@nestia/sdk 11.0.0-dev.20260305 → 11.0.0-dev.20260312

package/src/analyses/GenericAnalyzer.ts

@@ -1,49 +1,49 @@
-import ts from "typescript";
-
-export namespace GenericAnalyzer {
-  export function analyze(
-    checker: ts.TypeChecker,
-    classNode: ts.ClassDeclaration,
-  ): WeakMap<ts.Type, ts.Type> {
-    const dict: WeakMap<ts.Type, ts.Type> = new WeakMap();
-    explore(checker, dict, classNode);
-    return dict;
-  }
-
-  function explore(
-    checker: ts.TypeChecker,
-    dict: WeakMap<ts.Type, ts.Type>,
-    classNode: ts.ClassDeclaration,
-  ): void {
-    if (classNode.heritageClauses === undefined) return;
-
-    for (const heritage of classNode.heritageClauses)
-      for (const hType of heritage.types) {
-        // MUST BE CLASS
-        const expression: ts.Type = checker.getTypeAtLocation(hType.expression);
-        const superNode: ts.Declaration | undefined =
-          expression.symbol?.getDeclarations?.()?.[0];
-
-        if (superNode === undefined || !ts.isClassDeclaration(superNode))
-          continue;
-
-        // SPECIFY GENERICS
-        const usages: ReadonlyArray<ts.TypeNode> = hType.typeArguments || [];
-        const parameters: ReadonlyArray<ts.TypeParameterDeclaration> =
-          superNode.typeParameters || [];
-
-        parameters.forEach((param, index) => {
-          const paramType: ts.Type = checker.getTypeAtLocation(param);
-          const usageType: ts.Type =
-            usages[index] !== undefined
-              ? checker.getTypeAtLocation(usages[index])
-              : checker.getTypeAtLocation(param.default!);
-
-          dict.set(paramType, usageType);
-        });
-
-        // RECURSIVE EXPLORATION
-        explore(checker, dict, superNode);
-      }
-  }
-}
+import ts from "typescript";
+
+export namespace GenericAnalyzer {
+  export function analyze(
+    checker: ts.TypeChecker,
+    classNode: ts.ClassDeclaration,
+  ): WeakMap<ts.Type, ts.Type> {
+    const dict: WeakMap<ts.Type, ts.Type> = new WeakMap();
+    explore(checker, dict, classNode);
+    return dict;
+  }
+
+  function explore(
+    checker: ts.TypeChecker,
+    dict: WeakMap<ts.Type, ts.Type>,
+    classNode: ts.ClassDeclaration,
+  ): void {
+    if (classNode.heritageClauses === undefined) return;
+
+    for (const heritage of classNode.heritageClauses)
+      for (const hType of heritage.types) {
+        // MUST BE CLASS
+        const expression: ts.Type = checker.getTypeAtLocation(hType.expression);
+        const superNode: ts.Declaration | undefined =
+          expression.symbol?.getDeclarations?.()?.[0];
+
+        if (superNode === undefined || !ts.isClassDeclaration(superNode))
+          continue;
+
+        // SPECIFY GENERICS
+        const usages: ReadonlyArray<ts.TypeNode> = hType.typeArguments || [];
+        const parameters: ReadonlyArray<ts.TypeParameterDeclaration> =
+          superNode.typeParameters || [];
+
+        parameters.forEach((param, index) => {
+          const paramType: ts.Type = checker.getTypeAtLocation(param);
+          const usageType: ts.Type =
+            usages[index] !== undefined
+              ? checker.getTypeAtLocation(usages[index])
+              : checker.getTypeAtLocation(param.default!);
+
+          dict.set(paramType, usageType);
+        });
+
+        // RECURSIVE EXPLORATION
+        explore(checker, dict, superNode);
+      }
+  }
+}

package/src/analyses/PathAnalyzer.ts

