@buildvision/nest-sdk-generator 1.1.3

package/build/analyzer/route.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * @file Analyzer for the source API's routes in controller methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRouteWith = exports.resolveRoute = exports.debugUri = exports.unparseRoute = exports.paramsOfRoute = exports.analyzeUri = void 0;
+/**
+ * Analyze an URI path
+ * @param uriPath The URI path to analyze
+ */
+function analyzeUri(uriPath) {
+    // Split the URI path into "parts"
+    const rawParts = uriPath.split('/');
+    // The parsed parts we'll return
+    const parts = [];
+    // The current string offset in the URI path
+    // This variable is used for error display
+    let offset = 0;
+    /**
+     * Find if a specific part of the URI path contains an invalid character
+     * @param part The part to check
+     * @param pattern The invalid characters to look for, as a regular expression
+     * @returns An error message if an invalid character is found, nothing else
+     */
+    function _findInvalid(part, pattern) {
+        return part.match(pattern) ? uriPath + '\n' + ' '.repeat(offset) + '^' : null;
+    }
+    // Treat all parts of the URI path
+    for (let i = 0; i < rawParts.length; i++) {
+        const part = rawParts[i];
+        // Ignore empty parts (e.g. "/a///b" will be treated as "/a/b")
+        if (part === '')
+            continue;
+        // Ensure there is no generic character in the path as we don't support them
+        const genericErr = _findInvalid(part, /[\*\+\?]/);
+        if (genericErr) {
+            return new Error('Generic symbols (* + ?) are not supported as they prevent from determining the right route to use. Found in URI:\n' + genericErr);
+        }
+        // Check if this part is an URI parameter
+        if (part.startsWith(':')) {
+            // URI parameters must follow a strict naming
+            const paramErr = _findInvalid(part, /[^a-zA-Z0-9_:]/);
+            if (paramErr) {
+                return new Error('Invalid character detected in named parameter in URI:\n' + paramErr);
+            }
+            // We got a parameter
+            parts.push({ param: part.substr(1) });
+        }
+        else {
+            // We got a literal part
+            parts.push({ segment: part });
+        }
+        // Update the offset for error display
+        offset += part.length + 1;
+    }
+    // Success!
+    return {
+        isRoot: uriPath.startsWith('/'),
+        parts,
+    };
+}
+exports.analyzeUri = analyzeUri;
+/**
+ * Get the named parameters of a parsed route
+ * @param route
+ */
+function paramsOfRoute(route) {
+    return route.parts.map((part) => ('param' in part ? part.param : null)).filter((e) => e !== null);
+}
+exports.paramsOfRoute = paramsOfRoute;
+/**
+ * Convert a route back to its original string
+ * @param route
+ */
+function unparseRoute(route) {
+    return (route.isRoot ? '/' : '') + route.parts.map((part) => ('segment' in part ? part.segment : ':' + part.param)).join('/');
+}
+exports.unparseRoute = unparseRoute;
+/**
+ * Pretty-print a route
+ */
+function debugUri(route, color) {
+    return (route.isRoot ? '/' : '') + route.parts.map((part) => ('segment' in part ? part.segment : color(':' + part.param))).join('/');
+}
+exports.debugUri = debugUri;
+/**
+ * Resolve a route by providing its required parameters
+ * @param route
+ * @param params
+ */
+function resolveRoute(route, params) {
+    let uri = [];
+    for (const part of route.parts) {
+        if ('segment' in part) {
+            uri.push(part.segment);
+        }
+        else if (!params.hasOwnProperty(part.param)) {
+            return new Error('Missing route parameter ' + part.param);
+        }
+        else {
+            uri.push(params[part.param]);
+        }
+    }
+    return (route.isRoot ? '/' : '') + uri.join('/');
+}
+exports.resolveRoute = resolveRoute;
+/**
+ * Resolve a route by providing its required parameters through a callback
+ * @param route
+ * @param paramsProvider
+ */
+function resolveRouteWith(route, paramsProvider) {
+    let uri = [];
+    for (const part of route.parts) {
+        if ('segment' in part) {
+            uri.push(part.segment);
+        }
+        else {
+            const param = paramsProvider(part.param);
+            if (param === null) {
+                return new Error('Missing route parameter ' + part.param);
+            }
+            else {
+                uri.push(param);
+            }
+        }
+    }
+    return (route.isRoot ? '/' : '') + uri.join('/');
+}
+exports.resolveRouteWith = resolveRouteWith;
+//# sourceMappingURL=data:application/json;base64,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

