polyapi 0.23.2 → 0.23.4

package/build/client/src/commands/{generate.js → generate/types.js}

@@ -26,305 +26,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSingleCustomFunction = exports.generate = exports.generateSpecs = void 0;
+exports.generateVariablesTSDeclarationFile = exports.generateFunctionsTSDeclarationFile = exports.getGenerationErrors = exports.setGenerationErrors = void 0;
 const fs_1 = __importDefault(require("fs"));
 const handlebars_1 = __importDefault(require("handlebars"));
-const chalk_1 = __importDefault(require("chalk"));
-const shelljs_1 = __importDefault(require("shelljs"));
 const helper_string_1 = require("@guanghechen/helper-string");
-const prettier_1 = __importDefault(require("prettier"));
 const json_schema_to_typescript_1 = require("json-schema-to-typescript");
 const ts = __importStar(require("typescript"));
-const uuid_1 = require("uuid");
-const jsonpath_1 = __importDefault(require("jsonpath"));
-const utils_1 = require("../../../common/src/utils");
-const specs_1 = require("../../../common/src/specs");
-const api_1 = require("../api");
-const config_1 = require("../config");
-const utils_2 = require("../utils");
-const constants_1 = require("../constants");
-const index_1 = require("../../../common/src/json-schema/index");
+const utils_1 = require("../../../../common/src/utils");
+const specs_1 = require("../../../../common/src/specs");
+const utils_2 = require("../../utils");
+const index_1 = require("../../../../common/src/json-schema/index");
 let generationErrors = false;
