@buildvision/nest-sdk-generator 1.1.3

package/build/analyzer/index.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * @file Entrypoint of the source API analyzer, used to generate the final SDK
+ */
+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 });
+exports.analyzerCli = void 0;
+const fs = require("fs");
+const path = require("path");
+const ts_morph_1 = require("ts-morph");
+const logging_1 = require("../logging");
+const builtin_1 = require("./builtin");
+const controllers_1 = require("./controllers");
+const extractor_1 = require("./extractor");
+function analyzerCli(config) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const started = Date.now();
+        const sourcePath = path.resolve(process.cwd(), config.apiInputPath);
+        if (!sourcePath)
+            (0, logging_1.panic)('Please provide a source directory');
+        if (!fs.existsSync(sourcePath))
+            (0, logging_1.panic)('Provided source path {magentaBright} does not exist', sourcePath);
+        if (!fs.lstatSync(sourcePath).isDirectory())
+            (0, logging_1.panic)('Provided source path is not a directory');
+        (0, logging_1.debug)(`Analyzing from source directory {yellow}`, sourcePath);
+        if (config.jsonOutput) {
+            const jsonOutputParentDir = path.dirname(path.resolve(process.cwd(), config.jsonOutput));
+            if (!fs.existsSync(jsonOutputParentDir)) {
+                (0, logging_1.panic)("Output file's parent directory {magentaBright} does not exist.", jsonOutputParentDir);
+            }
+            (0, logging_1.debug)('Writing output to {yellow}', config.jsonOutput, config.jsonPrettyOutput ? 'beautified' : 'minified');
+        }
+        // ====== Find & parse 'tsconfig.json' ====== //
+        if (config.tsconfigFile && config.tsconfigFile.includes('/')) {
+            (0, logging_1.panic)('Provided tsconfig file name contains slashes');
+        }
+        const tsConfigFileName = (_a = config.tsconfigFile) !== null && _a !== void 0 ? _a : 'tsconfig.json';
+        const tsConfigFilePath = path.join(sourcePath, tsConfigFileName);
+        if (!fs.existsSync(tsConfigFilePath)) {
+            (0, logging_1.panic)('No {yellow} file found in provided source path {yellow}', tsConfigFileName, sourcePath);
+        }
+        // Create a 'ts-morph' project
+        const project = new ts_morph_1.Project({
+            tsConfigFilePath,
+        });
+        // Get the list of all TypeScript files in the source directory
+        const sourceTSFiles = project.getSourceFiles().map((file) => path.relative(sourcePath, file.getFilePath()));
+        (0, logging_1.debug)(`Found {magentaBright} source files.`, sourceTSFiles.length);
+        // Add them
+        (0, logging_1.debug)('\nAdding them to the source project...');
+        let progressByTenth = 0;
+        let strLen = sourceTSFiles.length.toString().length;
+        const hasProgress = (filesTreated) => filesTreated / sourceTSFiles.length >= (progressByTenth + 1) / 10;
+        const controllers = [];
+        for (let i = 0; i < sourceTSFiles.length; i++) {
+            const file = sourceTSFiles[i];
+            if (file.endsWith('.controller.ts')) {
+                controllers.push(file);
+            }
+            if (hasProgress(i + 1)) {
+                while (hasProgress(i + 1))
+                    progressByTenth++;
+                (0, logging_1.debug)('| Progress: {yellow} ({magentaBright} files) - {green} controller{} found', (progressByTenth * 10).toString().padStart(3, ' ') + '%', `${(i + 1).toString().padStart(strLen, ' ')} / ${sourceTSFiles.length}`, controllers.length.toString().padStart(strLen, ''), controllers.length > 1 ? 's' : '');
+            }
+        }
+        (0, logging_1.debug)('All files were added successfully.\n');
+        const modules = (0, controllers_1.analyzeControllers)(controllers, sourcePath, project);
+        // Builtin magic types are concatenated **after** the configuration's ones, as this allows users to
+        // override the builtin ones if they want. Do **not** change the concatenation order!
+        const magicTypes = ((_b = config.magicTypes) !== null && _b !== void 0 ? _b : []).concat(builtin_1.builtinMagicTypes);
+        const typesCache = new extractor_1.TypesExtractor(project, sourcePath, magicTypes);
+        const typesToExtract = (0, extractor_1.locateTypesFile)((0, extractor_1.flattenSdkResolvedTypes)(modules));
+        (0, logging_1.debug)('\n==== Extracting {} type' + (typesToExtract.length > 1 ? 's' : '') + ' ====\n', typesToExtract.length);
+        for (const loc of typesToExtract) {
+            const result = typesCache.extractType(loc);
+            if (result instanceof Error) {
+                (0, logging_1.panic)(result.message);
+            }
+        }
+        const content = {
+            modules,
+            types: typesCache.extracted,
+        };
+        if (config.jsonOutput) {
+            fs.writeFileSync(config.jsonOutput, JSON.stringify(content, (_, v) => (v instanceof Map ? Object.fromEntries(v) : v), config.jsonPrettyOutput ? 4 : 0), 'utf8');
+        }
+        (0, logging_1.debug)('\n===== Done in {green}! ====', ((Date.now() - started) / 1000).toFixed(2) + 's');
+        return content;
+    });
+}
+exports.analyzerCli = analyzerCli;
+//# sourceMappingURL=data:application/json;base64,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