package/build/analyzer/typedeps.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @file Type dependencies builders from the source API
+ */
+import { ts, Type } from 'ts-morph';
+/**
+ * Regex to match or replace imported types
+ */
+export declare const IMPORTED_TYPE_REGEX: RegExp;
+/**
+ * Type with resolved level 1 dependencies (does not look for dependencies' own dependencies!)
+ */
+export interface ResolvedTypeDeps {
+    /** The original raw type, with import("...") expressions */
+    readonly rawType: string;
+    /** The resolved type, without imports */
+    readonly resolvedType: string;
+    /** File from which the type originates */
+    readonly relativeFilePath: string;
+    /**
+     * The type dependencies used by the resolved type
+     * A collection of scripts' relative paths mapped with the list of types imported from them
+     */
+    readonly dependencies: Map<string, string[]>;
+    /**
+     * Non-native types that are not imported
+     * They may be either local types (declared in the same file than the one analyzed) or globally-defined types
+     */
+    readonly localTypes: string[];
+}
+/**
+ * Resolve the dependencies of a TS-Morph analyzed type
+ * @param type
+ * @param relativeFilePath
+ * @param absoluteSrcPath
+ * @returns
+ */
+export declare function resolveTypeDependencies(type: Type<ts.Type>, relativeFilePath: string, absoluteSrcPath: string): ResolvedTypeDeps;
+/**
+ * Extract an import type's name from a TS-Morph type
+ * @example "import('dir/file').TypeName" => "TypeName"
+ * @param type
+ * @returns
+ */
+export declare function getImportResolvedType(type: Type<ts.Type>): string;
+/**
+ * Convert paths for external files
+ * @param importedFilePath
+ */
+export declare function normalizeExternalFilePath(importedFilePath: string): string;

package/build/analyzer/typedeps.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * @file Type dependencies builders from the source API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExternalFilePath = exports.getImportResolvedType = exports.resolveTypeDependencies = exports.IMPORTED_TYPE_REGEX = void 0;
+const path = require("path");
+const logging_1 = require("../logging");
+/**
+ * Regex to match or replace imported types
+ */
+exports.IMPORTED_TYPE_REGEX = /\bimport\(['"]([^'"]+)['"]\)\.([a-zA-Z0-9_]+)\b/g;
+/**
+ * Resolve the dependencies of a TS-Morph analyzed type
+ * @param type
+ * @param relativeFilePath
+ * @param absoluteSrcPath
+ * @returns
+ */
+function resolveTypeDependencies(type, relativeFilePath, absoluteSrcPath) {
+    /** Raw type's text (e.g. `Array<import("somefile.ts").SomeType>`) */
+    const rawType = type.getText();
+    if (path.isAbsolute(relativeFilePath)) {
+        (0, logging_1.unreachable)('Internal error: got absolute file path in type dependencies resolver, when expecting a relative one (got {magentaBright})', relativeFilePath);
+    }
+    let dependencies = new Map();
+    let localTypes = [];
+    /** Resolved type (without import statements) */
+    const resolvedType = rawType.replace(exports.IMPORTED_TYPE_REGEX, (_, matchedFilePath, type) => {
+        const filePath = path.isAbsolute(matchedFilePath) ? path.relative(absoluteSrcPath, matchedFilePath) : matchedFilePath;
+        const deps = dependencies.get(filePath);
+        if (deps) {
+            if (!deps.includes(type)) {
+                deps.push(type);
+            }
+        }
+        else {
+            dependencies.set(filePath, [type]);
+        }
+        return type;
+    });
+    if (resolvedType.includes('import(')) {
+        (0, logging_1.unreachable)('Internal error: resolved still contains an {magenta} statement: {green}', 'import(...)', resolvedType);
+    }
+    for (const depFile of dependencies.keys()) {
+        if (path.isAbsolute(depFile)) {
+            (0, logging_1.unreachable)('Internal error: resolved absolute file path in type dependencies, when should have resolved a relative one\nIn type: {yellow}\nGot: {magentaBright}', type.getText(), depFile);
+        }
+    }
+    return {
+        rawType,
+        relativeFilePath,
+        resolvedType,
+        dependencies,
+        localTypes,
+    };
+}
+exports.resolveTypeDependencies = resolveTypeDependencies;
+/**
+ * Extract an import type's name from a TS-Morph type
+ * @example "import('dir/file').TypeName" => "TypeName"
+ * @param type
+ * @returns
+ */
+function getImportResolvedType(type) {
+    return type.getText().replace(exports.IMPORTED_TYPE_REGEX, (_, __, typename) => typename);
+}
+exports.getImportResolvedType = getImportResolvedType;
+/**
+ * Convert paths for external files
+ * @param importedFilePath
+ */
+function normalizeExternalFilePath(importedFilePath) {
+    importedFilePath = path.normalize(importedFilePath);
+    if (!importedFilePath.startsWith('../')) {
+        return importedFilePath;
+    }
+    let level = 0;
+    while (importedFilePath.startsWith('../')) {
+        level++;
+        importedFilePath = importedFilePath.substr(3);
+    }
+    return `_external${level}/${importedFilePath}`;
+}
+exports.normalizeExternalFilePath = normalizeExternalFilePath;
+//# sourceMappingURL=data:application/json;base64,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