-const getApiBaseUrl = () => process.env.POLY_API_BASE_URL || 'http://localhost:8000';
-const getApiKey = () => process.env.POLY_API_KEY;
-const prepareDir = async (polyPath) => {
-    const libPath = (0, utils_2.getPolyLibPath)(polyPath);
-    fs_1.default.rmSync(libPath, { recursive: true, force: true });
-    fs_1.default.mkdirSync(libPath, { recursive: true });
-    fs_1.default.mkdirSync(`${libPath}/api`);
-    fs_1.default.mkdirSync(`${libPath}/client`);
-    fs_1.default.mkdirSync(`${libPath}/auth`);
-    fs_1.default.mkdirSync(`${libPath}/webhooks`);
-    fs_1.default.mkdirSync(`${libPath}/server`);
-    fs_1.default.mkdirSync(`${libPath}/vari`);
-    fs_1.default.mkdirSync(`${libPath}/schemas`);
-    if (polyPath !== constants_1.DEFAULT_POLY_PATH) {
-        try {
-            await generateRedirectIndexFiles(polyPath);
-        }
-        catch (err) {
-            console.warn(`Could not generate redirect index files: ${err.message}, continuing...`);
-        }
-    }
-};
-const generateRedirectIndexFiles = async (polyPath) => {
-    const defaultPolyLib = (0, utils_2.getPolyLibPath)(constants_1.DEFAULT_POLY_PATH);
-    fs_1.default.rmSync(defaultPolyLib, { recursive: true, force: true });
-    fs_1.default.mkdirSync(defaultPolyLib, { recursive: true });
-    const indexRedirectJSTemplate = handlebars_1.default.compile(await loadTemplate('index-redirect.js.hbs'));
-    fs_1.default.writeFileSync(`${defaultPolyLib}/index.js`, indexRedirectJSTemplate({
-        polyPath: polyPath.startsWith('/') ? polyPath : `../../../${polyPath}`,
-    }));
-    const indexTSRedirectJSTemplate = handlebars_1.default.compile(await loadTemplate('index-redirect.d.ts.hbs'));
-    fs_1.default.writeFileSync(`${defaultPolyLib}/index.d.ts`, indexTSRedirectJSTemplate({
-        polyPath: polyPath.startsWith('/') ? polyPath : `../../../${polyPath}`,
-    }));
-};
-const loadTemplate = async (fileName) => fs_1.default.readFileSync(`${__dirname}/../templates/${fileName}`, 'utf8');
-const generateJSFiles = async (libPath, specs) => {
-    const apiFunctions = specs.filter((spec) => spec.type === 'apiFunction');
-    const customFunctions = specs
-        .filter((spec) => spec.type === 'customFunction')
-        .filter((spec) => spec.language === 'javascript');
-    const webhookHandles = specs.filter((spec) => spec.type === 'webhookHandle');
-    const authFunctions = specs.filter((spec) => spec.type === 'authFunction');
-    const serverFunctions = specs.filter((spec) => spec.type === 'serverFunction');
-    const serverVariables = specs.filter((spec) => spec.type === 'serverVariable');
-    await generateIndexJSFile(libPath);
-    await generatePolyCustomJSFile(libPath);
-    await generateAxiosJSFile(libPath);
-    await generateErrorHandlerFile(libPath);
-    await generateApiFunctionJSFiles(libPath, apiFunctions);
-    const customFnCodeGenerationErrors = await generateCustomFunctionJSFiles(libPath, customFunctions);
-    await generateWebhooksJSFiles(libPath, webhookHandles);
-    await generateAuthFunctionJSFiles(libPath, authFunctions);
-    await generateServerFunctionJSFiles(libPath, serverFunctions);
-    await generateServerVariableJSFiles(libPath, serverVariables);
-    return customFnCodeGenerationErrors;
-};
-const generateIndexJSFile = async (libPath) => {
-    const indexJSTemplate = handlebars_1.default.compile(await loadTemplate('index.js.hbs'));
-    fs_1.default.writeFileSync(`${libPath}/index.js`, indexJSTemplate({
-        clientID: (0, uuid_1.v4)(),
-        apiBaseUrl: getApiBaseUrl(),
-        apiKey: getApiKey(),
-    }));
-};
-const generatePolyCustomJSFile = async (libPath) => {
-    const polyCustomJSTemplate = handlebars_1.default.compile(await loadTemplate('poly-custom.js.hbs'));
-    fs_1.default.writeFileSync(`${libPath}/poly-custom.js`, polyCustomJSTemplate({
-        apiBaseUrl: getApiBaseUrl(),
-        apiKey: getApiKey(),
-    }));
-};
-const generateAxiosJSFile = async (libPath) => {
-    const axiosJSTemplate = handlebars_1.default.compile(await loadTemplate('axios.js.hbs'));
-    fs_1.default.writeFileSync(`${libPath}/axios.js`, axiosJSTemplate({
-        apiBaseUrl: getApiBaseUrl(),
-        apiKey: getApiKey(),
-    }));
-};
-const generateErrorHandlerFile = async (libPath) => {
-    const errorHandlerJSTemplate = handlebars_1.default.compile(await loadTemplate('error-handler.js.hbs'));
-    fs_1.default.writeFileSync(`${libPath}/error-handler.js`, errorHandlerJSTemplate({}));
-};
-const generateApiFunctionJSFiles = async (libPath, specifications) => {
-    const template = handlebars_1.default.compile(await loadTemplate('api-index.js.hbs'));
-    fs_1.default.writeFileSync(`${libPath}/api/index.js`, template({
-        specifications,
-    }));
-};
-const generateCustomFunctionJSFiles = async (libPath, specifications) => {
-    const codeGenerationErrors = [];
-    const generateCustomIndexJSTemplate = async () => {
-        const customIndexJSTemplate = handlebars_1.default.compile(await loadTemplate('custom-index.js.hbs'));
-        fs_1.default.writeFileSync(`${libPath}/client/index.js`, customIndexJSTemplate({
-            specifications: specifications.filter(spec => !codeGenerationErrors.find(error => error.specification.id === spec.id)),
-        }));
-    };
-    if (specifications.length === 0) {
-        await generateCustomIndexJSTemplate();
-        return [];
-    }
-    const customFunctionJSTemplate = handlebars_1.default.compile(await loadTemplate('custom-function.js.hbs'));
-    for (const spec of specifications) {
-        try {
-            fs_1.default.writeFileSync(`${libPath}/client/${spec.context ? `${spec.context}-` : ''}${spec.name}.js`, await prettyPrint(customFunctionJSTemplate(spec), 'babel'));
-        }
-        catch (error) {
-            codeGenerationErrors.push({
-                stack: error.stack,
-                specification: spec,
-            });
-        }
-    }
-    await generateCustomIndexJSTemplate();
-    return codeGenerationErrors;
-};
-const generateWebhooksJSFiles = async (libPath, specifications) => {
-    const template = handlebars_1.default.compile(await loadTemplate('webhooks-index.js.hbs'));
-    fs_1.default.writeFileSync(`${libPath}/webhooks/index.js`, template({
-        specifications,
-        apiKey: getApiKey(),
-    }));
-};
-const generateServerFunctionJSFiles = async (libPath, specifications) => {
-    const serverIndexJSTemplate = handlebars_1.default.compile(await loadTemplate('server-index.js.hbs'));
-    fs_1.default.writeFileSync(`${libPath}/server/index.js`, serverIndexJSTemplate({
-        specifications,
-    }));
-};
-const generateServerVariableJSFiles = async (libPath, specifications) => {
-    const contextData = (0, specs_1.getContextData)(specifications);
-    const contextPaths = getContextPaths(contextData);
-    const template = handlebars_1.default.compile(await loadTemplate('vari/index.js.hbs'));
-    const arrPaths = [];
-    for (const specification of specifications) {
-        if ((0, utils_1.isPlainObjectPredicate)(specification.variable.value) || Array.isArray(specification.variable.value)) {
-            arrPaths.push({
-                context: specification.context || '',
-                paths: getStringPaths(specification.variable.value),
-            });
-        }
-    }
-    fs_1.default.writeFileSync(`${libPath}/vari/index.js`, template({
-        specifications,
-        contextPaths,
-        apiKey: getApiKey(),
-        arrPaths: JSON.stringify(arrPaths),
-    }));
-};
-const generateAuthFunctionJSFiles = async (libPath, specifications) => {
-    const authIndexJSTemplate = handlebars_1.default.compile(await loadTemplate('auth-index.js.hbs'));
-    fs_1.default.writeFileSync(`${libPath}/auth/index.js`, authIndexJSTemplate({
-        getTokenFunctions: specifications.filter((spec) => spec.name === 'getToken'),
-        subResourceFunctions: specifications.filter((spec) => spec.subResource),
-        apiBaseUrl: getApiBaseUrl(),
-        apiKey: getApiKey(),
-    }));
-    if (specifications.length === 0) {
-        return;
-    }
-    const authFunctionJSTemplate = handlebars_1.default.compile(await loadTemplate('auth-function.js.hbs'));
-    for (const spec of specifications.filter((spec) => !spec.subResource)) {
-        fs_1.default.writeFileSync(`${libPath}/auth/${spec.context ? `${spec.context}-` : ''}${spec.name}.js`, await prettyPrint(authFunctionJSTemplate({
-            ...spec,
-            audienceRequired: spec.function.arguments.some((arg) => arg.name === 'audience'),
-            apiBaseUrl: getApiBaseUrl(),
-            apiKey: getApiKey(),
-        }), 'babel'));
-    }
-};
-const generateTSDeclarationFilesForContext = async (libPath, context, contextData, pathPrefix, contextCollector = []) => {
-    const contextDataKeys = Object.keys(contextData);
-    const contextDataSpecifications = contextDataKeys
-        .map((key) => contextData[key])
-        .filter((value) => typeof value.type === 'string');
-    const contextDataSubContexts = contextDataKeys
-        .filter((key) => !contextData[key].type)
-        .map((key) => {
-        const path = `${context.path ? `${context.path}.` : ''}${key}`;
-        return {
-            name: key,
-            path,
-            fileName: `${path}.d.ts`,
-            interfaceName: (0, helper_string_1.toPascalCase)(path),
-            level: context.level + 1,
-        };
-    });
-    await generateTSContextDeclarationFile(libPath, context, contextDataSpecifications, contextDataSubContexts, pathPrefix);
-    contextCollector = [...contextCollector, context];
-    for await (const subContext of contextDataSubContexts) {
-        contextCollector = await generateTSDeclarationFilesForContext(libPath, subContext, contextData[subContext.name], pathPrefix, contextCollector);
-    }
-    return contextCollector;
-};
-const assignUnresolvedRefsToPolySchemaRefObj = (schemaDefinition, unresolvedPolySchemaRefs = []) => {
-    (0, index_1.iterateRefs)(schemaDefinition, schema => {
-        const ref = schema['x-poly-ref'];
-        if (ref !== null && typeof ref === 'object' && !Array.isArray(ref)) {
-            const foundUnresolved = unresolvedPolySchemaRefs.find(unresolvedPolySchemaRef => unresolvedPolySchemaRef.path === ref.path && unresolvedPolySchemaRef.publicNamespace === ref.publicNamespace);
-            if (foundUnresolved) {
-                schema['x-poly-ref']['x-unresolved'] = true;
-            }
-            schema.description = `<path>${ref.publicNamespace ? `${ref.publicNamespace}.${ref.path}` : ref.path}</path>`;
-        }
-        return schema;
-    }, 'x-poly-ref');
-};
-const generateFunctionsTSDeclarationFile = async (libPath, specs) => {
-    await generateTSDeclarationFiles(libPath, specs.filter(spec => 'function' in spec).map((spec) => {
-        for (const functionArg of spec.function.arguments) {
-            if (functionArg.type.kind === 'object' && functionArg.type.schema) {
-                assignUnresolvedRefsToPolySchemaRefObj(functionArg.type.schema, functionArg.type.unresolvedPolySchemaRefs);
-            }
-            else if (functionArg.type.kind === 'object' && functionArg.type.properties) {
-                for (const property of functionArg.type.properties) {
-                    if (property.type.kind === 'object') {
-                        assignUnresolvedRefsToPolySchemaRefObj(property.type.schema, functionArg.type.unresolvedPolySchemaRefs);
-                    }
-                }
-            }
-        }
-        if (spec.function.returnType.kind === 'object' && spec.function.returnType.schema) {
-            assignUnresolvedRefsToPolySchemaRefObj(spec.function.returnType.schema, spec.function.returnType.unresolvedPolySchemaRefs);
-        }
-        return spec;
-    }), 'Poly', '.');
-};
-const generateSchemasTSDeclarationFile = async (libPath, specs) => {
-    await generateTSDeclarationFiles(libPath, specs.filter(spec => spec.type === 'schema').map((spec) => {
-        assignUnresolvedRefsToPolySchemaRefObj(spec.definition, spec.unresolvedPolySchemaRefs);
-        return spec;
-    }), 'Schemas', 'schemas');
-};
-const generateVariablesTSDeclarationFile = async (libPath, specs) => await generateTSDeclarationFiles(libPath, specs.filter(spec => 'variable' in spec), 'Vari', 'vari');
-const generateTSDeclarationFiles = async (libPath, specs, interfaceName, pathPrefix) => {
-    const contextData = (0, specs_1.getContextData)(specs);
-    const contexts = await generateTSDeclarationFilesForContext(libPath, {
-        name: '',
-        path: '',
-        interfaceName,
-        fileName: 'default.d.ts',
-        level: 0,
-    }, contextData, pathPrefix);
-    await generateTSIndexDeclarationFile(libPath, contexts, pathPrefix);
-};
-const generateTSIndexDeclarationFile = async (libPath, contexts, pathPrefix) => {
-    const template = handlebars_1.default.compile(await loadTemplate(`${pathPrefix}/index.d.ts.hbs`));
-    fs_1.default.writeFileSync(`${libPath}/${pathPrefix}/index.d.ts`, await prettyPrint(template({
-        contexts: contexts.map((context) => ({
-            ...context,
-            firstLevel: context.level === 1,
-        })),
-    })));
-};
-const getStringPaths = (data) => {
-    const paths = jsonpath_1.default.paths(data, '$..*', 100);
-    const stringPaths = [];
-    for (let i = 0; i < paths.length; i++) {
-        let stringPath = '';
-        for (const part of paths[i]) {
-            const isString = typeof part === 'string';
-            const delimiter = (stringPath.length > 0 && isString) ? '.' : '';
-            if (isString) {
-                stringPath = `${stringPath}${delimiter}${part}`;
-            }
-            else {
-                stringPath = `${stringPath}${delimiter}[${part}]`;
-            }
-        }
-        stringPaths.push(stringPath);
-    }
-    return stringPaths;
+const setGenerationErrors = (value) => {
+    generationErrors = value;
 };
+exports.setGenerationErrors = setGenerationErrors;
+const getGenerationErrors = () => generationErrors;
+exports.getGenerationErrors = getGenerationErrors;
 const schemaToDeclarations = async (namespace, typeName, schema, value, options = {
     unknownAny: true,
 }) => {
     const wrapToNamespace = (code) => `namespace ${namespace} {\n  ${code}\n}`;
     const appendPathUnionType = (code, value) => {
         if (Array.isArray(value) || (0, utils_1.isPlainObjectPredicate)(value)) {
-            const unionPath = getStringPaths(value).map(value => `'${value}'`);
+            const unionPath = (0, utils_2.getStringPaths)(value).map(value => `'${value}'`);
             const pathValue = unionPath.join(' | ') || '\'\'';
             return `${code}\nexport type PathValue = ${pathValue}`;
         }
@@ -419,7 +144,7 @@ const schemaToDeclarations = async (namespace, typeName, schema, value, options
         const [, path] = matchPathNameCommentInCode;
         if (['$ReturnType', '$Argument'].includes(argumentOrReturnType)) {
             if (isResolved) {
-                const typePath = [...path.split('.'), 'Schema'].map(helper_string_1.toPascalCase).join('.');
+                const typePath = `schemas.${path.split('.').map(helper_string_1.toPascalCase).join('.')}`;
                 result = result.replace(polySchemaInterfaceDeclaration.code, `export interface ${argumentOrReturnType.replace('$', '')} extends ${typePath} {}`);
             }
             else {
@@ -452,24 +177,14 @@ const schemaToDeclarations = async (namespace, typeName, schema, value, options
     }
     for (const polySchemaTypeReference of polySchemaTypeReferenceList) {
         const polySchemaTypeReferenceParts = getPolySchemaTypeParts(polySchemaTypeReference.name);
-        polySchemaTypeReferenceParts.push('Schema');
-        const [, , , resolvedStatus, ...realContextParts] = polySchemaTypeReferenceParts;
+        const [, , , resolvedStatus] = polySchemaTypeReferenceParts;
         const isResolved = resolvedStatus === '$Resolved';
         if (isResolved) {
             const realPathParts = polySchemaTypeReference.path.split('.').map(helper_string_1.toPascalCase);
-            realPathParts.push('Schema');
-            result = result.replace(polySchemaTypeReference.name, realPathParts.join('.'));
+            result = result.replace(polySchemaTypeReference.name, `schemas.${realPathParts.join('.')}`);
         }
         else {
-            if (polySchemaTypeReference.replacement) {
-                const replacementParts = getPolySchemaTypeParts(polySchemaTypeReference.replacement);
-                const [, , , , ...realContextParts] = replacementParts;
-                realContextParts.push('Schema');
-                result = result.replace(polySchemaTypeReference.name, realContextParts.join('$'));
-            }
-            else {
-                result = result.replace(polySchemaTypeReference.name, realContextParts.join('$'));
-            }
+            result = result.replace(polySchemaTypeReference.name, 'unknown');
         }
     }
     return wrapToNamespace(appendPathUnionType(result, value));
@@ -506,6 +221,71 @@ const getArgumentsTypeDeclarations = async (namespacePath, parentType, propertie
     }
     return typeDeclarations;
 };
+const getIDComment = (specification) => {
+    switch (specification.type) {
+        case 'apiFunction':
+        case 'serverFunction':
+        case 'customFunction':
+            return `* Function ID: ${specification.id}`;
+        case 'authFunction':
+            return `* Auth provider ID: ${specification.id}`;
+        case 'webhookHandle':
+            return `* Webhook ID: ${specification.id}`;
+        default:
+            return null;
+    }
+};
+const getAdditionalComments = (specification) => {
+    switch (specification.type) {
+        case 'customFunction':
+            if (!specification.requirements.length) {
+                return null;
+            }
+            return `This function requires you to have the following libraries installed:\n- ${specification.requirements.join('\n- ')}`;
+        default:
+            return null;
+    }
+};
+const getSpecificationWithFunctionComment = (specification) => {
+    const descriptionComment = specification.description
+        ? specification.description
+            .split('\n')
+            .map((line) => `* ${line}`)
+            .join('\n')
+        : null;
+    const toArgumentComment = (arg, prefix = '') => {
+        if (arg.name === 'payload' && arg.type.kind === 'object' && arg.type.properties) {
+            return arg.type.properties
+                .map(payloadProperty => toArgumentComment(payloadProperty, 'payload.'))
+                .filter(Boolean)
+                .join('\n');
+        }
+        if (!arg.description) {
+            return null;
+        }
+        return `* @param ${prefix}${arg.name} ${arg.description}`;
+    };
+    const argumentsComment = specification.function.arguments
+        .map(arg => toArgumentComment(arg))
+        .filter(Boolean)
+        .join('\n');
+    const additionalComments = getAdditionalComments(specification);
+    const idComment = getIDComment(specification);
+    return `${descriptionComment ? `${descriptionComment}\n` : ''}${argumentsComment ? `${argumentsComment}\n` : ''}${additionalComments ? `${additionalComments}\n` : ''}${idComment ? `*\n${idComment}\n` : ''}`.trim();
+};
+const getSpecificationWithVariableComment = (specification) => {
+    const descriptionComment = specification.description
+        ? specification.description
+            .split('\n')
+            .map((line) => `* ${line}`)
+            .join('\n')
+        : null;
+    const secretComment = specification.variable.secret
+        ? '* Note: The variable is secret and can be used only within Poly functions.'
+        : null;
+    const idComment = `* Variable ID: ${specification.id}`;
+    return `${descriptionComment ? `${descriptionComment}\n` : ''}${secretComment ? `${secretComment}\n` : ''}${idComment ? `*\n${idComment}` : ''}`.trim();
+};
 const getVariableValueTypeDeclarations = async (namespacePath, namespace, objectProperty, value) => {
     const declarations = await schemaToDeclarations(namespace, 'ValueType', objectProperty.schema, value, {
         unknownAny: false,
@@ -520,7 +300,7 @@ const getSpecificationsTypeDeclarations = async (namespacePath, specifications)
             return await getDeclaration();
         }
         catch (error) {
-            generationErrors = true;
+            (0, exports.setGenerationErrors)(true);
             errors.push({
                 specification,
                 stack: error.stack,
@@ -533,9 +313,21 @@ const getSpecificationsTypeDeclarations = async (namespacePath, specifications)
         .map((spec) => spec)
         .map((spec) => getDeclarationOrHandleError(() => getArgumentsTypeDeclarations(namespacePath, (0, helper_string_1.toPascalCase)(spec.name), spec.function.arguments), spec)))).flat();
     const returnTypeDeclarations = await Promise.all(specifications
-        .filter((spec) => 'function' in spec && spec.function.returnType.kind === 'object' && spec.function.returnType.schema && !(0, specs_1.isBinary)(spec.function.returnType))
+        .filter((spec) => 'function' in spec &&
+        ((spec.function.returnType.kind === 'object' &&
+            spec.function.returnType.schema &&
+            !(0, specs_1.isBinary)(spec.function.returnType)) ||
+            (spec.type === 'serverFunction' && spec.serverSideAsync === true)))
         .map((spec) => spec)
-        .map((spec) => getDeclarationOrHandleError(() => getObjectTypeDeclarations(namespacePath, (0, helper_string_1.toPascalCase)(spec.name), spec.function.returnType, 'ReturnType'), spec)));
+        .map((spec) => {
+        if (spec.type === 'serverFunction' && spec.serverSideAsync === true) {
+            const ns = (0, helper_string_1.toPascalCase)(spec.name);
+            return Promise.resolve(`namespace ${ns} {\n  export type ReturnType = { executionId: string };\n}`);
+        }
+        else {
+            return getDeclarationOrHandleError(() => getObjectTypeDeclarations(namespacePath, (0, helper_string_1.toPascalCase)(spec.name), spec.function.returnType, 'ReturnType'), spec);
+        }
+    }));
     const variableValueDeclarations = await Promise.all(specifications
         .filter((spec) => 'variable' in spec && spec.variable.valueType.kind === 'object' && spec.variable.valueType.schema)
         .map((spec) => spec)
@@ -547,13 +339,13 @@ const getSpecificationsTypeDeclarations = async (namespacePath, specifications)
     }, 'Schema'), spec)));
     if (errors.length) {
         errors.forEach((err) => {
-            echoGenerationError(err.specification);
+            (0, utils_2.echoGenerationError)(err.specification);
         });
     }
     return [...argumentsTypeDeclarations, ...returnTypeDeclarations, ...variableValueDeclarations, ...schemaDeclarations].join('\n');
 };
 const generateTSContextDeclarationFile = async (libPath, context, specifications, subContexts, pathPrefix) => {
-    const template = handlebars_1.default.compile(await loadTemplate(`${pathPrefix}/{{context}}.d.ts.hbs`));
+    const template = handlebars_1.default.compile((0, utils_2.loadTemplate)(`${pathPrefix}/{{context}}.d.ts.hbs`));
     const contextPaths = context.path === '' ? [] : context.path.split('.').map(helper_string_1.toPascalCase);
     const typeDeclarations = await getSpecificationsTypeDeclarations(contextPaths.join('.'), specifications);
     const toFunctionDeclaration = (specification) => {
@@ -573,12 +365,20 @@ const generateTSContextDeclarationFile = async (libPath, context, specifications
             }
             return returnType;
         };
+        let computedReturnType;
+        if (specification.type === 'serverFunction' &&
+            specification.serverSideAsync === true) {
+            computedReturnType = `${context.interfaceName}.${(0, helper_string_1.toPascalCase)(specification.name)}.ReturnType`;
+        }
+        else {
+            computedReturnType = (0, specs_1.toTypeDeclaration)(specification.function.returnType);
+        }
         return {
             name: specification.name.split('.').pop(),
             comment: getSpecificationWithFunctionComment(specification),
             deprecated: specification.state === 'DEPRECATED',
             arguments: specification.function.arguments.map(toArgumentDeclaration),
-            returnType: wrapInResponseType((0, specs_1.toTypeDeclaration)(specification.function.returnType)),
+            returnType: wrapInResponseType(computedReturnType),
             synchronous: specification.type === 'serverFunction' ? false : specification.function.synchronous === true,
         };
     };
@@ -599,10 +399,11 @@ const generateTSContextDeclarationFile = async (libPath, context, specifications
         const contextParts = specification.context.split('.').filter(v => v);
         return {
             name: specification.name.split('.').pop(),
-            typeDeclaration: contextParts.length ? `${specification.context.split('.').map(helper_string_1.toPascalCase).join('.')}.${(0, helper_string_1.toPascalCase)(specification.name)}.Schema` : `${(0, helper_string_1.toPascalCase)(specification.name)}.Schema`,
+            typeDeclaration: contextParts.length ? `${specification.context.split('.').map(helper_string_1.toPascalCase).join('.')}.${(0, helper_string_1.toPascalCase)(specification.name)}` : `${(0, helper_string_1.toPascalCase)(specification.name)}`,
         };
     };
-    fs_1.default.writeFileSync(`${libPath}/${pathPrefix}/${context.fileName}`, await prettyPrint(template({
+    const outputPath = `${libPath}/${pathPrefix}/${context.fileName}`;
+    fs_1.default.writeFileSync(outputPath, await (0, utils_2.prettyPrint)(template({
         interfaceName: context.interfaceName,
         contextPaths,
         typeDeclarations,
@@ -616,214 +417,84 @@ const generateTSContextDeclarationFile = async (libPath, context, specifications
         subContexts,
     })));
 };
-const getContextPaths = (contextData) => {
-    const paths = [];
-    const traverseAndAddPath = (data, path = '') => {
-        for (const key of Object.keys(data)) {
-            if (typeof data[key].context === 'string') {
-                continue;
+const generateTSDeclarationFilesForContext = async (libPath, context, contextData, pathPrefix, contextCollector = []) => {
+    const contextDataKeys = Object.keys(contextData);
+    const contextDataSpecifications = contextDataKeys
+        .map((key) => contextData[key])
+        .filter((value) => typeof value.type === 'string');
+    const contextDataSubContexts = contextDataKeys
+        .filter((key) => !contextData[key].type)
+        .map((key) => {
+        const path = `${context.path ? `${context.path}.` : ''}${key}`;
+        return {
+            name: key,
+            path,
+            fileName: `${path}.d.ts`,
+            interfaceName: (0, helper_string_1.toPascalCase)(path),
+            level: context.level + 1,
+        };
+    });
+    await generateTSContextDeclarationFile(libPath, context, contextDataSpecifications, contextDataSubContexts, pathPrefix);
+    contextCollector = [...contextCollector, context];
+    for await (const subContext of contextDataSubContexts) {
+        contextCollector = await generateTSDeclarationFilesForContext(libPath, subContext, contextData[subContext.name], pathPrefix, contextCollector);
+    }
+    return contextCollector;
+};
+const assignUnresolvedRefsToPolySchemaRefObj = (schemaDefinition, unresolvedPolySchemaRefs = []) => {
+    (0, index_1.iterateRefs)(schemaDefinition, schema => {
+        const ref = schema['x-poly-ref'];
+        if (ref !== null && typeof ref === 'object' && !Array.isArray(ref)) {
+            const foundUnresolved = unresolvedPolySchemaRefs.find(unresolvedPolySchemaRef => unresolvedPolySchemaRef.path === ref.path && unresolvedPolySchemaRef.publicNamespace === ref.publicNamespace);
+            if (foundUnresolved) {
+                schema['x-poly-ref']['x-unresolved'] = true;
             }
-            const currentPath = path ? `${path}.${key}` : key;
-            paths.push(currentPath);
-            traverseAndAddPath(data[key], currentPath);
+            schema.description = `<path>${ref.publicNamespace ? `${ref.publicNamespace}.${ref.path}` : ref.path}</path>`;
         }
-    };
-    traverseAndAddPath(contextData);
-    return paths;
+        return schema;
+    }, 'x-poly-ref');
 };
-const prettyPrint = (code, parser = 'typescript') => prettier_1.default.format(code, {
-    parser,
-    singleQuote: true,
-    printWidth: 160,
-});
-const echoGenerationError = (specification) => {
-    const name = specification.context
-        ? `${specification.context}.${specification.name}`
-        : specification.name;
-    const typeMap = {
-        apiFunction: 'API Function',
-        customFunction: 'Custom Function',
-        authFunction: 'Auth Function',
-        webhookHandle: 'Webhook Handle',
-        serverFunction: 'Server Function',
-        serverVariable: 'Variable',
-        schema: 'Schema',
-        snippet: 'Snippet',
-    };
-    const type = typeMap[specification.type];
-    shelljs_1.default.echo(chalk_1.default.red(`\nError encountered while processing ${type} '${name}' (id: '${specification.id}'). ${type} is unavailable.`));
+const generateTSDeclarationFiles = async (libPath, specs, interfaceName, pathPrefix) => {
+    const contextData = (0, specs_1.getContextData)(specs);
+    const contexts = await generateTSDeclarationFilesForContext(libPath, {
+        name: '',
+        path: '',
+        interfaceName,
+        fileName: 'default.d.ts',
+        level: 0,
+    }, contextData, pathPrefix);
+    await generateTSIndexDeclarationFile(libPath, contexts, pathPrefix);
 };
-const showErrGeneratingFiles = (error) => {
-    shelljs_1.default.echo(chalk_1.default.red('ERROR'));
-    shelljs_1.default.echo('Error while generating code files. Make sure the version of library/server is up to date.');
-    shelljs_1.default.echo(chalk_1.default.red(error.message));
-    shelljs_1.default.echo(chalk_1.default.red(error.stack));
-    shelljs_1.default.exit(2);
+const generateTSIndexDeclarationFile = async (libPath, contexts, pathPrefix) => {
+    const template = handlebars_1.default.compile((0, utils_2.loadTemplate)(`${pathPrefix}/index.d.ts.hbs`));
+    fs_1.default.writeFileSync(`${libPath}/${pathPrefix}/index.d.ts`, await (0, utils_2.prettyPrint)(template({
+        contexts: contexts.map((context) => ({
+            ...context,
+            firstLevel: context.level === 1,
+        })),
+    })));
 };
-const generateSingleCustomFunction = async (polyPath, functionId, updated) => {
-    shelljs_1.default.echo('-n', updated ? 'Regenerating TypeScript SDK...' : 'Generating TypeScript SDK...');
-    const libPath = (0, utils_2.getPolyLibPath)(polyPath);
-    let contextData = {};
-    try {
-        contextData = (0, utils_2.getContextDataFileContent)(libPath);
-    }
-    catch (error) {
-        shelljs_1.default.echo(chalk_1.default.red('ERROR'));
-        shelljs_1.default.echo('Error while fetching local context data.');
-        shelljs_1.default.echo(chalk_1.default.red(error.message));
-        shelljs_1.default.echo(chalk_1.default.red(error.stack));
-        return;
-    }
-    const prevSpecs = (0, utils_2.getSpecsFromContextData)(contextData);
-    let specs = [];
-    try {
-        specs = await (0, api_1.getSpecs)([], [], [functionId]);
-    }
-    catch (error) {
-        (0, utils_2.showErrGettingSpecs)(error);
-        return;
-    }
-    const [customFunction] = specs;
-    if (prevSpecs.some((prevSpec) => prevSpec.id === customFunction.id)) {
-        specs = prevSpecs.map((prevSpec) => {
-            if (prevSpec.id === customFunction.id) {
-                return customFunction;
+const generateFunctionsTSDeclarationFile = async (libPath, specs) => {
+    await generateTSDeclarationFiles(libPath, specs.filter(spec => 'function' in spec).map((spec) => {
+        for (const functionArg of spec.function.arguments) {
+            if (functionArg.type.kind === 'object' && functionArg.type.schema) {
+                assignUnresolvedRefsToPolySchemaRefObj(functionArg.type.schema, functionArg.type.unresolvedPolySchemaRefs);
             }
-            return prevSpec;
-        });
-    }
-    else {
-        prevSpecs.push(customFunction);
-        specs = prevSpecs;
-    }
-    await prepareDir(polyPath);
-    generationErrors = false;
-    await (0, exports.generateSpecs)(libPath, specs, false);
-    if (generationErrors) {
-        shelljs_1.default.echo(chalk_1.default.yellow('Generate DONE with errors. Please investigate the errors and contact support@polyapi.io for assistance.'));
-    }
-    else {
-        shelljs_1.default.echo(chalk_1.default.green('DONE'));
-    }
-};
-exports.generateSingleCustomFunction = generateSingleCustomFunction;
-const getIDComment = (specification) => {
-    switch (specification.type) {
-        case 'apiFunction':
-        case 'serverFunction':
-        case 'customFunction':
-            return `* Function ID: ${specification.id}`;
-        case 'authFunction':
-            return `* Auth provider ID: ${specification.id}`;
-        case 'webhookHandle':
-            return `* Webhook ID: ${specification.id}`;
-        default:
-            return null;
-    }
-};
-const getSpecificationWithFunctionComment = (specification) => {
-    const descriptionComment = specification.description
-        ? specification.description
-            .split('\n')
-            .map((line) => `* ${line}`)
-            .join('\n')
-        : null;
-    const toArgumentComment = (arg, prefix = '') => {
-        if (arg.name === 'payload' && arg.type.kind === 'object' && arg.type.properties) {
-            return arg.type.properties
-                .map(payloadProperty => toArgumentComment(payloadProperty, 'payload.'))
-                .filter(Boolean)
-                .join('\n');
-        }
-        if (!arg.description) {
-            return null;
-        }
-        return `* @param ${prefix}${arg.name} ${arg.description}`;
-    };
-    const argumentsComment = specification.function.arguments
-        .map(arg => toArgumentComment(arg))
-        .filter(Boolean)
-        .join('\n');
-    const additionalComments = getAdditionalComments(specification);
-    const idComment = getIDComment(specification);
-    return `${descriptionComment ? `${descriptionComment}\n` : ''}${argumentsComment ? `${argumentsComment}\n` : ''}${additionalComments ? `${additionalComments}\n` : ''}${idComment ? `*\n${idComment}\n` : ''}`.trim();
-};
-const getAdditionalComments = (specification) => {
-    switch (specification.type) {
-        case 'customFunction':
-            if (!specification.requirements.length) {
-                return null;
+            else if (functionArg.type.kind === 'object' && functionArg.type.properties) {
+                for (const property of functionArg.type.properties) {
+                    if (property.type.kind === 'object') {
+                        assignUnresolvedRefsToPolySchemaRefObj(property.type.schema, functionArg.type.unresolvedPolySchemaRefs);
+                    }
+                }
             }
-            return `This function requires you to have the following libraries installed:\n- ${specification.requirements.join('\n- ')}`;
-        default:
-            return null;
-    }
-};
-const getSpecificationWithVariableComment = (specification) => {
-    const descriptionComment = specification.description
-        ? specification.description
-            .split('\n')
-            .map((line) => `* ${line}`)
-            .join('\n')
-        : null;
-    const secretComment = specification.variable.secret
-        ? '* Note: The variable is secret and can be used only within Poly functions.'
-        : null;
-    const idComment = `* Variable ID: ${specification.id}`;
-    return `${descriptionComment ? `${descriptionComment}\n` : ''}${secretComment ? `${secretComment}\n` : ''}${idComment ? `*\n${idComment}` : ''}`.trim();
-};
-const generate = async ({ polyPath, contexts, names, functionIds, noTypes, }) => {
-    let specs = [];
-    const generateMsg = contexts ? `Generating Poly TypeScript SDK for contexts "${contexts}"...` : 'Generating Poly TypeScript SDK...';
-    shelljs_1.default.echo('-n', generateMsg);
-    await prepareDir(polyPath);
-    (0, config_1.loadConfig)(polyPath);
-    try {
-        specs = await (0, api_1.getSpecs)(contexts, names, functionIds);
-    }
-    catch (error) {
-        (0, utils_2.showErrGettingSpecs)(error);
-        return;
-    }
-    generationErrors = false;
-    await (0, exports.generateSpecs)((0, utils_2.getPolyLibPath)(polyPath), specs, noTypes);
-    if (generationErrors) {
-        shelljs_1.default.echo(chalk_1.default.yellow('Generate DONE with errors. Please investigate the errors and contact support@polyapi.io for assistance.'));
-    }
-    else {
-        shelljs_1.default.echo(chalk_1.default.green('DONE'));
-    }
-};
-exports.generate = generate;
-const generateSpecs = async (libPath, specs, noTypes) => {
-    try {
-        let missingNames = [];
-        [missingNames, specs] = specs.reduce((acc, s) => {
-            acc[s.name.trim() ? 1 : 0].push(s);
-            return acc;
-        }, [[], []]);
-        const jsFilesCodeGenerationErrors = await generateJSFiles(libPath, specs);
-        const filteredSpecs = specs.filter(spec => !jsFilesCodeGenerationErrors.find(codeGenerationError => codeGenerationError.specification.id === spec.id));
-        if (!noTypes) {
-            await generateFunctionsTSDeclarationFile(libPath, filteredSpecs);
-            await generateVariablesTSDeclarationFile(libPath, filteredSpecs);
-            await generateSchemasTSDeclarationFile(libPath, filteredSpecs);
-        }
-        (0, utils_2.generateContextDataFile)(libPath, filteredSpecs);
-        if (missingNames.length) {
-            generationErrors = true;
-            missingNames.map((s) => echoGenerationError(s));
         }
-        if (jsFilesCodeGenerationErrors.length) {
-            generationErrors = true;
-            jsFilesCodeGenerationErrors.forEach((error) => {
-                echoGenerationError(error.specification);
-            });
+        if (spec.function.returnType.kind === 'object' && spec.function.returnType.schema) {
+            assignUnresolvedRefsToPolySchemaRefObj(spec.function.returnType.schema, spec.function.returnType.unresolvedPolySchemaRefs);
         }
-    }
-    catch (error) {
-        showErrGeneratingFiles(error);
-    }
+        return spec;
+    }), 'Poly', '.');
 };
-exports.generateSpecs = generateSpecs;
-//# sourceMappingURL=generate.js.map
+exports.generateFunctionsTSDeclarationFile = generateFunctionsTSDeclarationFile;
+const generateVariablesTSDeclarationFile = async (libPath, specs) => await generateTSDeclarationFiles(libPath, specs.filter(spec => 'variable' in spec), 'Vari', 'vari');
+exports.generateVariablesTSDeclarationFile = generateVariablesTSDeclarationFile;
+//# sourceMappingURL=types.js.map