package/build/analyzer/methods.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @file Analyzer for the source API's methods
+ */
+import { ClassDeclaration } from 'ts-morph';
+import { SdkMethodParams } from './params';
+import { Route } from './route';
+import { ResolvedTypeDeps } from './typedeps';
+/**
+ * SDK interface for a single controller's method
+ */
+export interface SdkMethod {
+    /** Method's name */
+    readonly name: string;
+    /** Method's HTTP method (e.g. GET / POST) */
+    readonly httpMethod: SdkHttpMethod;
+    /** Method's return type with resolved dependencies */
+    readonly returnType: ResolvedTypeDeps;
+    /** Method's parsed route */
+    readonly route: Route;
+    /** Method's URI path */
+    readonly uriPath: string;
+    /** Method's parameters */
+    readonly params: SdkMethodParams;
+}
+/**
+ * HTTP method of a controller's method
+ */
+export declare enum SdkHttpMethod {
+    Get = "GET",
+    Post = "POST",
+    Put = "PUT",
+    Patch = "PATCH",
+    Delete = "DELETE"
+}
+/**
+ * Generate a SDK interface for a controller
+ * @param controllerClass The class declaration of the controller
+ * @param controllerUriPrefix Optional URI prefix for this controller (e.g. `@Controller("registrationName")`)
+ * @param filePath Path to the controller's file
+ * @param absoluteSrcPath Absolute path to the source directory
+ */
+export declare function analyzeMethods(controllerClass: ClassDeclaration, controllerUriPrefix: string | null, filePath: string, absoluteSrcPath: string): SdkMethod[] | Error;