@@ -1,69 +1,69 @@
-import path from "path";
-import { Token, parse } from "path-to-regexp";
-
-export namespace PathAnalyzer {
-  export const join = (...args: string[]) =>
-    "/" +
-    _Trim(
-      path
-        .join(...args.filter((s) => !!s.length))
-        .split("\\")
-        .join("/"),
-    );
-
-  export const escape = (str: string): string | null => {
-    const args = _Parse(str);
-    if (args === null) return null;
-    return (
-      "/" +
-      args
-        .map((arg) => (arg.type === "param" ? `:${arg.value}` : arg.value))
-        .join("/")
-    );
-  };
-
-  export const parameters = (str: string): string[] | null => {
-    const args = _Parse(str);
-    if (args === null) return null;
-    return args.filter((arg) => arg.type === "param").map((arg) => arg.value);
-  };
-
-  function _Parse(str: string): IArgument[] | null {
-    const tokens: Token[] | null = (() => {
-      try {
-        return parse(path.join(str).split("\\").join("/"));
-      } catch {
-        return null;
-      }
-    })();
-    if (tokens === null) return null;
-
-    const output: IArgument[] = [];
-    for (const key of tokens) {
-      if (typeof key === "string")
-        output.push({
-          type: "path",
-          value: _Trim(key),
-        });
-      else if (typeof key.name === "number" || _Trim(key.name) === "")
-        return null;
-      else
-        output.push({
-          type: "param",
-          value: _Trim(key.name),
-        });
-    }
-    return output;
-  }
-
-  function _Trim(str: string): string {
-    if (str[0] === "/") str = str.substring(1);
-    if (str[str.length - 1] === "/") str = str.substring(0, str.length - 1);
-    return str;
-  }
-
-  interface IArgument {
-    type: "param" | "path";
-    value: string;
-  }
-}
+import path from "path";
+import { Token, parse } from "path-to-regexp";
+
+export namespace PathAnalyzer {
+  export const join = (...args: string[]) =>
+    "/" +
+    _Trim(
+      path
+        .join(...args.filter((s) => !!s.length))
+        .split("\\")
+        .join("/"),
+    );
+
+  export const escape = (str: string): string | null => {
+    const args = _Parse(str);
+    if (args === null) return null;
+    return (
+      "/" +
+      args
+        .map((arg) => (arg.type === "param" ? `:${arg.value}` : arg.value))
+        .join("/")
+    );
+  };
+
+  export const parameters = (str: string): string[] | null => {
+    const args = _Parse(str);
+    if (args === null) return null;
+    return args.filter((arg) => arg.type === "param").map((arg) => arg.value);
+  };
+
+  function _Parse(str: string): IArgument[] | null {
+    const tokens: Token[] | null = (() => {
+      try {
+        return parse(path.join(str).split("\\").join("/"));
+      } catch {
+        return null;
+      }
+    })();
+    if (tokens === null) return null;
+
+    const output: IArgument[] = [];
+    for (const key of tokens) {
+      if (typeof key === "string")
+        output.push({
+          type: "path",
+          value: _Trim(key),
+        });
+      else if (typeof key.name === "number" || _Trim(key.name) === "")
+        return null;
+      else
+        output.push({
+          type: "param",
+          value: _Trim(key.name),
+        });
+    }
+    return output;
+  }
+
+  function _Trim(str: string): string {
+    if (str[0] === "/") str = str.substring(1);
+    if (str[str.length - 1] === "/") str = str.substring(0, str.length - 1);
+    return str;
+  }
+
+  interface IArgument {
+    type: "param" | "path";
+    value: string;
+  }
+}

package/src/analyses/ReflectControllerAnalyzer.ts

