@buildvision/nest-sdk-generator 1.1.3

package/build/analyzer/controllers.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * @file Analyzer for the source API's controllers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeControllers = void 0;
+const os = require("os");
+const path = require("path");
+const logging_1 = require("../logging");
+const utils_1 = require("../utils");
+const controller_1 = require("./controller");
+const module_1 = require("./module");
+function analyzeControllers(controllers, absoluteSrcPath, project) {
+    /** Hierarchised SDK informations */
+    const collected = new Map();
+    /**
+     * Modules cache: contains for a given directory the nearest module file's path and name
+     * This allows to avoid having to analyze the whole directory structure for each controller
+     */
+    const modulesCache = new Map();
+    /**
+     * Path of the declared modules
+     * When a module is detected and put in the cache, its name is registered here along with its path
+     * This allows to ensure there is no name clash between two different modules
+     */
+    const declaredModulesPath = new Map();
+    (0, logging_1.debug)(`Analyzing {yellow} controllers...`, controllers.length);
+    controllers.forEach((relativeControllerPath, i) => {
+        const absoluteControllerPath = path.resolve(absoluteSrcPath, relativeControllerPath);
+        (0, logging_1.debug)('\n{cyan} {yellow}: {magentaBright} {cyan}\n', '===== Analyzing controller', `${i + 1}/${controllers.length}`, relativeControllerPath, '=====');
+        const basePath = path.dirname(absoluteControllerPath);
+        let moduleName = modulesCache.get(basePath);
+        // Check if the module's name is in cache
+        if (!moduleName) {
+            // Else, find the nearest module file
+            const absoluteModulePath = (0, utils_1.findFileAbove)(/^.*\.module\.ts$/, path.resolve(absoluteSrcPath, basePath));
+            if (absoluteModulePath === null) {
+                (0, logging_1.panic)('No module file was found for controller at path: {yellow}', absoluteControllerPath);
+            }
+            const relativeModulePath = path.relative(absoluteSrcPath, absoluteModulePath);
+            // Get the module's name
+            moduleName = (0, module_1.getModuleName)(project, relativeModulePath, absoluteSrcPath);
+            (0, logging_1.debug)('Discovered module: {yellow}', moduleName);
+            // Ensure this module is unique
+            const cachedModulePath = declaredModulesPath.get(moduleName);
+            if (cachedModulePath) {
+                (0, logging_1.panic)(`Two modules were declared with the same name {yellow}:\n` + `- One in {yellow}\n` + `- One in {yellow}`, moduleName, cachedModulePath, relativeModulePath);
+            }
+            modulesCache.set(basePath, moduleName);
+        }
+        if (moduleName in {}) {
+            (0, logging_1.panic)(`Detected module whose name {yellow} collides with a JavaScript's native object property`, moduleName);
+        }
+        let moduleSdkInfos = collected.get(moduleName);
+        if (!moduleSdkInfos) {
+            moduleSdkInfos = new Map();
+            collected.set(moduleName, moduleSdkInfos);
+        }
+        if (i === 0) {
+            if (process.platform === 'linux' && os.release().toLocaleLowerCase().includes('microsoft') && absoluteSrcPath.startsWith('/mnt/')) {
+                (0, logging_1.warn)("NOTE: On WSL, the first type analysis on a project located in Windows's filesystem may take a long time to complete.");
+                (0, logging_1.warn)('Please consider moving your project to WSL, or running this tool directly from Windows');
+            }
+        }
+        const metadata = (0, controller_1.analyzeController)(project, relativeControllerPath, absoluteSrcPath);
+        if (metadata instanceof Error) {
+            throw new Error((0, logging_1.format)('Failed to analyze controller at path {magenta}:\n{}', relativeControllerPath, metadata.message));
+        }
+        if (metadata) {
+            if (metadata.registrationName in {}) {
+                (0, logging_1.panic)(`Detected controller whose registration name {yellow} collides with a JavaScript's native object property`, metadata.registrationName);
+            }
+            moduleSdkInfos.set(metadata.camelClassName, metadata);
+        }
+    });
+    return collected;
+}
+exports.analyzeControllers = analyzeControllers;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJvbGxlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYW5hbHl6ZXIvY29udHJvbGxlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7QUFFSCx5QkFBd0I7QUFDeEIsNkJBQTRCO0FBRTVCLHdDQUF1RDtBQUN2RCxvQ0FBd0M7QUFDeEMsNkNBQStEO0FBQy9ELHFDQUF3QztBQUl4QyxTQUFnQixrQkFBa0IsQ0FBQyxXQUFxQixFQUFFLGVBQXVCLEVBQUUsT0FBZ0I7SUFDakcsb0NBQW9DO0lBQ3BDLE1BQU0sU0FBUyxHQUFHLElBQUksR0FBRyxFQUFzQyxDQUFBO0lBRS9EOzs7T0FHRztJQUNILE1BQU0sWUFBWSxHQUFHLElBQUksR0FBRyxFQUFrQixDQUFBO0lBRTlDOzs7O09BSUc7SUFDSCxNQUFNLG1CQUFtQixHQUFHLElBQUksR0FBRyxFQUFrQixDQUFBO0lBRXJELElBQUEsZUFBSyxFQUFDLG1DQUFtQyxFQUFFLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUU5RCxXQUFXLENBQUMsT0FBTyxDQUFDLENBQUMsc0JBQXNCLEVBQUUsQ0FBQyxFQUFFLEVBQUU7UUFDaEQsTUFBTSxzQkFBc0IsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLGVBQWUsRUFBRSxzQkFBc0IsQ0FBQyxDQUFBO1FBRXBGLElBQUEsZUFBSyxFQUNILDZDQUE2QyxFQUM3Qyw0QkFBNEIsRUFDNUIsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFJLFdBQVcsQ0FBQyxNQUFNLEVBQUUsRUFDaEMsc0JBQXNCLEVBQ3RCLE9BQU8sQ0FDUixDQUFBO1FBRUQsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxzQkFBc0IsQ0FBQyxDQUFBO1FBRXJELElBQUksVUFBVSxHQUFHLFlBQVksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUE7UUFFM0MseUNBQXlDO1FBQ3pDLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDZixxQ0FBcUM7WUFDckMsTUFBTSxrQkFBa0IsR0FBRyxJQUFBLHFCQUFhLEVBQUMsa0JBQWtCLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxlQUFlLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQTtZQUVyRyxJQUFJLGtCQUFrQixLQUFLLElBQUksRUFBRTtnQkFDL0IsSUFBQSxlQUFLLEVBQUMsMkRBQTJELEVBQUUsc0JBQXNCLENBQUMsQ0FBQTthQUMzRjtZQUVELE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxlQUFlLEVBQUUsa0JBQWtCLENBQUMsQ0FBQTtZQUU3RSx3QkFBd0I7WUFDeEIsVUFBVSxHQUFHLElBQUEsc0JBQWEsRUFBQyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsZUFBZSxDQUFDLENBQUE7WUFFeEUsSUFBQSxlQUFLLEVBQUMsNkJBQTZCLEVBQUUsVUFBVSxDQUFDLENBQUE7WUFFaEQsK0JBQStCO1lBQy9CLE1BQU0sZ0JBQWdCLEdBQUcsbUJBQW1CLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxDQUFBO1lBRTVELElBQUksZ0JBQWdCLEVBQUU7Z0JBQ3BCLElBQUEsZUFBSyxFQUNILDBEQUEwRCxHQUFHLHFCQUFxQixHQUFHLG1CQUFtQixFQUN4RyxVQUFVLEVBQ1YsZ0JBQWdCLEVBQ2hCLGtCQUFrQixDQUNuQixDQUFBO2FBQ0Y7WUFFRCxZQUFZLENBQUMsR0FBRyxDQUFDLFFBQVEsRUFBRSxVQUFVLENBQUMsQ0FBQTtTQUN2QztRQUVELElBQUksVUFBVSxJQUFJLEVBQUUsRUFBRTtZQUNwQixJQUFBLGVBQUssRUFBQyx5RkFBeUYsRUFBRSxVQUFVLENBQUMsQ0FBQTtTQUM3RztRQUVELElBQUksY0FBYyxHQUFHLFNBQVMsQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLENBQUE7UUFFOUMsSUFBSSxDQUFDLGNBQWMsRUFBRTtZQUNuQixjQUFjLEdBQUcsSUFBSSxHQUFHLEVBQUUsQ0FBQTtZQUMxQixTQUFTLENBQUMsR0FBRyxDQUFDLFVBQVUsRUFBRSxjQUFjLENBQUMsQ0FBQTtTQUMxQztRQUVELElBQUksQ0FBQyxLQUFLLENBQUMsRUFBRTtZQUNYLElBQUksT0FBTyxDQUFDLFFBQVEsS0FBSyxPQUFPLElBQUksRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLGlCQUFpQixFQUFFLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxJQUFJLGVBQWUsQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLEVBQUU7Z0JBQ2pJLElBQUEsY0FBSSxFQUFDLHNIQUFzSCxDQUFDLENBQUE7Z0JBQzVILElBQUEsY0FBSSxFQUFDLHdGQUF3RixDQUFDLENBQUE7YUFDL0Y7U0FDRjtRQUVELE1BQU0sUUFBUSxHQUFHLElBQUEsOEJBQWlCLEVBQUMsT0FBTyxFQUFFLHNCQUFzQixFQUFFLGVBQWUsQ0FBQyxDQUFBO1FBRXBGLElBQUksUUFBUSxZQUFZLEtBQUssRUFBRTtZQUM3QixNQUFNLElBQUksS0FBSyxDQUFDLElBQUEsZ0JBQU0sRUFBQyxxREFBcUQsRUFBRSxzQkFBc0IsRUFBRSxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQTtTQUN6SDtRQUVELElBQUksUUFBUSxFQUFFO1lBQ1osSUFBSSxRQUFRLENBQUMsZ0JBQWdCLElBQUksRUFBRSxFQUFFO2dCQUNuQyxJQUFBLGVBQUssRUFDSCwwR0FBMEcsRUFDMUcsUUFBUSxDQUFDLGdCQUFnQixDQUMxQixDQUFBO2FBQ0Y7WUFFRCxjQUFjLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxjQUFjLEVBQUUsUUFBUSxDQUFDLENBQUE7U0FDdEQ7SUFDSCxDQUFDLENBQUMsQ0FBQTtJQUVGLE9BQU8sU0FBUyxDQUFBO0FBQ2xCLENBQUM7QUF0R0QsZ0RBc0dDIn0=