package/build/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/bin.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const analyzer_1 = require("./analyzer");
+const config_1 = require("./config");
+const generator_1 = require("./generator");
+const logging_1 = require("./logging");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const started = Date.now();
+        process.chdir(path.dirname(path.resolve(config_1.configPath)));
+        switch (process.argv[3]) {
+            case '--analyze':
+                yield (0, analyzer_1.analyzerCli)(config_1.config);
+                break;
+            case '--generate':
+            case undefined:
+                const sdkContent = yield (0, analyzer_1.analyzerCli)(config_1.config);
+                yield (0, generator_1.default)(config_1.config, sdkContent);
+                break;
+            default:
+                console.error('ERROR: Unknown action provided (must be either "--analyze" or "--generate")');
+                process.exit(1);
+        }
+        (0, logging_1.println)('{green}', '@ Done in ' + ((Date.now() - started) / 1000).toFixed(2) + 's');
+    });
+}
+main();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmluLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Jpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFFQSw2QkFBNEI7QUFDNUIseUNBQXdDO0FBQ3hDLHFDQUE2QztBQUM3QywyQ0FBc0M7QUFDdEMsdUNBQW1DO0FBRW5DLFNBQWUsSUFBSTs7UUFDakIsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFBO1FBRTFCLE9BQU8sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLG1CQUFVLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFFckQsUUFBUSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFO1lBQ3ZCLEtBQUssV0FBVztnQkFDZCxNQUFNLElBQUEsc0JBQVcsRUFBQyxlQUFNLENBQUMsQ0FBQTtnQkFDekIsTUFBSztZQUVQLEtBQUssWUFBWSxDQUFDO1lBQ2xCLEtBQUssU0FBUztnQkFDWixNQUFNLFVBQVUsR0FBRyxNQUFNLElBQUEsc0JBQVcsRUFBQyxlQUFNLENBQUMsQ0FBQTtnQkFDNUMsTUFBTSxJQUFBLG1CQUFZLEVBQUMsZUFBTSxFQUFFLFVBQVUsQ0FBQyxDQUFBO2dCQUN0QyxNQUFLO1lBRVA7Z0JBQ0UsT0FBTyxDQUFDLEtBQUssQ0FBQyw2RUFBNkUsQ0FBQyxDQUFBO2dCQUM1RixPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO1NBQ2xCO1FBRUQsSUFBQSxpQkFBTyxFQUFDLFNBQVMsRUFBRSxZQUFZLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxPQUFPLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUE7SUFDckYsQ0FBQztDQUFBO0FBRUQsSUFBSSxFQUFFLENBQUEifQ==