package/build/analyzer/methods.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * @file Analyzer for the source API's methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeMethods = exports.SdkHttpMethod = void 0;
+const chalk_1 = require("chalk");
+const ts_morph_1 = require("ts-morph");
+const logging_1 = require("../logging");
+const params_1 = require("./params");
+const route_1 = require("./route");
+const typedeps_1 = require("./typedeps");
+/**
+ * HTTP method of a controller's method
+ */
+var SdkHttpMethod;
+(function (SdkHttpMethod) {
+    SdkHttpMethod["Get"] = "GET";
+    SdkHttpMethod["Post"] = "POST";
+    SdkHttpMethod["Put"] = "PUT";
+    SdkHttpMethod["Patch"] = "PATCH";
+    SdkHttpMethod["Delete"] = "DELETE";
+})(SdkHttpMethod = exports.SdkHttpMethod || (exports.SdkHttpMethod = {}));
+/**
+ * Generate a SDK interface for a controller
+ * @param controllerClass The class declaration of the controller
+ * @param controllerUriPrefix Optional URI prefix for this controller (e.g. `@Controller("registrationName")`)
+ * @param filePath Path to the controller's file
+ * @param absoluteSrcPath Absolute path to the source directory
+ */
+function analyzeMethods(controllerClass, controllerUriPrefix, filePath, absoluteSrcPath) {
+    // Output variable
+    const collected = new Array();
+    // Get the list of all methods
+    const methods = controllerClass.forEachChildAsArray().filter((node) => node instanceof ts_morph_1.MethodDeclaration);
+    for (const method of methods) {
+        const methodName = method.getName();
+        (0, logging_1.debug)('├─ Found method: {yellow}', methodName);
+        // Get the HTTP decorator(s) of the method
+        const decorators = method.getDecorators().filter((dec) => Object.keys(SdkHttpMethod).includes(dec.getName()));
+        // We expect to have exactly one HTTP decorator
+        if (decorators.length > 1) {
+            // If there is more than one decorator, that's invalid, so we can't analyze the method
+            return new Error((0, logging_1.format)('├─── Detected multiple HTTP decorators on method: {yellow}' + decorators.map((dec) => dec.getName()).join(',')));
+        }
+        else if (decorators.length === 0) {
+            // If there isn't any HTTP decorator, this is simply not a method available from the outside and so we won't generate an interface for it
+            (0, logging_1.debug)('├─── Skipping this method as it does not have an HTTP decorator');
+            continue;
+        }
+        // Get the HTTP decorator
+        const dec = decorators[0];
+        // We need to put a '@ts-ignore' here because TypeScript doesn't like indexing an enumeration with a string key, although this works fine
+        // @ts-ignore
+        const httpMethod = SdkHttpMethod[dec.getName()];
+        (0, logging_1.debug)('├─── Detected HTTP method: {magentaBright}', httpMethod.toLocaleUpperCase());
+        // Get the arguments provided to the HTTP decorator (we expect one, the URI path)
+        const decArgs = dec.getArguments();
+        // The method's URI path
+        let uriPath;
+        // We expect the decorator to have exactly one argument
+        if (decArgs.length > 1) {
+            // If we have more than one argument, that's invalid (or at least not supported here), so we can't analyze the method
+            return new Error(`Multiple (${decArgs.length}) arguments were provided to the HTTP decorator`);
+        }
+        else if (decArgs.length === 0) {
+            // If there is no argument, we take the method's name as the URI path
+            (0, logging_1.debug)('├─── No argument found for decorator, using base URI path.');
+            uriPath = '';
+        }
+        else {
+            // If we have exactly one argument, hurray! That's our URI path.
+            const uriNameDec = decArgs[0];
+            // Variables are not supported
+            if (!ts_morph_1.Node.isStringLiteral(uriNameDec)) {
+                return new Error((0, logging_1.format)('├─── The argument provided to the HTTP decorator is not a string literal:\n>> {cyan}', uriNameDec.getText()));
+            }
+            // Update the method's URI path
+            uriPath = uriNameDec.getLiteralText();
+            (0, logging_1.debug)('├─── Detected argument in HTTP decorator, mapping this method to custom URI name');
+        }
+        (0, logging_1.debug)('├─── Detected URI name: {yellow}', uriPath);
+        // Analyze the method's URI
+        const route = (0, route_1.analyzeUri)(controllerUriPrefix ? (uriPath ? `/${controllerUriPrefix}/${uriPath}` : `/` + controllerUriPrefix) : uriPath);
+        if (route instanceof Error) {
+            return new Error('├─── Detected unsupported URI format:\n' +
+                route.message
+                    .split('\n')
+                    .map((line) => '├───── ' + line)
+                    .join('\n'));
+        }
+        (0, logging_1.debug)('├─── Parsed URI name to route: {yellow}', (0, route_1.debugUri)(route, chalk_1.blue));
+        // Analyze the method's arguments
+        (0, logging_1.debug)('├─── Analyzing arguments...');
+        const params = (0, params_1.analyzeParams)(httpMethod, route, method.getParameters(), filePath, absoluteSrcPath);
+        if (params instanceof Error)
+            return params;
+        // Get the method's return type
+        (0, logging_1.debug)('├─── Resolving return type...');
+        const returnType = (0, typedeps_1.resolveTypeDependencies)(method.getReturnType(), filePath, absoluteSrcPath);
+        (0, logging_1.debug)('├─── Detected return type: {cyan}', returnType.resolvedType);
+        // Success!
+        collected.push({
+            name: methodName,
+            httpMethod,
+            returnType,
+            route,
+            uriPath,
+            params,
+        });
+    }
+    return collected;
+}
+exports.analyzeMethods = analyzeMethods;
+//# sourceMappingURL=data:application/json;base64,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

