@nestia/sdk 10.0.2 → 11.0.0-dev.20260312

package/src/analyses/TypedHttpRouteAnalyzer.ts

@@ -1,204 +1,208 @@
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { IMetadata } from "typia/lib/schemas/metadata/IMetadata";
-import { IMetadataComponents } from "typia/lib/schemas/metadata/IMetadataComponents";
-import { IMetadataDictionary } from "typia/lib/schemas/metadata/IMetadataDictionary";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { MetadataComponents } from "typia/lib/schemas/metadata/MetadataComponents";
-import { MetadataObjectType } from "typia/lib/schemas/metadata/MetadataObjectType";
-import { Escaper } from "typia/lib/utils/Escaper";
-
-import { IReflectController } from "../structures/IReflectController";
-import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
-import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
-import { ITypedHttpRouteException } from "../structures/ITypedHttpRouteException";
-import { ITypedHttpRouteParameter } from "../structures/ITypedHttpRouteParameter";
-import { ITypedHttpRouteSuccess } from "../structures/ITypedHttpRouteSuccess";
-import { PathUtil } from "../utils/PathUtil";
-
-export namespace TypedHttpRouteAnalyzer {
-  export const dictionary = (
-    controllers: IReflectController[],
-  ): IMetadataDictionary => {
-    const individual: IMetadataComponents[] = [];
-    for (const c of controllers)
-      for (const o of c.operations) {
-        if (o.protocol !== "http") continue;
-        if (o.success) individual.push(o.success.components);
-        for (const p of o.parameters) individual.push(p.components);
-        for (const e of Object.values(o.exceptions))
-          individual.push(e.components);
-      }
-    const components: MetadataComponents = MetadataComponents.from({
-      objects: Object.values(
-        Object.fromEntries(
-          individual.map((c) => c.objects.map((o) => [o.name, o])).flat(),
-        ),
-      ),
-      arrays: Object.values(
-        Object.fromEntries(
-          individual.map((c) => c.arrays.map((a) => [a.name, a])).flat(),
-        ),
-      ),
-      tuples: Object.values(
-        Object.fromEntries(
-          individual.map((c) => c.tuples.map((t) => [t.name, t])).flat(),
-        ),
-      ),
-      aliases: Object.values(
-        Object.fromEntries(
-          individual.map((c) => c.aliases.map((a) => [a.name, a])).flat(),
-        ),
-      ),
-    });
-    return components.dictionary;
-  };
-
-  export const analyze = (props: {
-    controller: IReflectController;
-    errors: IReflectOperationError[];
-    dictionary: IMetadataDictionary;
-    operation: IReflectHttpOperation;
-    paths: string[];
-  }): ITypedHttpRoute[] => {
-    const errors: IReflectOperationError[] = [];
-    const cast = (
-      next: {
-        metadata: IMetadata;
-        validate: MetadataFactory.Validator;
-      },
-      from: string,
-      escape: boolean,
-    ): Metadata => {
-      const metadata: Metadata = Metadata.from(next.metadata, props.dictionary);
-      const metaErrors: MetadataFactory.IError[] = MetadataFactory.validate({
-        options: {
-          escape,
-          constant: true,
-          absorb: true,
-          validate: next.validate, // @todo -> CHECK IN TYPIA
-        },
-        functor: next.validate, // @todo -> CHECK IN TYPIA
-        metadata,
-      });
-      if (metaErrors.length)
-        errors.push({
-          file: props.controller.file,
-          class: props.controller.class.name,
-          function: props.operation.name,
-          from,
-          contents: metaErrors.map((e) => ({
-            name: e.name,
-            accessor:
-              e.explore.object !== null
-                ? join({
-                    object: e.explore.object,
-                    key: e.explore.property,
-                  })
-                : null,
-            messages: e.messages,
-          })),
-        });
-      return metadata;
-    };
-    const exceptions: Record<
-      number | "2XX" | "3XX" | "4XX" | "5XX",
-      ITypedHttpRouteException
-    > = Object.fromEntries(
-      Object.entries(props.operation.exceptions).map(([key, value]) => [
-        key as any,
-        {
-          status: value.status,
-          description: value.description,
-          example: value.example,
-          examples: value.examples,
-          type: value.type,
-          metadata: cast(value, `exception (status: ${key})`, true),
-        },
-      ]),
-    );
-    const parameters: ITypedHttpRouteParameter[] =
-      props.operation.parameters.map((p) => ({
-        ...p,
-        metadata: cast(
-          p,
-          `parameter (name: ${JSON.stringify(p.name)})`,
-          p.category === "body" &&
-            (p.contentType === "application/json" || p.encrypted === true),
-        ),
-      }));
-    const success: ITypedHttpRouteSuccess = {
-      ...props.operation.success,
-      metadata: cast(
-        props.operation.success,
-        "success",
-        props.operation.success.encrypted ||
-          props.operation.success.contentType === "application/json",
-      ),
-      setHeaders: props.operation.jsDocTags
-        .filter(
-          (t) =>
-            t.text?.length &&
-            t.text[0].text &&
-            (t.name === "setHeader" || t.name === "assignHeaders"),
-        )
-        .map((t) =>
-          t.name === "setHeader"
-            ? {
-                type: "setter",
-                source: t.text![0].text.split(" ")[0].trim(),
-                target: t.text![0].text.split(" ")[1]?.trim(),
-              }
-            : {
-                type: "assigner",
-                source: t.text![0].text,
-              },
-        ),
-    };
-    if (errors.length) {
-      props.errors.push(...errors);
-      return [];
-    }
-    return props.paths.map(
-      (path) =>
-        ({
-          ...props.operation,
-          controller: props.controller,
-          path,
-          accessor: [...PathUtil.accessors(path), props.operation.name],
-          exceptions,
-          pathParameters: parameters.filter((p) => p.category === "param"),
-          queryParameters: parameters
-            .filter((p) => p.category === "query")
-            .filter((p) => p.field !== null),
-          headerParameters: parameters
-            .filter((p) => p.category === "headers")
-            .filter((p) => p.field !== null),
-          queryObject:
-            parameters
-              .filter((p) => p.category === "query")
-              .filter((p) => p.field === null)[0] ?? null,
-          body: parameters.filter((p) => p.category === "body")[0] ?? null,
-          headerObject:
-            parameters
-              .filter((p) => p.category === "headers")
-              .filter((p) => p.field === null)[0] ?? null,
-          success,
-          extensions: props.operation.extensions,
-        }) satisfies ITypedHttpRoute,
-    );
-  };
-}
-
-const join = ({
-  object,
-  key,
-}: {
-  object: MetadataObjectType;
-  key: string | object | null;
-}) => {
-  if (key === null) return object.name;
-  else if (typeof key === "object") return `${object.name}[key]`;
-  else if (Escaper.variable(key)) return `${object.name}.${key}`;
-  return `${object.name}[${JSON.stringify(key)}]`;
-};
+import {
+  IMetadataDictionary,
+  MetadataComponents,
+  MetadataFactory,
+  MetadataObjectType,
+  MetadataSchema,
+} from "@typia/core";
+import { NamingConvention } from "@typia/utils";
+import { IMetadataComponents, IMetadataSchema } from "typia";
+
+import { IReflectController } from "../structures/IReflectController";
+import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
+import { IReflectOperationError } from "../structures/IReflectOperationError";
+import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
+import { ITypedHttpRouteException } from "../structures/ITypedHttpRouteException";
+import { ITypedHttpRouteParameter } from "../structures/ITypedHttpRouteParameter";
+import { ITypedHttpRouteSuccess } from "../structures/ITypedHttpRouteSuccess";
+import { PathUtil } from "../utils/PathUtil";
+
+export namespace TypedHttpRouteAnalyzer {
+  export const dictionary = (
+    controllers: IReflectController[],
+  ): IMetadataDictionary => {
+    const individual: IMetadataComponents[] = [];
+    for (const c of controllers)
+      for (const o of c.operations) {
+        if (o.protocol !== "http") continue;
+        if (o.success) individual.push(o.success.components);
+        for (const p of o.parameters) individual.push(p.components);
+        for (const e of Object.values(o.exceptions))
+          individual.push(e.components);
+      }
+    const components: MetadataComponents = MetadataComponents.from({
+      objects: Object.values(
+        Object.fromEntries(
+          individual.map((c) => c.objects.map((o) => [o.name, o])).flat(),
+        ),
+      ),
+      arrays: Object.values(
+        Object.fromEntries(
+          individual.map((c) => c.arrays.map((a) => [a.name, a])).flat(),
+        ),
+      ),
+      tuples: Object.values(
+        Object.fromEntries(
+          individual.map((c) => c.tuples.map((t) => [t.name, t])).flat(),
+        ),
+      ),
+      aliases: Object.values(
+        Object.fromEntries(
+          individual.map((c) => c.aliases.map((a) => [a.name, a])).flat(),
+        ),
+      ),
+    });
+    return components.dictionary;
+  };
+
+  export const analyze = (props: {
+    controller: IReflectController;
+    errors: IReflectOperationError[];
+    dictionary: IMetadataDictionary;
+    operation: IReflectHttpOperation;
+    paths: string[];
+  }): ITypedHttpRoute[] => {
+    const errors: IReflectOperationError[] = [];
+    const cast = (
+      next: {
+        metadata: IMetadataSchema;
+        validate: MetadataFactory.Validator;
+      },
+      from: string,
+      escape: boolean,
+    ): MetadataSchema => {
+      const metadata: MetadataSchema = MetadataSchema.from(
+        next.metadata,
+        props.dictionary,
+      );
+      const metaErrors: MetadataFactory.IError[] = MetadataFactory.validate({
+        options: {
+          escape,
+          constant: true,
+          absorb: true,
+          validate: next.validate, // @todo -> CHECK IN TYPIA
+        },
+        functor: next.validate, // @todo -> CHECK IN TYPIA
+        metadata,
+      });
+      if (metaErrors.length)
+        errors.push({
+          file: props.controller.file,
+          class: props.controller.class.name,
+          function: props.operation.name,
+          from,
+          contents: metaErrors.map((e) => ({
+            name: e.name,
+            accessor:
+              e.explore.object !== null
+                ? join({
+                    object: e.explore.object,
+                    key: e.explore.property,
+                  })
+                : null,
+            messages: e.messages,
+          })),
+        });
+      return metadata;
+    };
+    const exceptions: Record<
+      number | "2XX" | "3XX" | "4XX" | "5XX",
+      ITypedHttpRouteException
+    > = Object.fromEntries(
+      Object.entries(props.operation.exceptions).map(([key, value]) => [
+        key as any,
+        {
+          status: value.status,
+          description: value.description,
+          example: value.example,
+          examples: value.examples,
+          type: value.type,
+          metadata: cast(value, `exception (status: ${key})`, true),
+        },
+      ]),
+    );
+    const parameters: ITypedHttpRouteParameter[] =
+      props.operation.parameters.map((p) => ({
+        ...p,
+        metadata: cast(
+          p,
+          `parameter (name: ${JSON.stringify(p.name)})`,
+          p.category === "body" &&
+            (p.contentType === "application/json" || p.encrypted === true),
+        ),
+      }));
+    const success: ITypedHttpRouteSuccess = {
+      ...props.operation.success,
+      metadata: cast(
+        props.operation.success,
+        "success",
+        props.operation.success.encrypted ||
+          props.operation.success.contentType === "application/json",
+      ),
+      setHeaders: props.operation.jsDocTags
+        .filter(
+          (t) =>
+            t.text?.length &&
+            t.text[0]!.text &&
+            (t.name === "setHeader" || t.name === "assignHeaders"),
+        )
+        .map((t) =>
+          t.name === "setHeader"
+            ? {
+                type: "setter",
+                source: t.text![0]!.text.split(" ")[0]!.trim(),
+                target: t.text![0]!.text.split(" ")[1]?.trim(),
+              }
+            : {
+                type: "assigner",
+                source: t.text![0]!.text,
+              },
+        ),
+    };
+    if (errors.length) {
+      props.errors.push(...errors);
+      return [];
+    }
+    return props.paths.map(
+      (path) =>
+        ({
+          ...props.operation,
+          controller: props.controller,
+          path,
+          accessor: [...PathUtil.accessors(path), props.operation.name],
+          exceptions,
+          pathParameters: parameters.filter((p) => p.category === "param"),
+          queryParameters: parameters
+            .filter((p) => p.category === "query")
+            .filter((p) => p.field !== null),
+          headerParameters: parameters
+            .filter((p) => p.category === "headers")
+            .filter((p) => p.field !== null),
+          queryObject:
+            parameters
+              .filter((p) => p.category === "query")
+              .filter((p) => p.field === null)[0] ?? null,
+          body: parameters.filter((p) => p.category === "body")[0] ?? null,
+          headerObject:
+            parameters
+              .filter((p) => p.category === "headers")
+              .filter((p) => p.field === null)[0] ?? null,
+          success,
+          extensions: props.operation.extensions,
+        }) satisfies ITypedHttpRoute,
+    );
+  };
+}
+
+const join = ({
+  object,
+  key,
+}: {
+  object: MetadataObjectType;
+  key: string | object | null;
+}) => {
+  if (key === null) return object.name;
+  else if (typeof key === "object") return `${object.name}[key]`;
+  else if (NamingConvention.variable(key)) return `${object.name}.${key}`;
+  return `${object.name}[${JSON.stringify(key)}]`;
+};