package/build/config.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The configuration file's content
+ * For details on what these options do, see the project's README
+ */
+export interface Config {
+    /** Enable verbose mode */
+    readonly verbose?: boolean;
+    /** Disable colored output */
+    readonly noColor?: boolean;
+    /** Path to the API's source directory */
+    readonly apiInputPath: string;
+    /** Path to generate the SDK at */
+    readonly sdkOutput: string;
+    /** Path to the SDK interface file */
+    readonly sdkInterfacePath: string;
+    /** List of magic types */
+    readonly magicTypes?: MagicType[];
+    /** Show a JSON output */
+    readonly jsonOutput?: string;
+    /** Prettify the JSON output */
+    readonly jsonPrettyOutput?: boolean;
+    /** Prettify the generated files (enabled by default) */
+    readonly prettify?: boolean;
+    /** Path to Prettier's configuration file */
+    readonly prettierConfig?: string;
+    /** Path to custom tsconfig file */
+    readonly tsconfigFile?: string;
+    /** If the output directory already exists, overwrite it (enabled by default) */
+    readonly overwriteOldOutputDir?: boolean;
+    /** If the SDK interface file does not exist yet, create one automatically (enabled by default) */
+    readonly generateDefaultSdkInterface?: boolean;
+    /** Write generation timestamp in each TypeScript file (enabled by default) */
+    readonly generateTimestamps?: boolean;
+}
+/**
+ * Magic type used to replace a non-compatible type in the generated SDK
+ */
+export interface MagicType {
+    readonly nodeModuleFilePath: string;
+    readonly typeName: string;
+    readonly placeholderContent: string;
+}
+export declare const configPath: string;
+export declare const config: Config;

package/build/config.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.configPath = void 0;
+const chalk = require("chalk");
+const fs = require("fs");
+const path = require("path");
+/**
+ * Load an existing configuration file and decode it
+ * @param configPath
+ */
+function loadConfigFile(configPath) {
+    if (!fs.existsSync(configPath)) {
+        console.error(chalk.red('Config file was not found at path: ' + chalk.yellow(path.resolve(configPath))));
+        process.exit(4);
+    }
+    const text = fs.readFileSync(configPath, 'utf8');
+    try {
+        return JSON.parse(text);
+    }
+    catch (e) {
+        console.error(chalk.red('Failed to parse configuration file: ' + e));
+        process.exit(3);
+    }
+}
+exports.configPath = process.argv[2];
+if (!exports.configPath) {
+    console.error(chalk.red('Please provide a path to the configuration file'));
+    process.exit(2);
+}
+exports.config = loadConfigFile(exports.configPath);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrQkFBK0I7QUFDL0IseUJBQXdCO0FBQ3hCLDZCQUE0QjtBQTJENUI7OztHQUdHO0FBQ0gsU0FBUyxjQUFjLENBQUMsVUFBa0I7SUFDeEMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLEVBQUU7UUFDOUIsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLHFDQUFxQyxHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUN4RyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO0tBQ2hCO0lBRUQsTUFBTSxJQUFJLEdBQUcsRUFBRSxDQUFDLFlBQVksQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUE7SUFFaEQsSUFBSTtRQUNGLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQTtLQUN4QjtJQUFDLE9BQU8sQ0FBQyxFQUFFO1FBQ1YsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLHNDQUFzQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFDcEUsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQTtLQUNoQjtBQUNILENBQUM7QUFFWSxRQUFBLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBRXpDLElBQUksQ0FBQyxrQkFBVSxFQUFFO0lBQ2YsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLGlEQUFpRCxDQUFDLENBQUMsQ0FBQTtJQUMzRSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO0NBQ2hCO0FBRVksUUFBQSxNQUFNLEdBQUcsY0FBYyxDQUFDLGtCQUFVLENBQUMsQ0FBQSJ9

package/build/generator/genmodules.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file Generate SDK modules
+ */
+import { SdkModules } from '../analyzer/controllers';
+import { SdkMethod } from '../analyzer/methods';
+import { SdkMethodParams } from '../analyzer/params';
+/**
+ * Generate the SDK's module and controllers files
+ * @param modules
+ * @returns
+ */
+export declare function generateSdkModules(modules: SdkModules): Map<string, string>;
+/**
+ * Generate the method parameters for a given SDK method
+ * @param params
+ * @returns
+ */
+export declare function generateSdkMethodParams(params: SdkMethodParams): string;
+/**
+ * Generate a request call to Central for the generated files
+ * @param method
+ * @returns
+ */
+export declare function generateCentralRequest(method: SdkMethod): string;