@@ -1,105 +1,105 @@
-import {
-  HOST_METADATA,
-  PATH_METADATA,
-  SCOPE_OPTIONS_METADATA,
-} from "@nestjs/common/constants";
-
-import { INestiaProject } from "../structures/INestiaProject";
-import { INestiaSdkInput } from "../structures/INestiaSdkInput";
-import { IReflectController } from "../structures/IReflectController";
-import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
-import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
-import { ArrayUtil } from "../utils/ArrayUtil";
-import { ReflectHttpOperationAnalyzer } from "./ReflectHttpOperationAnalyzer";
-import { ReflectMetadataAnalyzer } from "./ReflectMetadataAnalyzer";
-import { ReflectWebSocketOperationAnalyzer } from "./ReflectWebSocketOperationAnalyzer";
-
-export namespace ReflectControllerAnalyzer {
-  export interface IProps {
-    project: Omit<INestiaProject, "config">;
-    controller: INestiaSdkInput.IController;
-    unique: WeakSet<Function>;
-  }
-  /* ---------------------------------------------------------
-    CONTROLLER
-  --------------------------------------------------------- */
-  export const analyze = (props: IProps): IReflectController | null => {
-    // MUST BE TYPE OF A CREATOR WHO HAS THE CONSTRUCTOR
-    if (
-      ArrayUtil.has(
-        Reflect.getMetadataKeys(props.controller.class),
-        PATH_METADATA,
-        HOST_METADATA,
-        SCOPE_OPTIONS_METADATA,
-      ) === false
-    )
-      return null;
-
-    // BASIC INFO
-    const controller: IReflectController = {
-      class: props.controller.class,
-      file: props.controller.location,
-      operations: [],
-      prefixes: props.controller.prefixes,
-      paths: ReflectMetadataAnalyzer.paths(props.controller.class).filter(
-        (str) => {
-          if (str.includes("*") === true) {
-            props.project.warnings.push({
-              file: props.controller.location,
-              class: props.controller.class.name,
-              function: null,
-              from: null,
-              contents: ["@nestia/sdk does not compose wildcard controller."],
-            });
-            return false;
-          }
-          return true;
-        },
-      ),
-      versions: ReflectMetadataAnalyzer.versions(props.controller.class),
-      security: ReflectMetadataAnalyzer.securities(props.controller.class),
-      tags:
-        Reflect.getMetadata("swagger/apiUseTags", props.controller.class) ?? [],
-    };
-
-    // OPERATORS
-    for (const [key, value] of _Get_prototype_entries(props.controller.class)) {
-      if (typeof value !== "function") continue;
-      const metadata: IOperationMetadata | undefined = Reflect.getMetadata(
-        "nestia/OperationMetadata",
-        props.controller.class.prototype,
-        key,
-      );
-      if (metadata === undefined) continue;
-      else if (metadata.jsDocTags.some((tag) => tag.name === "ignore"))
-        continue;
-      const next: ReflectHttpOperationAnalyzer.IProps = {
-        project: props.project,
-        controller: controller,
-        name: key,
-        function: value,
-        metadata,
-      };
-      const child: IReflectHttpOperation | IReflectWebSocketOperation | null =
-        ReflectWebSocketOperationAnalyzer.analyze(next) ??
-        ReflectHttpOperationAnalyzer.analyze(next);
-      if (child !== null) controller.operations.push(child);
-    }
-    return controller;
-  };
-
-  function _Get_prototype_entries(creator: any): Array<[string, unknown]> {
-    const keyList = Object.getOwnPropertyNames(creator.prototype);
-    const entries: Array<[string, unknown]> = keyList.map((key) => [
-      key,
-      creator.prototype[key],
-    ]);
-
-    const parent = Object.getPrototypeOf(creator);
-    if (parent.prototype !== undefined)
-      entries.push(..._Get_prototype_entries(parent));
-
-    return entries;
-  }
-}
+import {
+  HOST_METADATA,
+  PATH_METADATA,
+  SCOPE_OPTIONS_METADATA,
+} from "@nestjs/common/constants";
+
+import { INestiaProject } from "../structures/INestiaProject";
+import { INestiaSdkInput } from "../structures/INestiaSdkInput";
+import { IReflectController } from "../structures/IReflectController";
+import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
+import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
+import { IOperationMetadata } from "../transformers/IOperationMetadata";
+import { ArrayUtil } from "../utils/ArrayUtil";
+import { ReflectHttpOperationAnalyzer } from "./ReflectHttpOperationAnalyzer";
+import { ReflectMetadataAnalyzer } from "./ReflectMetadataAnalyzer";
+import { ReflectWebSocketOperationAnalyzer } from "./ReflectWebSocketOperationAnalyzer";
+
+export namespace ReflectControllerAnalyzer {
+  export interface IProps {
+    project: Omit<INestiaProject, "config">;
+    controller: INestiaSdkInput.IController;
+    unique: WeakSet<Function>;
+  }
+  /* ---------------------------------------------------------
+    CONTROLLER
+  --------------------------------------------------------- */
+  export const analyze = (props: IProps): IReflectController | null => {
+    // MUST BE TYPE OF A CREATOR WHO HAS THE CONSTRUCTOR
+    if (
+      ArrayUtil.has(
+        Reflect.getMetadataKeys(props.controller.class),
+        PATH_METADATA,
+        HOST_METADATA,
+        SCOPE_OPTIONS_METADATA,
+      ) === false
+    )
+      return null;
+
+    // BASIC INFO
+    const controller: IReflectController = {
+      class: props.controller.class,
+      file: props.controller.location,
+      operations: [],
+      prefixes: props.controller.prefixes,
+      paths: ReflectMetadataAnalyzer.paths(props.controller.class).filter(
+        (str) => {
+          if (str.includes("*") === true) {
+            props.project.warnings.push({
+              file: props.controller.location,
+              class: props.controller.class.name,
+              function: null,
+              from: null,
+              contents: ["@nestia/sdk does not compose wildcard controller."],
+            });
+            return false;
+          }
+          return true;
+        },
+      ),
+      versions: ReflectMetadataAnalyzer.versions(props.controller.class),
+      security: ReflectMetadataAnalyzer.securities(props.controller.class),
+      tags:
+        Reflect.getMetadata("swagger/apiUseTags", props.controller.class) ?? [],
+    };
+
+    // OPERATORS
+    for (const [key, value] of _Get_prototype_entries(props.controller.class)) {
+      if (typeof value !== "function") continue;
+      const metadata: IOperationMetadata | undefined = Reflect.getMetadata(
+        "nestia/OperationMetadata",
+        props.controller.class.prototype,
+        key,
+      );
+      if (metadata === undefined) continue;
+      else if (metadata.jsDocTags.some((tag) => tag.name === "ignore"))
+        continue;
+      const next: ReflectHttpOperationAnalyzer.IProps = {
+        project: props.project,
+        controller: controller,
+        name: key,
+        function: value,
+        metadata,
+      };
+      const child: IReflectHttpOperation | IReflectWebSocketOperation | null =
+        ReflectWebSocketOperationAnalyzer.analyze(next) ??
+        ReflectHttpOperationAnalyzer.analyze(next);
+      if (child !== null) controller.operations.push(child);
+    }
+    return controller;
+  };
+
+  function _Get_prototype_entries(creator: any): Array<[string, unknown]> {
+    const keyList = Object.getOwnPropertyNames(creator.prototype);
+    const entries: Array<[string, unknown]> = keyList.map((key) => [
+      key,
+      creator.prototype[key],
+    ]);
+
+    const parent = Object.getPrototypeOf(creator);
+    if (parent.prototype !== undefined)
+      entries.push(..._Get_prototype_entries(parent));
+
+    return entries;
+  }
+}