package/build/analyzer/module.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Analyzer for the source API's modules
+ */
+import { Project } from 'ts-morph';
+/**
+ * Get the name of a module
+ * @param project TS-Morph project the module is contained in
+ * @param modulePath Path to the module's file
+ * @param sourcePath Path to the TypeScript root directory
+ */
+export declare function getModuleName(project: Project, modulePath: string, sourcePath: string): string;

package/build/analyzer/module.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * @file Analyzer for the source API's modules
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModuleName = void 0;
+const path = require("path");
+const ts_morph_1 = require("ts-morph");
+const logging_1 = require("../logging");
+/**
+ * Get the name of a module
+ * @param project TS-Morph project the module is contained in
+ * @param modulePath Path to the module's file
+ * @param sourcePath Path to the TypeScript root directory
+ */
+function getModuleName(project, modulePath, sourcePath) {
+    // Prepare the source file to analyze
+    const file = project.getSourceFileOrThrow(path.resolve(sourcePath, modulePath));
+    // Find the module class declaration
+    const classDecl = file.forEachChildAsArray().find((node) => ts_morph_1.Node.isClassDeclaration(node) && node.getDecorators().length > 0);
+    if (!classDecl) {
+        (0, logging_1.panic)('No class declaration found in module at {yellow}', modulePath);
+    }
+    if (!ts_morph_1.Node.isClassDeclaration(classDecl))
+        (0, logging_1.panic)('Internal error: found class declaration statement which is not an instance of ClassDeclaration');
+    const moduleName = classDecl.getName();
+    if (moduleName === undefined) {
+        (0, logging_1.panic)('Internal error: failed to retrieve name of declared class');
+    }
+    const decorators = classDecl.getDecorators();
+    if (decorators.length > 1) {
+        (0, logging_1.panic)(`Found multiple decorators on module class {yellow} declared at {yellow}`, moduleName, modulePath);
+    }
+    const decName = decorators[0].getName();
+    if (decName !== 'Module') {
+        (0, logging_1.panic)((0, logging_1.format)(`The decorator on module class {yellow} was expected to be a {yellow}, found an {yellow} instead\nModule path is: {yellow}`, moduleName, '@Module', '@' + decName, modulePath));
+    }
+    return moduleName.substr(0, 1).toLocaleLowerCase() + moduleName.substr(1);
+}
+exports.getModuleName = getModuleName;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FuYWx5emVyL21vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7O0dBRUc7OztBQUVILDZCQUE0QjtBQUM1Qix1Q0FBd0M7QUFDeEMsd0NBQTBDO0FBRTFDOzs7OztHQUtHO0FBQ0gsU0FBZ0IsYUFBYSxDQUFDLE9BQWdCLEVBQUUsVUFBa0IsRUFBRSxVQUFrQjtJQUNwRixxQ0FBcUM7SUFDckMsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLG9CQUFvQixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSxFQUFFLFVBQVUsQ0FBQyxDQUFDLENBQUE7SUFFL0Usb0NBQW9DO0lBQ3BDLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxtQkFBbUIsRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsZUFBSSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUE7SUFFN0gsSUFBSSxDQUFDLFNBQVMsRUFBRTtRQUNkLElBQUEsZUFBSyxFQUFDLGtEQUFrRCxFQUFFLFVBQVUsQ0FBQyxDQUFBO0tBQ3RFO0lBRUQsSUFBSSxDQUFDLGVBQUksQ0FBQyxrQkFBa0IsQ0FBQyxTQUFTLENBQUM7UUFDckMsSUFBQSxlQUFLLEVBQUMsZ0dBQWdHLENBQUMsQ0FBQTtJQUV6RyxNQUFNLFVBQVUsR0FBRyxTQUFTLENBQUMsT0FBTyxFQUFFLENBQUE7SUFFdEMsSUFBSSxVQUFVLEtBQUssU0FBUyxFQUFFO1FBQzVCLElBQUEsZUFBSyxFQUFDLDJEQUEyRCxDQUFDLENBQUE7S0FDbkU7SUFFRCxNQUFNLFVBQVUsR0FBRyxTQUFTLENBQUMsYUFBYSxFQUFFLENBQUE7SUFFNUMsSUFBSSxVQUFVLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRTtRQUN6QixJQUFBLGVBQUssRUFBQyx5RUFBeUUsRUFBRSxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUE7S0FDekc7SUFFRCxNQUFNLE9BQU8sR0FBRyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxFQUFFLENBQUE7SUFFdkMsSUFBSSxPQUFPLEtBQUssUUFBUSxFQUFFO1FBQ3hCLElBQUEsZUFBSyxFQUNILElBQUEsZ0JBQU0sRUFDSiwySEFBMkgsRUFDM0gsVUFBVSxFQUNWLFNBQVMsRUFDVCxHQUFHLEdBQUcsT0FBTyxFQUNiLFVBQVUsQ0FDWCxDQUNGLENBQUE7S0FDRjtJQUVELE9BQU8sVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsaUJBQWlCLEVBQUUsR0FBRyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBQzNFLENBQUM7QUF6Q0Qsc0NBeUNDIn0=