package/build/generator/genmodules.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * @file Generate SDK modules
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCentralRequest = exports.generateSdkMethodParams = exports.generateSdkModules = void 0;
+const path = require("path");
+const route_1 = require("../analyzer/route");
+const typedeps_1 = require("../analyzer/typedeps");
+const logging_1 = require("../logging");
+/**
+ * Generate the SDK's module and controllers files
+ * @param modules
+ * @returns
+ */
+function generateSdkModules(modules) {
+    /** Generated module files */
+    const genFiles = new Map();
+    // Iterate over each module
+    for (const [moduleName, controllers] of modules) {
+        // Iterate over each of the module's controllers
+        for (const [controllerName, controller] of controllers) {
+            /** Generated controller's content */
+            const out = [];
+            out.push('/// Parent module: ' + moduleName);
+            out.push(`/// Controller: "${controllerName}" registered as "${controller.registrationName}" (${controller.methods.length} routes)`);
+            out.push('');
+            out.push('import { request } from "../central";');
+            const imports = new Map();
+            const depsToImport = new Array();
+            // Iterate over each controller
+            for (const method of controller.methods.values()) {
+                const { parameters: args, query, body } = method.params;
+                depsToImport.push(method.returnType);
+                if (args) {
+                    depsToImport.push(...args.values());
+                }
+                if (query) {
+                    depsToImport.push(...query.values());
+                }
+                if (body) {
+                    if (body.full) {
+                        depsToImport.push(body.type);
+                    }
+                    else {
+                        depsToImport.push(...body.fields.values());
+                    }
+                }
+            }
+            // Build the imports list
+            for (const dep of depsToImport) {
+                for (const [file, types] of dep.dependencies) {
+                    let imported = imports.get(file);
+                    if (!imported) {
+                        imported = [];
+                        imports.set(file, imported);
+                    }
+                    for (const typ of types) {
+                        if (!imported.includes(typ)) {
+                            imported.push(typ);
+                        }
+                    }
+                }
+            }
+            for (const [file, types] of imports) {
+                out.push(`import type { ${types.join(', ')} } from "../_types/${(0, typedeps_1.normalizeExternalFilePath)(file.replace(/\\/g, '/')).replace(/\\/g, '/')}";`);
+            }
+            out.push('');
+            out.push(`export default {`);
+            for (const method of controller.methods) {
+                const ret = method.returnType.resolvedType;
+                const promised = ret.startsWith('Promise<') ? ret : `Promise<${ret}>`;
+                out.push('');
+                out.push(`  // ${method.httpMethod} @ ${(0, route_1.unparseRoute)(method.route)}`);
+                out.push(`  ${method.name}(${generateSdkMethodParams(method.params)}): ${promised} {`);
+                out.push(generateCentralRequest(method).replace(/^/gm, '    '));
+                out.push('  },');
+            }
+            out.push('');
+            out.push('};');
+            genFiles.set(path.join(moduleName, controller.camelClassName + '.ts'), out.join('\n'));
+        }
+        /** Generated module's content */
+        const moduleContent = [];
+        moduleContent.push('/// Module name: ' + moduleName);
+        moduleContent.push('');
+        for (const controller of controllers.keys()) {
+            moduleContent.push(`export { default as ${controller} } from "./${controller}";`);
+        }
+        // Generate the SDK module file
+        genFiles.set(path.join(moduleName, 'index.ts'), moduleContent.join('\n'));
+    }
+    return genFiles;
+}
+exports.generateSdkModules = generateSdkModules;
+/**
+ * Generate the method parameters for a given SDK method
+ * @param params
+ * @returns
+ */
+function generateSdkMethodParams(params) {
+    // List of parameters (e.g. `id` in `/get/:id`, analyzed from the usages of the `@Param` decorator)
+    const parameters = params.parameters ? [...params.parameters].map(([name, type]) => `${name}: ${type.resolvedType}`) : [];
+    // List of query values (e.g. `id` in `?id=xxx`, analyzed from the usages of the `@Query` decorator)
+    const query = params.query ? [...params.query].map(([name, type]) => `${name}: ${type.resolvedType}`) : [];
+    // Body's content (type used with the `@Body` decorator)
+    const body = params.body
+        ? params.body.full
+            ? params.body.type.resolvedType
+            : '{ ' + [...params.body.fields].map(([name, type]) => `${name}: ${type.resolvedType}`).join(', ') + ' }'
+        : null;
+    // The ternary conditions below are made to eclipse useless parameters
+    // For instance, if we're not expecting any query nor body, these two parameters can be omitted when calling the method
+    return [
+        `params: {${' ' + parameters.join(', ') + ' '}}${parameters.length === 0 && !body && query.length === 0 ? ' = {}' : ''}`,
+        `body: ${body !== null && body !== void 0 ? body : '{}'}${!body && query.length === 0 ? ' = {}' : ''}`,
+        `query: {${' ' + query.join(', ') + ' '}}${query.length === 0 ? ' = {}' : ''}`,
+    ].join(', ');
+}
+exports.generateSdkMethodParams = generateSdkMethodParams;
+/**
+ * Generate a request call to Central for the generated files
+ * @param method
+ * @returns
+ */
+function generateCentralRequest(method) {
+    const resolvedRoute = (0, route_1.resolveRouteWith)(method.route, (param) => '${params.' + param + '}');
+    if (resolvedRoute instanceof Error) {
+        (0, logging_1.panic)('Internal error: failed to resolve route: ' + resolvedRoute.message);
+    }
+    return `return request('${method.httpMethod}', \`${resolvedRoute}\`, body, query) as any`;
+}
+exports.generateCentralRequest = generateCentralRequest;
+//# sourceMappingURL=data:application/json;base64,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