package/build/analyzer/decorator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file Utilities for analyzing the source API's decorators
+ */
+import { Decorator } from 'ts-morph';
+/**
+ * Expect a decorator to have a single, string literal argument
+ * @param dec The decorator
+ * @returns Nothing if the decorator has no argument, a { lit: string } if the decorator has a string literal, an Error else
+ */
+export declare function expectSingleStrLitDecorator(dec: Decorator): string | null | Error;

package/build/analyzer/decorator.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * @file Utilities for analyzing the source API's decorators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectSingleStrLitDecorator = void 0;
+const ts_morph_1 = require("ts-morph");
+const logging_1 = require("../logging");
+/**
+ * Expect a decorator to have a single, string literal argument
+ * @param dec The decorator
+ * @returns Nothing if the decorator has no argument, a { lit: string } if the decorator has a string literal, an Error else
+ */
+function expectSingleStrLitDecorator(dec) {
+    const args = dec.getArguments();
+    if (args.length > 1) {
+        return new Error(`Multiple (${args.length}) arguments were provided to the decorator`);
+    }
+    else if (args.length === 0) {
+        return null;
+    }
+    const [arg] = args;
+    if (!ts_morph_1.Node.isStringLiteral(arg)) {
+        return new Error((0, logging_1.format)('The argument provided to the decorator is not a string literal:\n>>> {cyan}', arg.getText()));
+    }
+    return arg.getLiteralText();
+}
+exports.expectSingleStrLitDecorator = expectSingleStrLitDecorator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FuYWx5emVyL2RlY29yYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7O0dBRUc7OztBQUVILHVDQUEwQztBQUMxQyx3Q0FBbUM7QUFFbkM7Ozs7R0FJRztBQUNILFNBQWdCLDJCQUEyQixDQUFDLEdBQWM7SUFDeEQsTUFBTSxJQUFJLEdBQUcsR0FBRyxDQUFDLFlBQVksRUFBRSxDQUFBO0lBRS9CLElBQUksSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUU7UUFDbkIsT0FBTyxJQUFJLEtBQUssQ0FBQyxhQUFhLElBQUksQ0FBQyxNQUFNLDRDQUE0QyxDQUFDLENBQUE7S0FDdkY7U0FBTSxJQUFJLElBQUksQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFO1FBQzVCLE9BQU8sSUFBSSxDQUFBO0tBQ1o7SUFFRCxNQUFNLENBQUMsR0FBRyxDQUFDLEdBQUcsSUFBSSxDQUFBO0lBRWxCLElBQUksQ0FBQyxlQUFJLENBQUMsZUFBZSxDQUFDLEdBQUcsQ0FBQyxFQUFFO1FBQzlCLE9BQU8sSUFBSSxLQUFLLENBQUMsSUFBQSxnQkFBTSxFQUFDLDZFQUE2RSxFQUFFLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUE7S0FDdkg7SUFFRCxPQUFPLEdBQUcsQ0FBQyxjQUFjLEVBQUUsQ0FBQTtBQUM3QixDQUFDO0FBaEJELGtFQWdCQyJ9

