@nestia/sdk 7.0.3 → 7.1.1-dev.20250714

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/ReflectHttpOperationAnalyzer.ts

@@ -1,183 +1,183 @@
-import { METHOD_METADATA, PATH_METADATA } from "@nestjs/common/constants";
-import { ranges } from "tstl";
-
-import { INestiaProject } from "../structures/INestiaProject";
-import { IReflectController } from "../structures/IReflectController";
-import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
-import { IReflectHttpOperationParameter } from "../structures/IReflectHttpOperationParameter";
-import { IReflectHttpOperationSuccess } from "../structures/IReflectHttpOperationSuccess";
-import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
-import { ArrayUtil } from "../utils/ArrayUtil";
-import { ImportAnalyzer } from "./ImportAnalyzer";
-import { PathAnalyzer } from "./PathAnalyzer";
-import { ReflectHttpOperationExceptionAnalyzer } from "./ReflectHttpOperationExceptionAnalyzer";
-import { ReflectHttpOperationParameterAnalyzer } from "./ReflectHttpOperationParameterAnalyzer";
-import { ReflectHttpOperationResponseAnalyzer } from "./ReflectHttpOperationResponseAnalyzer";
-import { ReflectMetadataAnalyzer } from "./ReflectMetadataAnalyzer";
-
-export namespace ReflectHttpOperationAnalyzer {
-  export interface IProps {
-    project: Omit<INestiaProject, "config">;
-    controller: IReflectController;
-    function: Function;
-    name: string;
-    metadata: IOperationMetadata;
-  }
-  export const analyze = (props: IProps): IReflectHttpOperation | null => {
-    if (
-      ArrayUtil.has(
-        Reflect.getMetadataKeys(props.function),
-        PATH_METADATA,
-        METHOD_METADATA,
-      ) === false
-    )
-      return null;
-
-    const errors: IReflectOperationError[] = [];
-    const method: string =
-      METHODS[Reflect.getMetadata(METHOD_METADATA, props.function)];
-    if (method === undefined || method === "OPTIONS") return null;
-
-    const parameters: IReflectHttpOperationParameter[] =
-      ReflectHttpOperationParameterAnalyzer.analyze({
-        controller: props.controller,
-        metadata: props.metadata,
-        httpMethod: method,
-        function: props.function,
-        functionName: props.name,
-        errors,
-      });
-    const success: IReflectHttpOperationSuccess | null = (() => {
-      const localErrors: IReflectOperationError[] = [];
-      const success = ReflectHttpOperationResponseAnalyzer.analyze({
-        controller: props.controller,
-        function: props.function,
-        functionName: props.name,
-        httpMethod: method,
-        metadata: props.metadata,
-        errors,
-      });
-      if (localErrors.length) {
-        errors.push(...localErrors);
-        return null;
-      }
-      return success;
-    })();
-    if (errors.length) {
-      props.project.errors.push(...errors);
-      return null;
-    } else if (success === null) return null;
-
-    // DO CONSTRUCT
-    const operation: IReflectHttpOperation = {
-      protocol: "http",
-      function: props.function,
-      name: props.name,
-      method: method === "ALL" ? "POST" : method,
-      paths: ReflectMetadataAnalyzer.paths(props.function).filter((str) => {
-        if (str.includes("*") === true) {
-          props.project.warnings.push({
-            file: props.controller.file,
-            class: props.controller.class.name,
-            function: props.name,
-            from: "",
-            contents: ["@nestia/sdk does not compose wildcard method."],
-          });
-          return false;
-        }
-        return true;
-      }),
-      versions: ReflectMetadataAnalyzer.versions(props.function),
-      parameters,
-      success,
-      security: ReflectMetadataAnalyzer.securities(props.function),
-      exceptions: ReflectHttpOperationExceptionAnalyzer.analyze({
-        controller: props.controller,
-        function: props.function,
-        functionName: props.name,
-        httpMethod: method,
-        metadata: props.metadata,
-        errors,
-      }),
-      tags: Reflect.getMetadata("swagger/apiUseTags", props.function) ?? [],
-      imports: ImportAnalyzer.unique(
-        [
-          ...props.metadata.parameters
-            .filter((x) => parameters.some((y) => x.index === y.index))
-            .map((x) => x.imports),
-          ...props.metadata.success.imports,
-          ...Object.values(props.metadata.exceptions).map((e) => e.imports),
-        ].flat(),
-      ),
-      description: props.metadata.description,
-      jsDocTags: props.metadata.jsDocTags,
-      operationId: props.metadata.jsDocTags
-        .find(({ name }) => name === "operationId")
-        ?.text?.[0].text.split(" ")[0]
-        .trim(),
-      extensions: ReflectMetadataAnalyzer.extensions(props.function),
-    };
-
-    // VALIDATE PATH ARGUMENTS
-    for (const controllerLocation of props.controller.paths)
-      for (const metaLocation of operation.paths) {
-        // NORMALIZE LOCATION
-        const location: string = PathAnalyzer.join(
-          controllerLocation,
-          metaLocation,
-        );
-        if (location.includes("*")) continue;
-
-        // LIST UP PARAMETERS
-        const binded: string[] | null = PathAnalyzer.parameters(location);
-        if (binded === null) {
-          props.project.errors.push({
-            file: props.controller.file,
-            class: props.controller.class.name,
-            function: props.name,
-            from: "{parameters}",
-            contents: [`invalid path (${JSON.stringify(location)})`],
-          });
-          continue;
-        }
-        const parameters: string[] = operation.parameters
-          .filter((param) => param.category === "param")
-          .map((param) => param.field!)
-          .sort();
-
-        // DO VALIDATE
-        if (ranges.equal(binded.sort(), parameters) === false)
-          errors.push({
-            file: props.controller.file,
-            class: props.controller.class.name,
-            function: props.name,
-            from: "{parameters}",
-            contents: [
-              `binded arguments in the "path" between function's decorator and parameters' decorators are different (function: [${binded.join(
-                ", ",
-              )}], parameters: [${parameters.join(", ")}]).`,
-            ],
-          });
-      }
-
-    // RETURNS
-    if (errors.length) {
-      props.project.errors.push(...errors);
-      return null;
-    }
-    return operation;
-  };
-}
-
-// node_modules/@nestjs/common/lib/enums/request-method.enum.ts
-const METHODS = [
-  "GET",
-  "POST",
-  "PUT",
-  "DELETE",
-  "PATCH",
-  "ALL",
-  "OPTIONS",
-  "HEAD",
-];
+import { METHOD_METADATA, PATH_METADATA } from "@nestjs/common/constants";
+import { ranges } from "tstl";
+
+import { INestiaProject } from "../structures/INestiaProject";
+import { IReflectController } from "../structures/IReflectController";
+import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
+import { IReflectHttpOperationParameter } from "../structures/IReflectHttpOperationParameter";
+import { IReflectHttpOperationSuccess } from "../structures/IReflectHttpOperationSuccess";
+import { IReflectOperationError } from "../structures/IReflectOperationError";
+import { IOperationMetadata } from "../transformers/IOperationMetadata";
+import { ArrayUtil } from "../utils/ArrayUtil";
+import { ImportAnalyzer } from "./ImportAnalyzer";
+import { PathAnalyzer } from "./PathAnalyzer";
+import { ReflectHttpOperationExceptionAnalyzer } from "./ReflectHttpOperationExceptionAnalyzer";
+import { ReflectHttpOperationParameterAnalyzer } from "./ReflectHttpOperationParameterAnalyzer";
+import { ReflectHttpOperationResponseAnalyzer } from "./ReflectHttpOperationResponseAnalyzer";
+import { ReflectMetadataAnalyzer } from "./ReflectMetadataAnalyzer";
+
+export namespace ReflectHttpOperationAnalyzer {
+  export interface IProps {
+    project: Omit<INestiaProject, "config">;
+    controller: IReflectController;
+    function: Function;
+    name: string;
+    metadata: IOperationMetadata;
+  }
+  export const analyze = (props: IProps): IReflectHttpOperation | null => {
+    if (
+      ArrayUtil.has(
+        Reflect.getMetadataKeys(props.function),
+        PATH_METADATA,
+        METHOD_METADATA,
+      ) === false
+    )
+      return null;
+
+    const errors: IReflectOperationError[] = [];
+    const method: string =
+      METHODS[Reflect.getMetadata(METHOD_METADATA, props.function)];
+    if (method === undefined || method === "OPTIONS") return null;
+
+    const parameters: IReflectHttpOperationParameter[] =
+      ReflectHttpOperationParameterAnalyzer.analyze({
+        controller: props.controller,
+        metadata: props.metadata,
+        httpMethod: method,
+        function: props.function,
+        functionName: props.name,
+        errors,
+      });
+    const success: IReflectHttpOperationSuccess | null = (() => {
+      const localErrors: IReflectOperationError[] = [];
+      const success = ReflectHttpOperationResponseAnalyzer.analyze({
+        controller: props.controller,
+        function: props.function,
+        functionName: props.name,
+        httpMethod: method,
+        metadata: props.metadata,
+        errors,
+      });
+      if (localErrors.length) {
+        errors.push(...localErrors);
+        return null;
+      }
+      return success;
+    })();
+    if (errors.length) {
+      props.project.errors.push(...errors);
+      return null;
+    } else if (success === null) return null;
+
+    // DO CONSTRUCT
+    const operation: IReflectHttpOperation = {
+      protocol: "http",
+      function: props.function,
+      name: props.name,
+      method: method === "ALL" ? "POST" : method,
+      paths: ReflectMetadataAnalyzer.paths(props.function).filter((str) => {
+        if (str.includes("*") === true) {
+          props.project.warnings.push({
+            file: props.controller.file,
+            class: props.controller.class.name,
+            function: props.name,
+            from: "",
+            contents: ["@nestia/sdk does not compose wildcard method."],
+          });
+          return false;
+        }
+        return true;
+      }),
+      versions: ReflectMetadataAnalyzer.versions(props.function),
+      parameters,
+      success,
+      security: ReflectMetadataAnalyzer.securities(props.function),
+      exceptions: ReflectHttpOperationExceptionAnalyzer.analyze({
+        controller: props.controller,
+        function: props.function,
+        functionName: props.name,
+        httpMethod: method,
+        metadata: props.metadata,
+        errors,
+      }),
+      tags: Reflect.getMetadata("swagger/apiUseTags", props.function) ?? [],
+      imports: ImportAnalyzer.unique(
+        [
+          ...props.metadata.parameters
+            .filter((x) => parameters.some((y) => x.index === y.index))
+            .map((x) => x.imports),
+          ...props.metadata.success.imports,
+          ...Object.values(props.metadata.exceptions).map((e) => e.imports),
+        ].flat(),
+      ),
+      description: props.metadata.description,
+      jsDocTags: props.metadata.jsDocTags,
+      operationId: props.metadata.jsDocTags
+        .find(({ name }) => name === "operationId")
+        ?.text?.[0].text.split(" ")[0]
+        .trim(),
+      extensions: ReflectMetadataAnalyzer.extensions(props.function),
+    };
+
+    // VALIDATE PATH ARGUMENTS
+    for (const controllerLocation of props.controller.paths)
+      for (const metaLocation of operation.paths) {
+        // NORMALIZE LOCATION
+        const location: string = PathAnalyzer.join(
+          controllerLocation,
+          metaLocation,
+        );
+        if (location.includes("*")) continue;
+
+        // LIST UP PARAMETERS
+        const binded: string[] | null = PathAnalyzer.parameters(location);
+        if (binded === null) {
+          props.project.errors.push({
+            file: props.controller.file,
+            class: props.controller.class.name,
+            function: props.name,
+            from: "{parameters}",
+            contents: [`invalid path (${JSON.stringify(location)})`],
+          });
+          continue;
+        }
+        const parameters: string[] = operation.parameters
+          .filter((param) => param.category === "param")
+          .map((param) => param.field!)
+          .sort();
+
+        // DO VALIDATE
+        if (ranges.equal(binded.sort(), parameters) === false)
+          errors.push({
+            file: props.controller.file,
+            class: props.controller.class.name,
+            function: props.name,
+            from: "{parameters}",
+            contents: [
+              `binded arguments in the "path" between function's decorator and parameters' decorators are different (function: [${binded.join(
+                ", ",
+              )}], parameters: [${parameters.join(", ")}]).`,
+            ],
+          });
+      }
+
+    // RETURNS
+    if (errors.length) {
+      props.project.errors.push(...errors);
+      return null;
+    }
+    return operation;
+  };
+}
+
+// node_modules/@nestjs/common/lib/enums/request-method.enum.ts
+const METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "ALL",
+  "OPTIONS",
+  "HEAD",
+];