@bearer/cli/lib/utils/generators.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const functions = require("@bearer/functions");
const fs = require("fs");
const globby = require("globby");
const path = require("path");
const ts = require("typescript");
const TJS = require("typescript-json-schema");
const openapi_generator_1 = require("@bearer/openapi-generator");
const config = ts.readConfigFile(path.join(__dirname, '../../templates/start', 'tsconfig.json'), ts.sys.readFile);
const NON_FUNCTION_NAMES = ['DBClient'];
const FUNCTION_NAMES = Object.keys(functions).filter(functionName => !NON_FUNCTION_NAMES.includes(functionName));
const FUNCTION_TYPE_IDENTIFIER = 'functionType';
const functionEntries = [];
function bodySchema(tsType, generator) {
    return {};
}
class FunctionNodeAdapter {
    constructor(functionName, node, 
    // @ts-ignore
    generator) {
        this.functionName = functionName;
        this.node = node;
        this.generator = generator;
    }
    get functionClassName() {
        return getIdentifier(this.node).escapedText.toString();
    }
    get functionType() {
        return getPropertyValue(this.node, FUNCTION_TYPE_IDENTIFIER);
    }
    get paramsSchema() {
        return [...DEFAULT_PARAMS];
    }
    adaptParamsSchema({ properties = {} }) {
        if (properties) {
            return Object.keys(properties).map(propName => {
                const { schema, required, name, description } = properties[propName];
                return {
                    schema: schema || { type: 'string' },
                    in: 'query',
                    description: description || propName,
                    required: required !== undefined ? required : true,
                    name: name || propName
                };
            });
        }
        return [];
    }
    get bodySchema() {
        return {
            properties: bodySchema(this.node, this.generator)
        };
    }
    get outputSchema() {
        return {};
    }
    get adapt() {
        return {
            functionClassName: this.functionClassName,
            functionName: this.functionName,
            functionType: this.functionType,
            paramsSchema: this.paramsSchema,
            bodySchema: this.bodySchema,
            outputSchema: this.outputSchema
        };
    }
}
function isFunctionClass(tsNode) {
    if (!ts.isClassDeclaration(tsNode)) {
        return false;
    }
    return extendsFunctionType(tsNode) && implementsAction(tsNode);
}
exports.isFunctionClass = isFunctionClass;
function extendsFunctionType(tsClass) {
    const extendedClasses = (tsClass.heritageClauses || []).filter(hc => hc.token === ts.SyntaxKind.ExtendsKeyword);
    return Boolean(extendedClasses.find(hc => Boolean(hc.types.find(t => FUNCTION_NAMES.includes(t.expression.escapedText.toString())))));
}
function implementsAction(tsClass) {
    return Boolean(tsClass.members.filter(m => {
        return ts.isMethodDeclaration(m);
    }));
}
function getIdentifier(tsNode) {
    return tsNode.name;
}
exports.getIdentifier = getIdentifier;
function getFunctionName(tsSourceFile) {
    return path.basename(tsSourceFile.fileName).split('.')[0];
}
exports.getFunctionName = getFunctionName;
function getPropertyValue(tsNode, propertyName) {
    if (tsNode.members) {
        const declaration = tsNode.members.find(node => {
            return ts.isPropertyDeclaration(node) && node.name.escapedText.toString() === propertyName;
        });
        if (declaration && declaration.initializer) {
            return declaration.initializer.text;
        }
    }
}
exports.getPropertyValue = getPropertyValue;
function transformer(generator) {
    return (context) => {
        return (tsSourceFile) => {
            function visit(tsNode) {
                if (isFunctionClass(tsNode)) {
                    const adapter = new FunctionNodeAdapter(getFunctionName(tsSourceFile), tsNode, generator);
                    functionEntries.push(adapter.adapt);
                }
                return tsNode;
            }
            return ts.visitEachChild(tsSourceFile, visit, context);
        };
    };
}
exports.transformer = transformer;
class FunctionCodeProcessor {
    constructor(srcFunctionsDir, transformer) {
        this.srcFunctionsDir = srcFunctionsDir;
        this.transformer = transformer;
    }
    async run() {
        const files = await globby(`${this.srcFunctionsDir}/*.ts`);
        files.forEach(file => {
            const sourceFile = ts.createSourceFile(file, fs.readFileSync(file, 'utf8'), ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
            ts.transform(sourceFile, [this.transformer]);
        });
    }
}
exports.FunctionCodeProcessor = FunctionCodeProcessor;
class OpenApiSpecGenerator {
    constructor(srcFunctionsDir, bearerConfig) {
        this.srcFunctionsDir = srcFunctionsDir;
        this.bearerConfig = bearerConfig;
    }
    async build() {
        const files = await globby(`${this.srcFunctionsDir}/*.ts`);
        const programGenerator = TJS.getProgramFromFiles(files, Object.assign({}, config.config.compilerOptions, { allowUnusedLabels: true, 
            // be indulgent
            noUnusedParameters: false, noUnusedLocals: false }), './ok');
        const generator = TJS.buildGenerator(programGenerator, {
            required: true
        });
        if (!generator) {
            throw new Error('Please fix above issues before');
        }
        files.forEach(file => {
            const sourceFile = ts.createSourceFile(file, fs.readFileSync(file, 'utf8'), ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
            ts.transform(sourceFile, [transformer(generator)]);
        });
        return openapi_generator_1.default({
            functions: functionEntries.map(entry => entry.functionName),
            functionsDir: this.srcFunctionsDir,
            buid: this.bearerConfig.buid,
            integrationName: this.bearerConfig.integrationTitle || ''
        });
    }
}
exports.OpenApiSpecGenerator = OpenApiSpecGenerator;
const DEFAULT_PARAMS = [
    {
        in: 'header',
        name: 'authorization',
        schema: {
            type: 'string'
        },
        description: 'API Key',
        required: true
    }
];