package/src/analyses/ReflectMetadataAnalyzer.ts

@@ -1,44 +1,44 @@
-import { VERSION_NEUTRAL } from "@nestjs/common";
-import { PATH_METADATA, VERSION_METADATA } from "@nestjs/common/constants";
-import { VersionValue } from "@nestjs/common/interfaces";
-
-import { SecurityAnalyzer } from "./SecurityAnalyzer";
-
-export namespace ReflectMetadataAnalyzer {
-  export const paths = (target: Function): string[] => {
-    const value: string | string[] = Reflect.getMetadata(PATH_METADATA, target);
-    if (typeof value === "string") return [value];
-    else if (value.length === 0) return [""];
-    else return value;
-  };
-
-  export const extensions = (value: any): Record<string, any> => {
-    const entire: Record<string, any>[] | undefined = Reflect.getMetadata(
-      "swagger/apiExtension",
-      value,
-    );
-    return entire ?? {};
-  };
-
-  export const securities = (value: any): Record<string, string[]>[] => {
-    const entire: Record<string, string[]>[] | undefined = Reflect.getMetadata(
-      "swagger/apiSecurity",
-      value,
-    );
-    return entire ? SecurityAnalyzer.merge(...entire) : [];
-  };
-
-  export const versions = (
-    target: any,
-  ): Array<string | typeof VERSION_NEUTRAL> | undefined => {
-    const value: VersionValue | undefined = Reflect.getMetadata(
-      VERSION_METADATA,
-      target,
-    );
-    return value === undefined
-      ? undefined
-      : Array.isArray(value)
-        ? value
-        : [value];
-  };
-}
+import { VERSION_NEUTRAL } from "@nestjs/common";
+import { PATH_METADATA, VERSION_METADATA } from "@nestjs/common/constants";
+import { VersionValue } from "@nestjs/common/interfaces";
+
+import { SecurityAnalyzer } from "./SecurityAnalyzer";
+
+export namespace ReflectMetadataAnalyzer {
+  export const paths = (target: Function): string[] => {
+    const value: string | string[] = Reflect.getMetadata(PATH_METADATA, target);
+    if (typeof value === "string") return [value];
+    else if (value.length === 0) return [""];
+    else return value;
+  };
+
+  export const extensions = (value: any): Record<string, any> => {
+    const entire: Record<string, any>[] | undefined = Reflect.getMetadata(
+      "swagger/apiExtension",
+      value,
+    );
+    return entire ?? {};
+  };
+
+  export const securities = (value: any): Record<string, string[]>[] => {
+    const entire: Record<string, string[]>[] | undefined = Reflect.getMetadata(
+      "swagger/apiSecurity",
+      value,
+    );
+    return entire ? SecurityAnalyzer.merge(...entire) : [];
+  };
+
+  export const versions = (
+    target: any,
+  ): Array<string | typeof VERSION_NEUTRAL> | undefined => {
+    const value: VersionValue | undefined = Reflect.getMetadata(
+      VERSION_METADATA,
+      target,
+    );
+    return value === undefined
+      ? undefined
+      : Array.isArray(value)
+        ? value
+        : [value];
+  };
+}