package/build/analyzer/params.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @file Analyzer for the source API's controllers' methods' parameters
+ */
+import { ParameterDeclaration } from 'ts-morph';
+import { SdkHttpMethod } from './methods';
+import { Route } from './route';
+import { ResolvedTypeDeps } from './typedeps';
+/**
+ * SDK interface for a controller's method's parameters
+ */
+export interface SdkMethodParams {
+    /** Route parameters */
+    parameters: Map<string, ResolvedTypeDeps> | null;
+    /** Query parameters */
+    query: Map<string, ResolvedTypeDeps> | null;
+    /** Body parameters */
+    body: SdkMethodBodyParam | null;
+}
+/**
+ * Single body parameter in a SDK's method
+ */
+export declare type SdkMethodBodyParam = {
+    full: true;
+    type: ResolvedTypeDeps;
+} | {
+    full: false;
+    fields: Map<string, ResolvedTypeDeps>;
+};
+/**
+ * Generate a SDK interface for a controller's method's parameters
+ * @param httpMethod The method's HTTP method
+ * @param route The method's route
+ * @param args The method's arguments
+ * @param filePath Path to the controller's file
+ * @param absoluteSrcPath Absolute path to the source directory
+ * @returns A SDK interface for the method's parameters
+ */
+export declare function analyzeParams(httpMethod: SdkHttpMethod, route: Route, args: ParameterDeclaration[], filePath: string, absoluteSrcPath: string): SdkMethodParams | Error;

