@bearer/openapi-generator/lib/index.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const path_1 = __importDefault(require("path"));
const typescript_1 = __importDefault(require("typescript"));
const openapi_template_1 = require("./openapi-template");
const convert_type_1 = require("./convert-type");
exports.FUNCTION_ACTION = 'action';
/**
 * find action method in class and return relevant node
 */
function findActionMethod(node) {
    const action = node.members.find((node) => {
        if (node.name) {
            return node.name.getText() === exports.FUNCTION_ACTION;
        }
        return false;
    });
    if (typescript_1.default.isPropertyDeclaration(action)) {
        return action.initializer;
    }
    return action;
}
function serializeBody(method, checker) {
    const symbol = checker.getSymbolAtLocation(method.name);
    let data;
    let error;
    if (symbol) {
        const returnTypeNode = method.type;
        const dataIndex = 0; // index of ReturnedData in TFetchPromise<ReturnedData, ReturnedError>
        const errorIndex = 1; // index of ReturnedError in TFetchPromise<ReturnedData, ReturnedError>
        if (returnTypeNode && typescript_1.default.isTypeReferenceNode(returnTypeNode)) {
            const typeData = checker.getTypeFromTypeNode(returnTypeNode.typeArguments[dataIndex]);
            data = convert_type_1.convertType(typeData, checker);
            const errorArgument = returnTypeNode.typeArguments[errorIndex];
            if (errorArgument) {
                const typeError = checker.getTypeFromTypeNode(errorArgument);
                error = convert_type_1.convertType(typeError, checker);
            }
        }
    }
    return { data, error };
}
/**
 *  Find the Parameter type in func and convert it to json-schema
 */
function serializeParameters(sym, node, checker) {
    if (sym) {
        const typ = checker.getTypeOfSymbolAtLocation(sym, node);
        if (typ.aliasTypeArguments) {
            return convert_type_1.convertType(typ.aliasTypeArguments[0], checker);
        }
    }
}
/**
 *  Find the auth context type and return it's name
 *  @param sym action method symbol
 *  @param node action method symbol value declaration
 *  @param checker program type checker
 */
function getFunctionAuthType(sym, node, checker) {
    if (sym) {
        const typ = checker.getTypeOfSymbolAtLocation(sym, node);
        if (typ.aliasTypeArguments) {
            const authType = checker.typeToString(typ.aliasTypeArguments[1]);
            if (/ApiKey/.test(authType))
                return 'APIKEY';
            if (/Basic/.test(authType))
                return 'BASIC';
            if (/OAuth1/.test(authType))
                return 'OAUTH1';
            if (/OAuth2/.test(authType))
                return 'OAUTH2';
            if (/None/.test(authType))
                return 'NONE';
            return authType;
        }
    }
    return;
}
/**
 *  Convert single func types to json schema
 *  This function tries to find the relevant type definitions, Params and `action` method resposne type
 *  and converts the types to json-schema
 *  @param functionPath absolute path to function
 *  @param options compiler options
 */
function functionTypesToSchemaConverter(functionPath, options = { target: typescript_1.default.ScriptTarget.ES5, module: typescript_1.default.ModuleKind.CommonJS }) {
    const program = typescript_1.default.createProgram([functionPath], options);
    const sourceFile = program.getSourceFile(functionPath);
    const checker = program.getTypeChecker();
    const output = {
        requestBody: {},
        response: {}
    };
    if (sourceFile) {
        typescript_1.default.forEachChild(sourceFile, visit);
    }
    return output;
    function visit(node) {
        // Only consider exported nodes
        if (!isNodeExported(node)) {
            return;
        }
        if (typescript_1.default.isClassDeclaration(node) && node.name) {
            const actionMethodNode = findActionMethod(node);
            if (actionMethodNode) {
                const parameterNode = actionMethodNode.parameters[0];
                const sym = checker.getSymbolAtLocation(parameterNode.name);
                output.requestBody = serializeParameters(sym, parameterNode, checker);
                output.response = serializeBody(actionMethodNode, checker);
                output.functionAuthType = getFunctionAuthType(sym, parameterNode, checker);
            }
        }
    }
    function isNodeExported(node) {
        return ((typescript_1.default.getCombinedModifierFlags(node) & typescript_1.default.ModifierFlags.Export) !== 0 ||
            (!!node.parent && node.parent.kind === typescript_1.default.SyntaxKind.SourceFile));
    }
}
exports.functionTypesToSchemaConverter = functionTypesToSchemaConverter;
/**
 *  Generate full openapi spec from functions
 *  @param functionsDir absolute path to functions directory
 *  @param functions list of func names
 *  @param buid integration unique identifier
 *  @param integrationName name of the integration
 */
function generator({ functionsDir, functions, buid, integrationName }) {
    const doc = openapi_template_1.topOfSpec(integrationName);
    const schemas = functions.sort().reduce((acc, func) => {
        const functionPath = path_1.default.join(functionsDir, `${func}.ts`);
        const typeSchema = functionTypesToSchemaConverter(functionPath);
        return Object.assign(acc, openapi_template_1.specPath({
            buid,
            functionName: func,
            response: { type: 'object', properties: typeSchema.response },
            requestBody: typeSchema.requestBody,
            oauth: typeSchema.functionAuthType === 'OAUTH2' || typeSchema.functionAuthType === 'OAUTH1'
        }));
    }, {});
    return JSON.stringify(Object.assign(doc, { paths: schemas }), null, 2);
}
exports.default = generator;