@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.INTENT_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.INTENT_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;
        let dataIndex = 0; // index of ReturnedData in TFetchPromise<ReturnedData, ReturnedError>
        let errorIndex = 1; // index of ReturnedError in TFetchPromise<ReturnedData, ReturnedError>
        const typeName = checker.typeToString(checker.getTypeFromTypeNode(returnTypeNode));
        if (typeName.startsWith('Promise<TSaveStatePayload')) {
            dataIndex = 1; // index of ReturnedData in TSavePromise<State, ReturnedData, ReturnedError>
            errorIndex = 2; // index of ReturnedData in TSavePromise<State, 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 };
}
function resolveParameterTypeIndex(t, checker, i, j) {
    let index = i;
    if (checker.typeToString(t).startsWith('TSaveActionEvent')) {
        index = j;
    }
    return index;
}
/**
 *  Find the Parameter type in intent and convert it to json-schema
 */
function serializeParameters(sym, node, checker) {
    if (sym) {
        const typ = checker.getTypeOfSymbolAtLocation(sym, node);
        if (typ.aliasTypeArguments) {
            const index = resolveParameterTypeIndex(typ, checker, 0, 1);
            return convert_type_1.convertType(typ.aliasTypeArguments[index], 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 getIntentAuthType(sym, node, checker) {
    if (sym) {
        const typ = checker.getTypeOfSymbolAtLocation(sym, node);
        if (typ.aliasTypeArguments) {
            const index = resolveParameterTypeIndex(typ, checker, 1, 2);
            const authType = checker.typeToString(typ.aliasTypeArguments[index]);
            if (/apiKey/.test(authType))
                return 'APIKEY';
            if (/username/.test(authType) && /password/.test(authType))
                return 'BASIC';
            if (/accessToken/.test(authType))
                return 'OAUTH2';
            if (/undefined/.test(authType))
                return 'NONE';
            return authType;
        }
    }
    return;
}
/**
 *  Convert single intent 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 intentPath absolute path to intent
 *  @param options compiler options
 */
function intentTypesToSchemaConverter(intentPath, options = { target: typescript_1.default.ScriptTarget.ES5, module: typescript_1.default.ModuleKind.CommonJS }) {
    const program = typescript_1.default.createProgram([intentPath], options);
    const sourceFile = program.getSourceFile(intentPath);
    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.intentAuthType = getIntentAuthType(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.intentTypesToSchemaConverter = intentTypesToSchemaConverter;
/**
 *  Generate full openapi spec from intents
 *  @param intentsDir absolute path to intents directory
 *  @param intents list of intent names
 *  @param integrationUuid integration unique identifier
 *  @param integrationName name of the integration
 */
function generator({ intentsDir, intents, integrationUuid, integrationName }) {
    const doc = openapi_template_1.topOfSpec(integrationName);
    const schemas = intents.sort().reduce((acc, intent) => {
        const intentPath = path_1.default.join(intentsDir, `${intent}.ts`);
        const typeSchema = intentTypesToSchemaConverter(intentPath);
        return Object.assign(acc, openapi_template_1.specPath({
            integrationUuid,
            intentName: intent,
            response: { type: 'object', properties: typeSchema.response },
            requestBody: typeSchema.requestBody,
            oauth2: typeSchema.intentAuthType === 'OAUTH2'
        }));
    }, {});
    return JSON.stringify(Object.assign(doc, { paths: schemas }), null, 2);
}
exports.default = generator;