package/build/analyzer/params.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * @file Analyzer for the source API's controllers' methods' parameters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeParams = void 0;
+const logging_1 = require("../logging");
+const decorator_1 = require("./decorator");
+const methods_1 = require("./methods");
+const route_1 = require("./route");
+const typedeps_1 = require("./typedeps");
+/**
+ * Generate a SDK interface for a controller's method's parameters
+ * @param httpMethod The method's HTTP method
+ * @param route The method's route
+ * @param args The method's arguments
+ * @param filePath Path to the controller's file
+ * @param absoluteSrcPath Absolute path to the source directory
+ * @returns A SDK interface for the method's parameters
+ */
+function analyzeParams(httpMethod, route, args, filePath, absoluteSrcPath) {
+    var _a, _b, _c, _d;
+    // The collected informations we will return
+    const collected = {
+        parameters: null,
+        query: null,
+        body: null,
+    };
+    // Get the named parameters of the route
+    const routeParams = (0, route_1.paramsOfRoute)(route);
+    // Treat all arguments (to not confuse with the route's parameters)
+    for (const arg of args) {
+        const name = arg.getName();
+        (0, logging_1.debug)('├───── Detected argument: {yellow}', name);
+        // Arguments are collected as soon as they have a decorator like @Query() or @Body()
+        const decs = arg.getDecorators();
+        if (decs.length === 0) {
+            // If we have no argument, this is not an argument we are interested in, so we just skip it
+            (0, logging_1.debug)('├───── Skipping this argument as it does not have a decorator');
+            continue;
+        }
+        else if (decs.length > 1) {
+            // If we have more than one decorator, this could mean we have for instance an @NotEmpty() @Query() or something like this,
+            //  which is currently not supported.
+            return new Error('Skipping this argument as it has multiple decorators, which is currently not supported');
+        }
+        // Get the only decrator
+        const dec = decs[0];
+        const decName = dec.getName();
+        // Treat the @Param() decorator
+        if (decName === 'Param') {
+            (0, logging_1.debug)('├───── Detected decorator {blue}', '@Param');
+            // We expect a single string argument for this decorator,
+            // which is the route parameter's name
+            const paramName = (0, decorator_1.expectSingleStrLitDecorator)(dec);
+            if (paramName instanceof Error)
+                return paramName;
+            // If there is no argument, this argument is a global receiver which maps the full set of parameters
+            // We theorically *could* extract the type informations from this object type, but this would be insanely complex
+            // So, we just skip it as it's a lot more simple, and is not commonly used anyway as it has a set of downsides
+            if (paramName === null) {
+                (0, logging_1.warn)('├───── Skipping this argument as it is a generic parameters receiver, which is currently not supported');
+                continue;
+            }
+            // Ensure the specified parameter appears in the method's route
+            if (!routeParams.includes(paramName))
+                return new Error((0, logging_1.format)('├───── Cannot map unknown parameter {yellow}', paramName));
+            (0, logging_1.debug)('├───── Mapping argument to parameter: {yellow}', paramName);
+            // Get the route parameter's type
+            const typ = (0, typedeps_1.resolveTypeDependencies)(arg.getType(), filePath, absoluteSrcPath);
+            (0, logging_1.debug)('├───── Detected parameter type: {yellow} ({magentaBright} dependencies)', typ.resolvedType, typ.dependencies.size);
+            // Update the method's route parameters
+            if (paramName in {}) {
+                return new Error((0, logging_1.format)(`Detected @Param() field whose name {yellow} collides with a JavaScript's native object property`, paramName));
+            }
+            (_a = collected.parameters) !== null && _a !== void 0 ? _a : (collected.parameters = new Map());
+            collected.parameters.set(paramName, typ);
+        }
+        // Treat the @Query() decorator
+        else if (decName === 'Query') {
+            (0, logging_1.debug)('├───── Detected decorator {blue}', '@Query');
+            // We expect a single string argument for this decorator,
+            // which is the query parameter's name
+            const queryName = (0, decorator_1.expectSingleStrLitDecorator)(dec);
+            if (queryName instanceof Error)
+                return queryName;
+            // If there is no argument, this argument is a global receiver which maps the full set of parameters
+            // We theorically *could* extract the type informations from this object type, but this would be insanely complex
+            // So, we just skip it as it's a lot more simple, and is not commonly used anyway as it has a set of downsides
+            if (queryName === null) {
+                (0, logging_1.warn)('├───── Skipping this argument as it is a generic query receiver');
+                continue;
+            }
+            (0, logging_1.debug)('├───── Mapping argument to query: {yellow}', queryName);
+            // Get the parameter's type
+            const typ = (0, typedeps_1.resolveTypeDependencies)(arg.getType(), filePath, absoluteSrcPath);
+            (0, logging_1.debug)(`├───── Detected query type: {yellow} ({magentaBright} dependencies)`, typ.resolvedType, typ.dependencies.size);
+            // Update the method's query parameter
+            if (queryName in {}) {
+                return new Error((0, logging_1.format)(`Detected @Query() field whose name {yellow} collides with a JavaScript's native object property`, queryName));
+            }
+            (_b = collected.query) !== null && _b !== void 0 ? _b : (collected.query = new Map());
+            collected.query.set(queryName, typ);
+        }
+        // Treat the @Body() decorator
+        else if (decName === 'Body') {
+            (0, logging_1.debug)('├───── Detected decorator {blue}', '@Body');
+            // GET requests cannot have a BODY
+            if (httpMethod === methods_1.SdkHttpMethod.Get) {
+                return new Error('GET requests cannot have a BODY!');
+            }
+            // We expect a single string argument for this decorator,
+            // which is the body field's name
+            const fieldName = (0, decorator_1.expectSingleStrLitDecorator)(dec);
+            if (fieldName instanceof Error)
+                return fieldName;
+            // Get the field's type
+            const typ = (0, typedeps_1.resolveTypeDependencies)(arg.getType(), filePath, absoluteSrcPath);
+            const depsCount = typ.dependencies.size;
+            (0, logging_1.debug)(`├───── Detected BODY type: {cyan} ({magentaBright} ${depsCount === 0 ? 'no dependency' : depsCount > 1 ? 'dependencies' : 'dependency'})`, typ.resolvedType, depsCount);
+            // If there no name was provided to the decorator, then the decorator is a generic receiver which means it maps to the full body type
+            // This also means we can map the BODY type to this argument's type
+            if (fieldName === null) {
+                const body = collected.body;
+                // If we previously had an @Body(<name>) decorator on another argument, we have an important risk of mistyping
+                // => e.g. `@Body("a") a: string, @Body() body: { a: number }` is invalid as the type for the `a` field mismatches
+                // => It's easy to make an error as the @Body() type is often hidden behind a DTO
+                // But that's extremely complex to check automatically, so we just display a warning instead
+                // Also, that's not the kind of thing we make on purpose very often, so it's more likely it's an error, which makes it even more important
+                //  to display a warning here.
+                if ((body === null || body === void 0 ? void 0 : body.full) === false)
+                    (0, logging_1.warn)('├───── Detected full @Body() decorator after a single parameter. This is considered a bad practice, avoid it if you can!');
+                // Having two generic @Body() decorators is meaningless and will likey lead to errors, so we return a precise error here
+                else if (body === null || body === void 0 ? void 0 : body.full) {
+                    return new Error((0, logging_1.format)(`Detected two @Body() decorators: found {yellow} previously, while method argument {yellow} indicates type {yellow}`, body.type.resolvedType, name, typ.resolvedType));
+                }
+                (0, logging_1.debug)("├───── Mapping argument to full request's body");
+                // Update the whole BODY type
+                collected.body = { full: true, type: typ };
+            }
+            else {
+                // Here we have an @Body(<string>) decorator
+                // If we previously had an @Body() decorator, this can lead to several types of errors (see the big comment above for more informations)
+                if ((_c = collected.body) === null || _c === void 0 ? void 0 : _c.full) {
+                    (0, logging_1.warn)('├───── Detected single @Body() decorator after a full parameter. This is considered a bad practice, avoid it if you can!');
+                }
+                else {
+                    (0, logging_1.debug)('├───── Mapping argument to BODY field: {yellow}', fieldName);
+                    // Update the BODY type by adding the current field to it
+                    if (fieldName in {}) {
+                        return new Error((0, logging_1.format)(`Detected @Body() field whose name {yellow} collides with a JavaScript's native object property`, fieldName));
+                    }
+                    (_d = collected.body) !== null && _d !== void 0 ? _d : (collected.body = { full: false, fields: new Map() });
+                    collected.body.fields.set(fieldName, typ);
+                }
+            }
+        }
+    }
+    // Success!
+    return collected;
+}
+exports.analyzeParams = analyzeParams;
+//# sourceMappingURL=data:application/json;base64,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