package/build/generator/gentypes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file Generate type files for the SDK
+ */
+import { TypesExtractorContent } from '../analyzer/extractor';
+/**
+ * Generate the non-formatted type files which will be used by the SDK's route functions
+ * @param sdkTypes
+ * @returns
+ */
+export declare function generateSdkTypeFiles(sdkTypes: TypesExtractorContent): Map<string, string>;

package/build/generator/gentypes.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * @file Generate type files for the SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSdkTypeFiles = void 0;
+const path = require("path");
+const typedeps_1 = require("../analyzer/typedeps");
+/**
+ * Generate the non-formatted type files which will be used by the SDK's route functions
+ * @param sdkTypes
+ * @returns
+ */
+function generateSdkTypeFiles(sdkTypes) {
+    /** Generated type files */
+    const genFiles = new Map();
+    // While analyzing the controllers' content, all types used by their methods have been extracted
+    // The list of these types is then provided to this function as the `sdkTypes` argument, allowing us
+    //  to establish the list of all dependencies.
+    for (const [file, types] of sdkTypes) {
+        const out = [];
+        /** List of imports in the current file */
+        const imports = new Map();
+        // Iterate over all types in the current `file`
+        for (const extracted of types.values()) {
+            // Iterate over all of the extracted type's dependencies
+            for (const dep of extracted.dependencies) {
+                // If the dependency is from the same file, then we have nothing to do
+                if (dep.relativePath === file) {
+                    continue;
+                }
+                // Push the typename to the list of imports
+                let imported = imports.get(dep.relativePathNoExt);
+                if (!imported) {
+                    imported = [dep.typename];
+                    imports.set(dep.relativePathNoExt, imported);
+                }
+                if (!imported.includes(dep.typename)) {
+                    imported.push(dep.typename);
+                }
+            }
+        }
+        // Generate an import statement for each imported type
+        out.push([...imports]
+            .map(([depFile, types]) => {
+            let depPath = path.relative(path.dirname(file), (0, typedeps_1.normalizeExternalFilePath)(depFile)).replace(/\\/g, '/');
+            if (!depPath.includes('/'))
+                depPath = './' + depPath;
+            return `import type { ${types.join(', ')} } from "${depPath.startsWith('./') || depPath.startsWith('../') ? depPath : './' + depPath}"`;
+        })
+            .join('\n'));
+        // Add the extracted types' declaration, indented
+        for (const extracted of types.values()) {
+            out.push(extracted.content.replace(/^/gm, '  '));
+        }
+        // Generate the type file
+        genFiles.set(file, out.join('\n'));
+    }
+    return genFiles;
+}
+exports.generateSdkTypeFiles = generateSdkTypeFiles;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2VuZXJhdG9yL2dlbnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7R0FFRzs7O0FBRUgsNkJBQTRCO0FBRTVCLG1EQUFnRTtBQUVoRTs7OztHQUlHO0FBQ0gsU0FBZ0Isb0JBQW9CLENBQUMsUUFBK0I7SUFDbEUsMkJBQTJCO0lBQzNCLE1BQU0sUUFBUSxHQUFHLElBQUksR0FBRyxFQUFrQixDQUFBO0lBRTFDLGdHQUFnRztJQUNoRyxvR0FBb0c7SUFDcEcsOENBQThDO0lBQzlDLEtBQUssTUFBTSxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSSxRQUFRLEVBQUU7UUFDcEMsTUFBTSxHQUFHLEdBQUcsRUFBRSxDQUFBO1FBRWQsMENBQTBDO1FBQzFDLE1BQU0sT0FBTyxHQUFHLElBQUksR0FBRyxFQUFvQixDQUFBO1FBRTNDLCtDQUErQztRQUMvQyxLQUFLLE1BQU0sU0FBUyxJQUFJLEtBQUssQ0FBQyxNQUFNLEVBQUUsRUFBRTtZQUN0Qyx3REFBd0Q7WUFDeEQsS0FBSyxNQUFNLEdBQUcsSUFBSSxTQUFTLENBQUMsWUFBWSxFQUFFO2dCQUN4QyxzRUFBc0U7Z0JBQ3RFLElBQUksR0FBRyxDQUFDLFlBQVksS0FBSyxJQUFJLEVBQUU7b0JBQzdCLFNBQVE7aUJBQ1Q7Z0JBRUQsMkNBQTJDO2dCQUMzQyxJQUFJLFFBQVEsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFBO2dCQUVqRCxJQUFJLENBQUMsUUFBUSxFQUFFO29CQUNiLFFBQVEsR0FBRyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQTtvQkFDekIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsaUJBQWlCLEVBQUUsUUFBUSxDQUFDLENBQUE7aUJBQzdDO2dCQUVELElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRTtvQkFDcEMsUUFBUSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUE7aUJBQzVCO2FBQ0Y7U0FDRjtRQUVELHNEQUFzRDtRQUN0RCxHQUFHLENBQUMsSUFBSSxDQUNOLENBQUMsR0FBRyxPQUFPLENBQUM7YUFDVCxHQUFHLENBQUMsQ0FBQyxDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUMsRUFBRSxFQUFFO1lBQ3hCLElBQUksT0FBTyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFBLG9DQUF5QixFQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQTtZQUN2RyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUM7Z0JBQUUsT0FBTyxHQUFHLElBQUksR0FBRyxPQUFPLENBQUE7WUFDcEQsT0FBTyxpQkFBaUIsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsWUFDdEMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLElBQUksR0FBRyxPQUMzRSxHQUFHLENBQUE7UUFDTCxDQUFDLENBQUM7YUFDRCxJQUFJLENBQUMsSUFBSSxDQUFDLENBQ2QsQ0FBQTtRQUVELGlEQUFpRDtRQUNqRCxLQUFLLE1BQU0sU0FBUyxJQUFJLEtBQUssQ0FBQyxNQUFNLEVBQUUsRUFBRTtZQUN0QyxHQUFHLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFBO1NBQ2pEO1FBRUQseUJBQXlCO1FBQ3pCLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQTtLQUNuQztJQUVELE9BQU8sUUFBUSxDQUFBO0FBQ2pCLENBQUM7QUEzREQsb0RBMkRDIn0=

package/build/generator/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file Entrypoint of the SDK generator
+ */
+import { SdkContent } from '../analyzer';
+import { Config } from '../config';
+export default function generatorCli(config: Config, sdkContent: SdkContent): Promise<void>;