package/build/analyzer/extractor.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @file Types extractor to use in the generated SDK
+ */
+import { Project } from 'ts-morph';
+import { MagicType } from '../config';
+import { SdkModules } from './controllers';
+import { ResolvedTypeDeps } from './typedeps';
+/** Valid extensions for TypeScript module files */
+export declare const MODULE_EXTENSIONS: string[];
+/**
+ * Location of an imported type
+ */
+export interface TypeLocation {
+    readonly typename: string;
+    readonly relativePathNoExt: string;
+}
+/**
+ * Location of an imported type after figuring out its extension
+ */
+export interface TypeLocationWithExt extends TypeLocation {
+    readonly relativePath: string;
+}
+/**
+ * Extracted imported type
+ */
+export interface ExtractedType extends TypeLocationWithExt {
+    /** Type's declaration */
+    readonly content: string;
+    /** Type parameters (e.g. <T>) */
+    readonly typeParams: string[];
+    /** Types this one depends on */
+    readonly dependencies: TypeLocationWithExt[];
+}
+export declare type TypesExtractorContent = Map<string, Map<string, ExtractedType>>;
+/**
+ * Types extractor
+ */
+export declare class TypesExtractor {
+    /** TS-Morph project */
+    readonly project: Project;
+    /** Absolute source path */
+    readonly absoluteSrcPath: string;
+    /** Magic types to replace non-portable types */
+    readonly magicTypes: Array<MagicType>;
+    /** Extracted types */
+    readonly extracted: TypesExtractorContent;
+    constructor(
+    /** TS-Morph project */
+    project: Project, 
+    /** Absolute source path */
+    absoluteSrcPath: string, 
+    /** Magic types to replace non-portable types */
+    magicTypes: Array<MagicType>, 
+    /** Extracted types */
+    extracted?: TypesExtractorContent);
+    /**
+     * Check if a type has already been extracted
+     */
+    hasExtractedType(loc: TypeLocationWithExt): boolean;
+    /**
+     * Get a type that was previously extracted
+     */
+    getExtractedType(loc: TypeLocationWithExt): ExtractedType | null;
+    /**
+     * Find the extension of a TypeScript module
+     * @param loc
+     * @returns
+     */
+    guessExtractedTypeModuleFileExt(loc: TypeLocation): string | null;
+    /**
+     * Find if a type has previously been extracted, without providing its extension
+     * @param loc
+     * @returns
+     */
+    findExtractedTypeWithoutExt(loc: TypeLocation): ExtractedType | null;
+    /**
+     * Memorize an extracted type so it can be reused later on
+     * @param loc
+     * @param extracted
+     */
+    memorizeExtractedType(loc: TypeLocationWithExt, extracted: ExtractedType): void;
+    /**
+     * Find the relative file location of a type
+     * @param loc
+     * @returns
+     */
+    findTypeRelativeFilePath(loc: TypeLocation): string | Error;
+    /**
+     * Extract a type
+     * @param loc
+     * @param typesPath
+     * @returns
+     */
+    extractType(loc: TypeLocation, typesPath?: string[]): ExtractedType | Error;
+}
+/**
+ * Locate the files containing a list of a resolved types
+ * @param resolvedTypes
+ * @returns
+ */
+export declare function locateTypesFile(resolvedTypes: Array<ResolvedTypeDeps>): TypeLocation[];
+/**
+ * Flatten a tree of resolved type dependencies
+ * @param sdkModules
+ * @returns
+ */
+export declare function flattenSdkResolvedTypes(sdkModules: SdkModules): ResolvedTypeDeps[];