package/build/analyzer/route.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @file Analyzer for the source API's routes in controller methods
+ */
+/**
+ * A single URI part
+ */
+export declare type RoutePart = {
+    readonly segment: string;
+} | {
+    readonly param: string;
+};
+/**
+ * A parsed URI path
+ */
+export interface Route {
+    /** Is this an absolute route? (routes starting with a '/') */
+    readonly isRoot: boolean;
+    /** The route's parts */
+    readonly parts: RoutePart[];
+}
+/**
+ * Analyze an URI path
+ * @param uriPath The URI path to analyze
+ */
+export declare function analyzeUri(uriPath: string): Route | Error;
+/**
+ * Get the named parameters of a parsed route
+ * @param route
+ */
+export declare function paramsOfRoute(route: Route): string[];
+/**
+ * Convert a route back to its original string
+ * @param route
+ */
+export declare function unparseRoute(route: Route): string;
+/**
+ * Pretty-print a route
+ */
+export declare function debugUri(route: Route, color: (str: string) => string): string;
+/**
+ * Resolve a route by providing its required parameters
+ * @param route
+ * @param params
+ */
+export declare function resolveRoute(route: Route, params: {
+    [name: string]: string;
+}): string | Error;
+/**
+ * Resolve a route by providing its required parameters through a callback
+ * @param route
+ * @param paramsProvider
+ */
+export declare function resolveRouteWith(route: Route, paramsProvider: (param: string) => string | null): string | Error;