polyapi 0.25.28 → 0.26.0

package/build/transpiler.js

@@ -10,11 +10,11 @@ const shelljs_1 = __importDefault(require("shelljs"));
 const typescript_1 = __importDefault(require("typescript"));
 const path_1 = __importDefault(require("path"));
 const ts_json_schema_generator_1 = require("ts-json-schema-generator");
+const helper_string_1 = require("@guanghechen/helper-string");
 const deployables_1 = require("./deployables");
 const utils_1 = require("./utils");
 const constants_1 = require("./constants");
 const api_1 = require("./api");
-const helper_string_1 = require("@guanghechen/helper-string");
 const EXCLUDED_REQUIREMENTS = [
     'assert',
     'buffer',
@@ -83,12 +83,30 @@ const getDependencies = async (code, fileName, baseUrl, ignoreDependencies) => {
     const getPropertyPath = (expr) => {
         const parts = [];
         let current = expr;
-        while (typescript_1.default.isPropertyAccessExpression(current)) {
-            parts.unshift(current.name.text);
-            current = current.expression;
-        }
-        if (typescript_1.default.isIdentifier(current)) {
-            parts.unshift(current.text);
+        while (true) {
+            if (typescript_1.default.isPropertyAccessExpression(current)) {
+                parts.unshift(current.name.text);
+                current = current.expression;
+                continue;
+            }
+            if (typescript_1.default.isElementAccessExpression(current)) {
+                const arg = current.argumentExpression;
+                if (arg && typescript_1.default.isStringLiteral(arg)) {
+                    parts.unshift(arg.text);
+                }
+                else if (arg && typescript_1.default.isNumericLiteral(arg)) {
+                    parts.unshift(arg.text);
+                }
+                else {
+                    parts.unshift('*');
+                }
+                current = current.expression;
+                continue;
+            }
+            if (typescript_1.default.isIdentifier(current)) {
+                parts.unshift(current.text);
+            }
+            break;
         }
         return parts.join('.');
     };
@@ -125,25 +143,30 @@ const getDependencies = async (code, fileName, baseUrl, ignoreDependencies) => {
                     return (sourceFile) => {
                         const visitor = (node) => {
                             if (typescript_1.default.isImportDeclaration(node)) {
-                                const moduleName = node.moduleSpecifier.text;
-                                if (!ignoreDependencies && moduleName === "polyapi" && node.importClause) {
+                                const moduleName = node.moduleSpecifier
+                                    .text;
+                                if (moduleName === 'polyapi' && node.importClause) {
                                     if (node.importClause.name) {
                                         polyImportIdentifier = `${node.importClause.name.text}.`;
                                         lookForInternalDependencies = true;
                                     }
-                                    if (node.importClause.namedBindings && typescript_1.default.isNamedImports(node.importClause.namedBindings)) {
-                                        for (const element of node.importClause.namedBindings.elements) {
-                                            const imported = element.propertyName ? element.propertyName.text : element.name.text;
+                                    if (node.importClause.namedBindings &&
+                                        typescript_1.default.isNamedImports(node.importClause.namedBindings)) {
+                                        for (const element of node.importClause.namedBindings
+                                            .elements) {
+                                            const imported = element.propertyName
+                                                ? element.propertyName.text
+                                                : element.name.text;
                                             const local = element.name.text;
-                                            if (imported === "vari") {
+                                            if (imported === 'vari') {
                                                 variImportIdentifier = `${local}.`;
                                                 lookForInternalDependencies = true;
                                             }
-                                            else if (imported === "tabi") {
+                                            else if (imported === 'tabi') {
                                                 tabiImportIdentifier = `${local}.`;
                                                 lookForInternalDependencies = true;
                                             }
-                                            else if (imported === "schemas") {
+                                            else if (imported === 'schemas') {
                                                 schemasImportIdentifier = `${local}.`;
                                                 lookForInternalDependencies = true;
                                             }
@@ -167,15 +190,20 @@ const getDependencies = async (code, fileName, baseUrl, ignoreDependencies) => {
                                 }
                                 return node;
                             }
-                            if (!ignoreDependencies && lookForInternalDependencies) {
+                            if (lookForInternalDependencies) {
                                 if (typescript_1.default.isVariableDeclaration(node) && node.initializer) {
                                     const initializer = unwrapExpression(node.initializer);
-                                    if (typescript_1.default.isIdentifier(node.name) && typescript_1.default.isPropertyAccessExpression(initializer)) {
+                                    if (typescript_1.default.isIdentifier(node.name) &&
+                                        typescript_1.default.isPropertyAccessExpression(initializer)) {
                                         const path = getPropertyPath(initializer);
-                                        if ((polyImportIdentifier && path.startsWith(polyImportIdentifier)) ||
-                                            (variImportIdentifier && path.startsWith(variImportIdentifier)) ||
-                                            (tabiImportIdentifier && path.startsWith(tabiImportIdentifier)) ||
-                                            (otherImportIdentifiers.length && otherImportIdentifiers.some(other => path.startsWith(other)))) {
+                                        if ((polyImportIdentifier &&
+                                            path.startsWith(polyImportIdentifier)) ||
+                                            (variImportIdentifier &&
+                                                path.startsWith(variImportIdentifier)) ||
+                                            (tabiImportIdentifier &&
+                                                path.startsWith(tabiImportIdentifier)) ||
+                                            (otherImportIdentifiers.length &&
+                                                otherImportIdentifiers.some((other) => path.startsWith(other)))) {
                                             if (node.name && typescript_1.default.isIdentifier(node.name)) {
                                                 aliasMap.set(node.name.text, path);
                                                 return node;
@@ -203,42 +231,95 @@ const getDependencies = async (code, fileName, baseUrl, ignoreDependencies) => {
                                             const root = path.split('.')[0];
                                             if (aliasMap.has(root)) {
                                                 const aliasBase = aliasMap.get(root);
-                                                path = aliasBase.split(".").concat(path.split('.').slice(1)).join('.');
+                                                path = aliasBase
+                                                    .split('.')
+                                                    .concat(path.split('.').slice(1))
+                                                    .join('.');
                                             }
-                                            if ((polyImportIdentifier && path.startsWith(polyImportIdentifier)) ||
-                                                (variImportIdentifier && path.startsWith(variImportIdentifier)) ||
-                                                (tabiImportIdentifier && path.startsWith(tabiImportIdentifier)) ||
-                                                (otherImportIdentifiers.length && otherImportIdentifiers.some(other => path.startsWith(other)))) {
+                                            if ((polyImportIdentifier &&
+                                                path.startsWith(polyImportIdentifier)) ||
+                                                (variImportIdentifier &&
+                                                    path.startsWith(variImportIdentifier)) ||
+                                                (tabiImportIdentifier &&
+                                                    path.startsWith(tabiImportIdentifier)) ||
+                                                (otherImportIdentifiers.length &&
+                                                    otherImportIdentifiers.some((other) => path.startsWith(other)))) {
                                                 aliasMap.set(localName, path);
                                             }
                                         }
                                         return node;
                                     }
                                 }
-                                else if (typescript_1.default.isPropertyAccessExpression(node) && !typescript_1.default.isPropertyAccessExpression(node.parent)) {
+                                else if (typescript_1.default.isPropertyAccessExpression(node) &&
+                                    !typescript_1.default.isPropertyAccessExpression(node.parent) &&
+                                    !typescript_1.default.isElementAccessExpression(node.parent)) {
                                     let path = getPropertyPath(node);
                                     const root = path.split('.')[0];
                                     if (aliasMap.has(root)) {
                                         const aliasBase = aliasMap.get(root);
-                                        path = aliasBase.split(".").concat(path.split('.').slice(1)).join('.');
+                                        path = aliasBase
+                                            .split('.')
+                                            .concat(path.split('.').slice(1))
+                                            .join('.');
                                     }
-                                    if (polyImportIdentifier && path.startsWith(polyImportIdentifier)) {
+                                    if (polyImportIdentifier &&
+                                        path.startsWith(polyImportIdentifier)) {
                                         internalReferences.add(path);
                                     }
-                                    else if (variImportIdentifier && path.startsWith(variImportIdentifier)) {
-                                        internalReferences.add(path.replace(VariMethods, ''));
+                                    else if (variImportIdentifier &&
+                                        path.startsWith(variImportIdentifier)) {
+                                        if (VariMethods.test(path)) {
+                                            internalReferences.add(path.replace(VariMethods, ''));
+                                        }
                                     }
-                                    else if (tabiImportIdentifier && path.startsWith(tabiImportIdentifier)) {
-                                        internalReferences.add(path.replace(TabiMethods, ''));
+                                    else if (tabiImportIdentifier &&
+                                        path.startsWith(tabiImportIdentifier)) {
+                                        if (TabiMethods.test(path)) {
+                                            internalReferences.add(path.replace(TabiMethods, ''));
+                                        }
                                     }
                                     else if (otherImportIdentifiers.length) {
-                                        const match = otherImportIdentifiers.find(other => path.startsWith(other));
+                                        const match = otherImportIdentifiers.find((other) => path.startsWith(other));
                                         if (match)
                                             internalReferences.add(path);
                                     }
                                 }
+                                else if (typescript_1.default.isCallExpression(node)) {
+                                    const target = unwrapExpression(node.expression);
+                                    if (typescript_1.default.isPropertyAccessExpression(target) ||
+                                        typescript_1.default.isElementAccessExpression(target)) {
+                                        let path = getPropertyPath(target);
+                                        const root = path.split('.')[0];
+                                        if (aliasMap.has(root)) {
+                                            const aliasBase = aliasMap.get(root);
+                                            path = aliasBase
+                                                .split('.')
+                                                .concat(path.split('.').slice(1))
+                                                .join('.');
+                                        }
+                                        if (polyImportIdentifier &&
+                                            path.startsWith(polyImportIdentifier)) {
+                                            internalReferences.add(path);
+                                        }
+                                        else if (variImportIdentifier &&
+                                            path.startsWith(variImportIdentifier)) {
+                                            if (VariMethods.test(path)) {
+                                                internalReferences.add(path.replace(VariMethods, ''));
+                                            }
+                                        }
+                                        else if (tabiImportIdentifier &&
+                                            path.startsWith(tabiImportIdentifier)) {
+                                            if (TabiMethods.test(path)) {
+                                                internalReferences.add(path.replace(TabiMethods, ''));
+                                            }
+                                        }
+                                        else if (otherImportIdentifiers.some((other) => path.startsWith(other))) {
+                                            internalReferences.add(path);
+                                        }
+                                    }
+                                }
                             }
-                            if (!ignoreDependencies && schemasImportIdentifier && typescript_1.default.isTypeReferenceNode(node)) {
+                            if (schemasImportIdentifier && typescript_1.default.isTypeReferenceNode(node)) {
                                 const path = flattenTypeName(node.typeName);
                                 if (path.startsWith(schemasImportIdentifier)) {
                                     internalReferences.add(path);
@@ -256,6 +337,7 @@ const getDependencies = async (code, fileName, baseUrl, ignoreDependencies) => {
     const dependencies = Array.from(importedLibraries).filter((library) => !EXCLUDED_REQUIREMENTS.includes(library));
     const externalDependencies = {};
     const internalDependencies = {};
+    let internalContexts = [];
     if (dependencies.length) {
         let packageJson = {};
         try {
@@ -269,7 +351,8 @@ const getDependencies = async (code, fileName, baseUrl, ignoreDependencies) => {
         const packageJsonDevDependencies = packageJson.devDependencies || {};
         for (const dependency of dependencies) {
             let dependencyName = dependency;
-            let version = packageJsonDependencies[dependencyName] || packageJsonDevDependencies[dependencyName];
+            let version = packageJsonDependencies[dependencyName] ||
+                packageJsonDevDependencies[dependencyName];
             if (version) {
                 externalDependencies[dependency] = version;
                 continue;
@@ -278,7 +361,9 @@ const getDependencies = async (code, fileName, baseUrl, ignoreDependencies) => {
             while (dependencyParts.length > 0) {
                 dependencyParts.pop();
                 dependencyName = dependencyParts.join('/');
-                version = packageJsonDependencies[dependencyName] || packageJsonDevDependencies[dependencyName];
+                version =
+                    packageJsonDependencies[dependencyName] ||
+                        packageJsonDevDependencies[dependencyName];
                 if (version) {
                     externalDependencies[dependencyName] = version;
                     break;
@@ -295,54 +380,86 @@ const getDependencies = async (code, fileName, baseUrl, ignoreDependencies) => {
         const found = [];
         let missing = [];
         const findReferencedSpecs = (toFind) => {
-            for (let path of toFind) {
+            for (const originalPath of toFind) {
                 let type;
+                let path = originalPath;
                 if (path.startsWith(polyImportIdentifier)) {
                     path = path.replace(polyImportIdentifier, '');
                 }
                 else if (path.startsWith(variImportIdentifier)) {
-                    type = "serverVariable";
+                    type = 'serverVariable';
                     path = path.replace(variImportIdentifier, '');
                 }
                 else if (path.startsWith(tabiImportIdentifier)) {
-                    type = "table";
+                    type = 'table';
                     path = path.replace(tabiImportIdentifier, '');
                 }
                 else if (path.startsWith(schemasImportIdentifier)) {
-                    type = "schema";
+                    type = 'schema';
                     path = path.replace(schemasImportIdentifier, '');
                 }
-                const spec = specs.find(s => {
-                    if (type) {
-                        if (type !== s.type)
-                            return false;
-                    }
-                    else if (['serverVariable', 'table', 'schema'].includes(s.type))
-                        return false;
-                    if (s.type === 'schema') {
-                        return s.contextName.split('.').map(s => (0, helper_string_1.toPascalCase)(s)).join('.') === path;
+                if (path.includes('.*')) {
+                    path = path.split('.*')[0];
+                    if (internalContexts.includes('*'))
+                        continue;
+                    if (!path) {
+                        internalContexts = ['*'];
                     }
-                    return s.contextName.toLowerCase() === path.toLowerCase();
-                });
-                if (spec) {
-                    found.push(spec);
-                    let type = spec.type;
-                    const dep = { path: spec.contextName, id: spec.id };
-                    if (spec.visibilityMetadata.visibility === 'PUBLIC' &&
-                        ['apiFunction', 'customFunction', 'serverFunction'].includes(type)) {
-                        type = `public${type.substring(0, 1).toUpperCase()}${type.substring(1)}`;
-                        dep['tenantName'] = spec.visibilityMetadata.foreignTenantName;
-                        dep['environmentName'] = spec.visibilityMetadata.foreignEnvironmentName;
+                    else {
+                        internalContexts.push(path);
                     }
-                    internalDependencies[type] = internalDependencies[type] || [];
-                    internalDependencies[type].push(dep);
                 }
                 else {
-                    missing.push(path);
+                    const spec = specs.find((s) => {
+                        if (type) {
+                            if (type !== s.type)
+                                return false;
+                        }
+                        else if (['serverVariable', 'table', 'schema'].includes(s.type))
+                            return false;
+                        if (s.type === 'schema') {
+                            return (s.contextName
+                                .split('.')
+                                .map((s) => (0, helper_string_1.toPascalCase)(s))
+                                .join('.') === path);
+                        }
+                        return s.contextName.toLowerCase() === path.toLowerCase();
+                    });
+                    if (spec) {
+                        found.push(spec);
+                        let type = spec.type;
+                        const dep = { path: spec.contextName, id: spec.id };
+                        if (spec.visibilityMetadata.visibility === 'PUBLIC' &&
+                            ['apiFunction', 'customFunction', 'serverFunction'].includes(type)) {
+                            type = `public${type
+                                .substring(0, 1)
+                                .toUpperCase()}${type.substring(1)}`;
+                            dep['tenantName'] = spec.visibilityMetadata.foreignTenantName;
+                            dep['environmentName'] =
+                                spec.visibilityMetadata.foreignEnvironmentName;
+                        }
+                        internalDependencies[type] = internalDependencies[type] || [];
+                        internalDependencies[type].push(dep);
+                    }
+                    else {
+                        missing.push(path);
+                    }
                 }
             }
         };
         findReferencedSpecs(internalReferences);
+        if (internalContexts.length) {
+            internalContexts.sort();
+            const toKeep = [];
+            for (const context of internalContexts) {
+                if (toKeep.find((c) => context.startsWith(c)))
+                    continue;
+                toKeep.push(context);
+            }
+            if (toKeep.length) {
+                internalDependencies.contexts = toKeep;
+            }
+        }
         if (missing.length && !fetchedSpecs) {
             specs = await (0, api_1.getSpecs)();
             (0, utils_1.writeCachedSpecs)(libPath, specs);
@@ -351,11 +468,16 @@ const getDependencies = async (code, fileName, baseUrl, ignoreDependencies) => {
             missing = [];
             findReferencedSpecs(toFind);
         }
-        if (missing.length) {
-            throw new Error(`Cannot resolve all poly resources referenced within function.\n\nMissing:\n${missing.map(n => `  '${n}'`).join('\n')}\n\nRerun command with '--ignore-dependencies' to skip resolving dependencies.`);
+        if (missing.length && !ignoreDependencies) {
+            throw new Error(`Cannot resolve all poly resources referenced within function.\n\nMissing:\n${missing
+                .map((n) => `  '${n}'`)
+                .join('\n')}\n\nRerun command with '--ignore-dependencies' to skip resolving dependencies.`);
         }
     }
-    return [dependencies.length ? externalDependencies : undefined, internalReferences.size && !ignoreDependencies ? internalDependencies : undefined];
+    return [
+        dependencies.length ? externalDependencies : undefined,
+        internalReferences.size ? internalDependencies : undefined,
+    ];
 };
 exports.getDependencies = getDependencies;
 const parseDeployComment = (comment) => {
@@ -545,14 +667,23 @@ const parseDeployableFunction = async (sourceFile, polyConfig, baseUrl, fileRevi
         polyConfig.description = functionDetails.types.description || '';
     }
     const [externalDependencies, internalDependencies] = await (0, exports.getDependencies)(sourceFile.getFullText(), sourceFile.fileName, baseUrl, true);
-    const typeSchemas = (0, exports.generateTypeSchemas)(sourceFile.fileName, deployables_1.DeployableTypeEntries.map(d => d[0]), polyConfig.name);
+    const referencedSchemas = internalDependencies && 'schema' in internalDependencies
+        ? Object.fromEntries(internalDependencies.schema.map((schema) => [
+            `schemas.${schema.path
+                .split('.')
+                .map((s) => (0, helper_string_1.toPascalCase)(s))
+                .join('.')}`,
+            { 'x-poly-ref': { path: schema.path } },
+        ]))
+        : null;
+    const typeSchemas = (0, exports.generateTypeSchemas)(sourceFile.fileName, deployables_1.DeployableTypeEntries.map((d) => d[0]), polyConfig.name, referencedSchemas);
     return {
         ...polyConfig,
         ...functionDetails,
         deployments,
         deploymentCommentRanges,
         externalDependencies,
-        internalDependencies,
+        internalDependencies: null,
         typeSchemas,
         fileRevision,
         gitRevision,
@@ -593,7 +724,8 @@ const parseDeployable = async (filePath, baseUrl, gitRevision) => {
     }
     catch (e) {
         shelljs_1.default.echo(chalk_1.default.redBright(`Prepared ${polyConfig.type.replaceAll('-', ' ')} ${polyConfig.context}.${polyConfig.name}: ERROR`));
-        shelljs_1.default.echo(chalk_1.default.red((e instanceof Error ? e.message : e.response?.data?.message) || 'Unexpected error.'));
+        shelljs_1.default.echo(chalk_1.default.red((e instanceof Error ? e.message : e.response?.data?.message) ||
+            'Unexpected error.'));
     }
 };
 exports.parseDeployable = parseDeployable;
@@ -601,14 +733,14 @@ const dereferenceSchema = (obj, definitions, visited = new Set()) => {
     if (!obj || typeof obj !== 'object')
         return obj;
     if (Array.isArray(obj)) {
-        return obj.map(item => dereferenceSchema(item, definitions, visited));
+        return obj.map((item) => dereferenceSchema(item, definitions, visited));
     }
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
         if (key === '$ref' && typeof value === 'string') {
             const match = value.match(/^#\/definitions\/(.+)$/);
             if (match) {
-                const defName = match[1];
+                const defName = decodeURIComponent(match[1]);
                 if (visited.has(defName)) {
                     return { $ref: value };
                 }
@@ -637,12 +769,15 @@ const dereferenceSchema = (obj, definitions, visited = new Set()) => {
 };
 const isInlineableDefinition = (definition, defName) => {
     const decodedDefName = decodeURIComponent(defName);
-    if (definition.type === 'object' && definition.properties &&
+    if (definition.type === 'object' &&
+        definition.properties &&
         Object.keys(definition.properties).length > 0) {
         return true;
     }
-    if (definition.type === 'array' && definition.items &&
-        typeof definition.items === 'object' && definition.items.type) {
+    if (definition.type === 'array' &&
+        definition.items &&
+        typeof definition.items === 'object' &&
+        definition.items.type) {
         return true;
     }
     if (['string', 'number', 'boolean', 'integer'].includes(definition.type)) {
@@ -654,8 +789,10 @@ const isInlineableDefinition = (definition, defName) => {
     if ((definition.anyOf || definition.allOf) && !decodedDefName.includes('<')) {
         return true;
     }
-    if (decodedDefName.includes('<') || decodedDefName.includes('>') ||
-        decodedDefName.includes('|') || decodedDefName.includes('&')) {
+    if (decodedDefName.includes('<') ||
+        decodedDefName.includes('>') ||
+        decodedDefName.includes('|') ||
+        decodedDefName.includes('&')) {
         return false;
     }
     return !/[<>%|&]/.test(decodedDefName);
@@ -667,7 +804,7 @@ const dereferenceRoot = (schema) => {
     if (schema.$ref) {
         const match = schema.$ref.match(/^#\/definitions\/(.+)$/);
         if (match) {
-            const defName = match[1];
+            const defName = decodeURIComponent(match[1]);
             const root = schema.definitions[defName];
             if (root) {
                 const { definitions, $schema, $ref, ...rest } = schema;
@@ -687,7 +824,7 @@ const dereferenceRoot = (schema) => {
         if (!obj || typeof obj !== 'object')
             return;
         if (Array.isArray(obj)) {
-            obj.forEach(item => findReferences(item, visited));
+            obj.forEach((item) => findReferences(item, visited));
             return;
         }
         for (const [key, value] of Object.entries(obj)) {
@@ -696,8 +833,11 @@ const dereferenceRoot = (schema) => {
                 if (match) {
                     const encodedDefName = match[1];
                     const decodedDefName = decodeURIComponent(encodedDefName);
-                    const actualDefName = definitions[encodedDefName] ? encodedDefName :
-                        definitions[decodedDefName] ? decodedDefName : null;
+                    const actualDefName = definitions[encodedDefName]
+                        ? encodedDefName
+                        : definitions[decodedDefName]
+                            ? decodedDefName
+                            : null;
                     if (actualDefName && !visited.has(actualDefName)) {
                         visited.add(actualDefName);
                         filteredDefinitions[actualDefName] = definitions[actualDefName];
@@ -713,7 +853,9 @@ const dereferenceRoot = (schema) => {
     findReferences(dereferencedRest);
     return {
         ...dereferencedRest,
-        ...(Object.keys(filteredDefinitions).length > 0 && { definitions: filteredDefinitions }),
+        ...(Object.keys(filteredDefinitions).length > 0 && {
+            definitions: filteredDefinitions,
+        }),
         $schema,
     };
 };
@@ -729,7 +871,20 @@ const extractTypesFromAST = (filePath, functionName) => {
     const extractFromTypeNode = (typeNode) => {
         if (typescript_1.default.isTypeReferenceNode(typeNode)) {
             const typeName = typeNode.typeName.getText(sourceFile);
-            const primitives = ['Promise', 'Array', 'Record', 'string', 'number', 'boolean', 'void', 'any', 'unknown', 'object', 'undefined', 'null'];
+            const primitives = [
+                'Promise',
+                'Array',
+                'Record',
+                'string',
+                'number',
+                'boolean',
+                'void',
+                'any',
+                'unknown',
+                'object',
+                'undefined',
+                'null',
+            ];
             if (!primitives.includes(typeName)) {
                 extractedTypes.add(typeName);
             }
@@ -739,7 +894,8 @@ const extractTypesFromAST = (filePath, functionName) => {
                 }
             }
         }
-        else if (typescript_1.default.isUnionTypeNode(typeNode) || typescript_1.default.isIntersectionTypeNode(typeNode)) {
+        else if (typescript_1.default.isUnionTypeNode(typeNode) ||
+            typescript_1.default.isIntersectionTypeNode(typeNode)) {
             for (const type of typeNode.types) {
                 extractFromTypeNode(type);
             }
@@ -762,15 +918,19 @@ const extractTypesFromAST = (filePath, functionName) => {
     return Array.from(extractedTypes);
 };
 exports.extractTypesFromAST = extractTypesFromAST;
-const generateTypeSchemas = (filePath, ignoredTypeNames = [], functionName) => {
+const generateTypeSchemas = (filePath, ignoredTypeNames = [], functionName, referencedSchemas = null) => {
     const tsconfigPath = path_1.default.resolve('tsconfig.json');
     const actualFunctionName = functionName || path_1.default.basename(filePath, '.ts');
     const extractedTypes = (0, exports.extractTypesFromAST)(filePath, actualFunctionName);
-    const typeNames = extractedTypes.filter(typeName => !ignoredTypeNames.includes(typeName));
+    const typeNames = extractedTypes.filter((typeName) => !ignoredTypeNames.includes(typeName));
     const output = {};
     for (const typeName of typeNames) {
         if (ignoredTypeNames.includes(typeName))
             continue;
+        if (referencedSchemas?.[typeName]) {
+            output[typeName] = referencedSchemas[typeName];
+            continue;
+        }
         try {
             const generator = (0, ts_json_schema_generator_1.createGenerator)({
                 path: filePath,