package/build/analyzer/extractor.js

@@ -0,0 +1,349 @@
+"use strict";
+/**
+ * @file Types extractor to use in the generated SDK
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenSdkResolvedTypes = exports.locateTypesFile = exports.TypesExtractor = exports.MODULE_EXTENSIONS = void 0;
+const path = require("path");
+const ts_morph_1 = require("ts-morph");
+const logging_1 = require("../logging");
+const classdeps_1 = require("./classdeps");
+const typedeps_1 = require("./typedeps");
+/** Valid extensions for TypeScript module files */
+exports.MODULE_EXTENSIONS = ['.ts', '.d.ts', '.tsx', '.d.tsx', '.js', '.jsx'];
+/**
+ * Types extractor
+ */
+class TypesExtractor {
+    constructor(
+    /** TS-Morph project */
+    project, 
+    /** Absolute source path */
+    absoluteSrcPath, 
+    /** Magic types to replace non-portable types */
+    magicTypes, 
+    /** Extracted types */
+    extracted = new Map()) {
+        this.project = project;
+        this.absoluteSrcPath = absoluteSrcPath;
+        this.magicTypes = magicTypes;
+        this.extracted = extracted;
+    }
+    /**
+     * Check if a type has already been extracted
+     */
+    hasExtractedType(loc) {
+        const files = this.extracted.get(loc.relativePath);
+        return files ? files.has(loc.typename) : false;
+    }
+    /**
+     * Get a type that was previously extracted
+     */
+    getExtractedType(loc) {
+        var _a, _b;
+        return (_b = (_a = this.extracted.get(loc.relativePath)) === null || _a === void 0 ? void 0 : _a.get(loc.typename)) !== null && _b !== void 0 ? _b : null;
+    }
+    /**
+     * Find the extension of a TypeScript module
+     * @param loc
+     * @returns
+     */
+    guessExtractedTypeModuleFileExt(loc) {
+        for (const ext of exports.MODULE_EXTENSIONS) {
+            if (this.extracted.has(loc.relativePathNoExt + ext)) {
+                return loc.relativePathNoExt + ext;
+            }
+        }
+        return null;
+    }
+    /**
+     * Find if a type has previously been extracted, without providing its extension
+     * @param loc
+     * @returns
+     */
+    findExtractedTypeWithoutExt(loc) {
+        var _a;
+        for (const ext of exports.MODULE_EXTENSIONS) {
+            const typ = (_a = this.extracted.get(loc.relativePathNoExt + ext)) === null || _a === void 0 ? void 0 : _a.get(loc.typename);
+            if (typ) {
+                return typ;
+            }
+        }
+        return null;
+    }
+    /**
+     * Memorize an extracted type so it can be reused later on
+     * @param loc
+     * @param extracted
+     */
+    memorizeExtractedType(loc, extracted) {
+        let files = this.extracted.get(loc.relativePath);
+        if (!files) {
+            files = new Map();
+            this.extracted.set(loc.relativePath, files);
+        }
+        if (!files.has(loc.typename)) {
+            files.set(loc.typename, extracted);
+        }
+    }
+    /**
+     * Find the relative file location of a type
+     * @param loc
+     * @returns
+     */
+    findTypeRelativeFilePath(loc) {
+        if (path.isAbsolute(loc.relativePathNoExt)) {
+            (0, logging_1.unreachable)('Internal error: got absolute file path in types extractor, when expecting a relative one (got {magentaBright})', loc.relativePathNoExt);
+        }
+        const absolutePathNoExt = path.resolve(this.absoluteSrcPath, loc.relativePathNoExt);
+        const cached = this.findExtractedTypeWithoutExt(loc);
+        if (cached) {
+            return cached.relativePath;
+        }
+        let relativeFilePath = null;
+        for (const ext of exports.MODULE_EXTENSIONS) {
+            try {
+                this.project.getSourceFileOrThrow(absolutePathNoExt + ext);
+                relativeFilePath = loc.relativePathNoExt + ext;
+            }
+            catch (e) {
+                continue;
+            }
+        }
+        return (relativeFilePath !== null && relativeFilePath !== void 0 ? relativeFilePath : new Error((0, logging_1.format)('File {magenta} was not found (was expected to contain dependency type {yellow})', loc.relativePathNoExt, loc.typename)));
+    }
+    /**
+     * Extract a type
+     * @param loc
+     * @param typesPath
+     * @returns
+     */
+    extractType(loc, typesPath = []) {
+        var _a, _b;
+        if (path.isAbsolute(loc.relativePathNoExt)) {
+            (0, logging_1.unreachable)('Internal error: got absolute file path in types extractor, when expecting a relative one (got {magentaBright})', loc.relativePathNoExt);
+        }
+        // Get the absolute path of the type's parent file
+        // We don't know its extension yet as imported file names in import statements don't have an extension
+        const absolutePathNoExt = path.resolve(this.absoluteSrcPath, loc.relativePathNoExt);
+        // If the type is already in cache, return it directly
+        const cached = this.findExtractedTypeWithoutExt(loc);
+        if (cached) {
+            return cached;
+        }
+        // Try to find the path with extension of the file and get it as a TS-Morph file
+        let fileAndPath = null;
+        for (const ext of exports.MODULE_EXTENSIONS) {
+            try {
+                fileAndPath = [this.project.getSourceFileOrThrow(absolutePathNoExt + ext), loc.relativePathNoExt + ext];
+            }
+            catch (e) {
+                continue;
+            }
+        }
+        if (!fileAndPath) {
+            return new Error((0, logging_1.format)('File {magenta} was not found (was expected to contain dependency type {yellow})', loc.relativePathNoExt, loc.typename));
+        }
+        const [file, relativeFilePath] = fileAndPath;
+        // Use magic types to replace non-portable types
+        for (const magicType of this.magicTypes) {
+            if (relativeFilePath.endsWith(`node_modules/${magicType.nodeModuleFilePath}`) && loc.typename === magicType.typeName) {
+                (0, logging_1.debug)('-> '.repeat(typesPath.length + 1) +
+                    'Found magic type {yellow} from external module file {magentaBright}, using provided placeholder.', loc.typename, relativeFilePath);
+                const extracted = {
+                    content: '/** @file Magic placeholder from configuration file */\n\n' + magicType.placeholderContent,
+                    relativePath: relativeFilePath,
+                    relativePathNoExt: loc.relativePathNoExt,
+                    typename: loc.typename,
+                    typeParams: [],
+                    dependencies: [],
+                };
+                typesPath.pop();
+                let types = this.extracted.get(relativeFilePath);
+                if (!types) {
+                    types = new Map();
+                    this.extracted.set(relativeFilePath, types);
+                }
+                types.set(loc.typename, extracted);
+                return extracted;
+            }
+        }
+        (0, logging_1.debug)('-> '.repeat(typesPath.length + 1) + 'Extracting type {yellow} from file {magentaBright}...', loc.typename, relativeFilePath);
+        // Analyze the type's declaration
+        const decl = file.forEachChildAsArray().find((node) => {
+            return ((ts_morph_1.Node.isEnumDeclaration(node) ||
+                ts_morph_1.Node.isTypeAliasDeclaration(node) ||
+                ts_morph_1.Node.isInterfaceDeclaration(node) ||
+                ts_morph_1.Node.isClassDeclaration(node) ||
+                ts_morph_1.Node.isFunctionDeclaration(node)) &&
+                node.getName() === loc.typename);
+        });
+        if (!decl) {
+            return new Error((0, logging_1.format)(`Type {yellow} was not found in file {magenta}`, loc.typename, relativeFilePath));
+        }
+        // Handle a limitation of the tool: you can't import two types from two files at the same path with just two different extensions
+        // Example: importing a type named "User" from two files in the same directory called "user.entity.ts" and "user.entity.js"
+        const typ = this.findExtractedTypeWithoutExt(loc);
+        if (typ && typ.relativePath !== relativeFilePath) {
+            (0, logging_1.panic)('Found two conflicting files at same path but with different extensions:\n> {magentaBright}\n> {magentaBright}', typ.relativePath, relativeFilePath);
+        }
+        /** Resolved type's dependencies */
+        let resolvedDeps;
+        /** Type's parameters (e.g. <T>) */
+        let typeParams;
+        /** Type declaration */
+        let extractedDecl = decl.getText();
+        // Handle enumerations
+        if (ts_morph_1.Node.isEnumDeclaration(decl)) {
+            resolvedDeps = [];
+            typeParams = [];
+        }
+        // Handle type aliases
+        else if (ts_morph_1.Node.isTypeAliasDeclaration(decl)) {
+            resolvedDeps = [(0, typedeps_1.resolveTypeDependencies)(decl.getType(), relativeFilePath, this.absoluteSrcPath)];
+            typeParams = [];
+        }
+        // Handle interfaces
+        else if (ts_morph_1.Node.isInterfaceDeclaration(decl)) {
+            resolvedDeps = (0, classdeps_1.analyzeClassDeps)(decl, relativeFilePath, this.absoluteSrcPath);
+            typeParams = decl.getTypeParameters().map((tp) => tp.getText());
+        }
+        // Handle classes
+        // Methods are not handled because they shouldn't be used as DTOs and won't be decodable from JSON in all cases
+        // This part is tricky as we remake the class from scratch using the informations we have on it, given we have to get rid
+        //  of methods as well as removing decorators
+        else if (ts_morph_1.Node.isClassDeclaration(decl)) {
+            const classHead = decl.getText().match(/\b(export[^{]+class[^{]+{)/);
+            if (!classHead) {
+                (0, logging_1.unreachable)('Internal error: failed to match class head in declaration: {yellow}', decl.getText());
+            }
+            extractedDecl = classHead[1];
+            const index = (_a = decl.getType().getStringIndexType()) !== null && _a !== void 0 ? _a : decl.getType().getNumberIndexType();
+            if (index) {
+                extractedDecl += '\npublic [input: string | number]: ' + (0, typedeps_1.getImportResolvedType)(index);
+            }
+            // Export all members
+            for (const member of decl.getMembers()) {
+                if (!ts_morph_1.Node.isPropertyDeclaration(member)) {
+                    (0, logging_1.warn)('Found non-property member in class {cyan}: {magenta}', (_b = decl.getName()) !== null && _b !== void 0 ? _b : '<anonymous>', member.getText());
+                    continue;
+                }
+                const memberType = member.getType();
+                extractedDecl += `\npublic ${member.getName()}${member.getText().includes('?') ? '?' : member.getText().includes('!:') ? '!' : ''}: ${(0, typedeps_1.getImportResolvedType)(memberType)};`;
+            }
+            extractedDecl += '\n}';
+            resolvedDeps = (0, classdeps_1.analyzeClassDeps)(decl, relativeFilePath, this.absoluteSrcPath);
+            typeParams = decl.getTypeParameters().map((tp) => tp.getText());
+        }
+        // Handle functions
+        else if (ts_morph_1.Node.isFunctionDeclaration(decl)) {
+            resolvedDeps = [];
+            typeParams = [];
+        }
+        // Handle unknown types
+        else {
+            (0, logging_1.panic)('Unknown node type when extracting types: ' + decl.getKindName());
+        }
+        /** Normalized dependencies */
+        const dependencies = [];
+        // Ensure we're not stuck in an infinite loop where we analyze a type A, then its dependency B, which itself depends on A, and so on
+        if (typesPath.includes(loc.typename)) {
+            (0, logging_1.unreachable)(`Internal error: infinite loop detected in types extracted: {yellow}`, typesPath.join(' -> '));
+        }
+        typesPath.push(loc.typename);
+        // Analyze all dependencies
+        for (const dependencyLoc of locateTypesFile(resolvedDeps)) {
+            // If the "dependency" is one of the type's parameters (e.g. "T"), ignore this part
+            if (typeParams.includes(dependencyLoc.typename)) {
+                continue;
+            }
+            // Find the dependency's relative path
+            let relativePath;
+            const cached = this.findExtractedTypeWithoutExt(dependencyLoc);
+            if (cached) {
+                relativePath = cached.relativePath;
+            }
+            else if (typesPath.includes(dependencyLoc.typename)) {
+                relativePath = this.findTypeRelativeFilePath(dependencyLoc);
+            }
+            else {
+                const extracted = this.extractType(dependencyLoc, typesPath);
+                relativePath = extracted instanceof Error ? extracted : extracted.relativePath;
+            }
+            if (relativePath instanceof Error) {
+                return new Error((0, logging_1.format)('├─ Failed to extract type {yellow} due to an error in dependency type {yellow}\nfrom file {magenta} :\n{}', loc.typename, dependencyLoc.typename, relativeFilePath, relativePath.message.replace(/^/gm, '  ')));
+            }
+            // Update dependencies
+            dependencies.push(Object.assign(Object.assign({}, dependencyLoc), { relativePath }));
+        }
+        const extracted = Object.assign(Object.assign({}, loc), { relativePath: relativeFilePath, typeParams, content: extractedDecl, dependencies });
+        typesPath.pop();
+        let types = this.extracted.get(relativeFilePath);
+        if (!types) {
+            types = new Map();
+            this.extracted.set(relativeFilePath, types);
+        }
+        // Save the dependency
+        types.set(loc.typename, extracted);
+        return extracted;
+    }
+}
+exports.TypesExtractor = TypesExtractor;
+/**
+ * Locate the files containing a list of a resolved types
+ * @param resolvedTypes
+ * @returns
+ */
+function locateTypesFile(resolvedTypes) {
+    const out = new Array();
+    for (const resolved of resolvedTypes) {
+        for (const [file, types] of resolved.dependencies) {
+            for (const typename of types) {
+                if (!out.find((loc) => loc.typename === typename && loc.relativePathNoExt === file)) {
+                    out.push({ typename, relativePathNoExt: file });
+                }
+            }
+        }
+        for (const typename of resolved.localTypes) {
+            if (!out.find((loc) => loc.typename === typename && loc.relativePathNoExt === resolved.relativeFilePath)) {
+                out.push({ typename, relativePathNoExt: resolved.relativeFilePath });
+            }
+        }
+    }
+    return out;
+}
+exports.locateTypesFile = locateTypesFile;
+/**
+ * Flatten a tree of resolved type dependencies
+ * @param sdkModules
+ * @returns
+ */
+function flattenSdkResolvedTypes(sdkModules) {
+    const flattened = new Array();
+    for (const module of sdkModules.values()) {
+        for (const controller of module.values()) {
+            for (const method of controller.methods.values()) {
+                const { parameters: args, query, body } = method.params;
+                flattened.push(method.returnType);
+                if (args) {
+                    flattened.push(...args.values());
+                }
+                if (query) {
+                    flattened.push(...query.values());
+                }
+                if (!body) {
+                    continue;
+                }
+                if (body.full) {
+                    flattened.push(body.type);
+                }
+                else {
+                    flattened.push(...body.fields.values());
+                }
+            }
+        }
+    }
+    return flattened;
+}
+exports.flattenSdkResolvedTypes = flattenSdkResolvedTypes;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extractor.js","sourceRoot":"","sources":["../../src/analyzer/extractor.ts"],"names":[],"mappings":"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"}

package/build/analyzer/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file Entrypoint of the source API analyzer, used to generate the final SDK
+ */
+import { Config } from '../config';
+import { SdkModules } from './controllers';
+import { TypesExtractorContent } from './extractor';
+export interface SdkContent {
+    readonly modules: SdkModules;
+    readonly types: TypesExtractorContent;
+}
+export interface MagicType {
+    readonly package: string;
+    readonly typeName: string;
+    readonly content: string;
+}
+export declare function analyzerCli(config: Config): Promise<SdkContent>;