package/src/executable/internal/NestiaConfigLoader.ts

@@ -1,78 +1,85 @@
-import { NoTransformConfigurationError } from "@nestia/core/lib/decorators/NoTransformConfigurationError";
-import fs from "fs";
-import path from "path";
-import { register } from "ts-node";
-import { parse } from "tsconfck";
-import ts from "typescript";
-import typia from "typia";
-
-import { INestiaConfig } from "../../INestiaConfig";
-
-export namespace NestiaConfigLoader {
-  export const compilerOptions = async (
-    project: string,
-  ): Promise<ts.ParsedCommandLine> => {
-    const configFileName = ts.findConfigFile(
-      process.cwd(),
-      ts.sys.fileExists,
-      project,
-    );
-    if (!configFileName) throw new Error(`unable to find "${project}" file.`);
-    const { tsconfig } = await parse(configFileName);
-    const configFileText = JSON.stringify(tsconfig);
-    const { config } = ts.parseConfigFileTextToJson(
-      configFileName,
-      configFileText,
-    );
-    return ts.parseJsonConfigFileContent(
-      config,
-      ts.sys,
-      path.dirname(configFileName),
-    );
-  };
-
-  export const configurations = async (
-    file: string,
-    compilerOptions: Record<string, any>,
-  ): Promise<INestiaConfig[]> => {
-    if (fs.existsSync(path.resolve(file)) === false)
-      throw new Error(`Unable to find "${file}" file.`);
-
-    NoTransformConfigurationError.throws = false;
-    const plugins: any[] = [
-      ...typia
-        .assert<object[]>(compilerOptions.plugins ?? [])
-        .filter((x: any) => x.transform !== "@nestia/sdk/lib/transform"),
-      { transform: "@nestia/sdk/lib/transform" },
-    ];
-    register({
-      emit: false,
-      compilerOptions: {
-        ...compilerOptions,
-        plugins,
-      },
-      require: compilerOptions.baseUrl
-        ? ["tsconfig-paths/register"]
-        : undefined,
-    });
-
-    const loaded: (INestiaConfig | INestiaConfig[]) & {
-      default?: INestiaConfig | INestiaConfig[];
-    } = await import(path.resolve(file));
-    const instance: INestiaConfig | INestiaConfig[] =
-      typeof loaded?.default === "object" && loaded.default !== null
-        ? loaded.default
-        : loaded;
-    const configurations: INestiaConfig[] = Array.isArray(instance)
-      ? instance
-      : [instance];
-
-    try {
-      return typia.assert(configurations);
-    } catch (exp) {
-      if (typia.is<typia.TypeGuardError>(exp))
-        exp.message = `invalid "${file}" data.`;
-      throw exp;
-    }
-  };
-}
+import { NoTransformConfigurationError } from "@nestia/core";
+import fs from "fs";
+import path from "path";
+import { register } from "ts-node";
+import { parse } from "tsconfck";
+import ts from "typescript";
+import typia from "typia";
+
+import { INestiaConfig } from "../../INestiaConfig";
+
+export namespace NestiaConfigLoader {
+  export const compilerOptions = async (
+    project: string,
+  ): Promise<ts.ParsedCommandLine> => {
+    const configFileName = ts.findConfigFile(
+      process.cwd(),
+      ts.sys.fileExists,
+      project,
+    );
+    if (!configFileName) throw new Error(`unable to find "${project}" file.`);
+    const { tsconfig } = await parse(configFileName);
+    const configFileText = JSON.stringify(tsconfig);
+    const { config } = ts.parseConfigFileTextToJson(
+      configFileName,
+      configFileText,
+    );
+    return ts.parseJsonConfigFileContent(
+      config,
+      ts.sys,
+      path.dirname(configFileName),
+    );
+  };
+
+  export const configurations = async (
+    file: string,
+    compilerOptions: Record<string, any>,
+  ): Promise<INestiaConfig[]> => {
+    if (fs.existsSync(path.resolve(file)) === false)
+      throw new Error(`Unable to find "${file}" file.`);
+
+    NoTransformConfigurationError.throws = false;
+
+    const setup: boolean = typia
+      .assert<object[]>(compilerOptions.plugins ?? [])
+      .some(
+        (x: any) =>
+          x.transform === "@nestia/sdk/lib/transform" ||
+          x.transform === "@nestia/sdk/src/transform.ts",
+      );
+    const plugins: any[] = [
+      ...(compilerOptions.plugins ?? []),
+      ...(setup ? [{ transform: "@nestia/sdk/lib/transform" }] : []),
+    ];
+    if (!(process as any)[Symbol.for("ts-node.register.instance")])
+      register({
+        emit: false,
+        compilerOptions: {
+          ...compilerOptions,
+          plugins,
+        },
+        require: compilerOptions.baseUrl
+          ? ["tsconfig-paths/register"]
+          : undefined,
+      });
+
+    const loaded: (INestiaConfig | INestiaConfig[]) & {
+      default?: INestiaConfig | INestiaConfig[];
+    } = await import(path.resolve(file));
+    const instance: INestiaConfig | INestiaConfig[] =
+      typeof loaded?.default === "object" && loaded.default !== null
+        ? loaded.default
+        : loaded;
+    const configurations: INestiaConfig[] = Array.isArray(instance)
+      ? instance
+      : [instance];
+
+    try {
+      return typia.assert(configurations);
+    } catch (exp) {
+      if (typia.is<typia.TypeGuardError>(exp))
+        exp.message = `invalid "${file}" data.`;
+      throw exp;
+    }
+  };
+}