@nestia/sdk 4.4.2-dev.20241217 → 4.4.2

package/src/analyses/TypedHttpRouteAnalyzer.ts

@@ -1,186 +1,186 @@
-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,
-      accessors: [...PathUtil.accessors(path), props.operation.name],
-      exceptions,
-      parameters,
-      success,
-      extensions: props.operation.extensions,
-    }));
-  };
-}
-
-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 { 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,
+      accessors: [...PathUtil.accessors(path), props.operation.name],
+      exceptions,
+      parameters,
+      success,
+      extensions: props.operation.extensions,
+    }));
+  };
+}
+
+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)}]`;
+};

package/src/analyses/TypedWebSocketRouteAnalyzer.ts

@@ -1,18 +1,18 @@
-import { IReflectController } from "../structures/IReflectController";
-import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
-import { ITypedWebSocketRoute } from "../structures/ITypedWebSocketRoute";
-import { PathUtil } from "../utils/PathUtil";
-
-export namespace TypedWebSocketRouteAnalyzer {
-  export const analyze = (props: {
-    controller: IReflectController;
-    operation: IReflectWebSocketOperation;
-    paths: string[];
-  }): ITypedWebSocketRoute[] =>
-    props.paths.map((path) => ({
-      ...props.operation,
-      controller: props.controller,
-      path,
-      accessors: [...PathUtil.accessors(path), props.operation.name],
-    }));
-}
+import { IReflectController } from "../structures/IReflectController";
+import { IReflectWebSocketOperation } from "../structures/IReflectWebSocketOperation";
+import { ITypedWebSocketRoute } from "../structures/ITypedWebSocketRoute";
+import { PathUtil } from "../utils/PathUtil";
+
+export namespace TypedWebSocketRouteAnalyzer {
+  export const analyze = (props: {
+    controller: IReflectController;
+    operation: IReflectWebSocketOperation;
+    paths: string[];
+  }): ITypedWebSocketRoute[] =>
+    props.paths.map((path) => ({
+      ...props.operation,
+      controller: props.controller,
+      path,
+      accessors: [...PathUtil.accessors(path), props.operation.name],
+    }));
+}

package/src/decorators/OperationMetadata.ts

@@ -1,15 +1,15 @@
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
-
-export function OperationMetadata(
-  metadata: IOperationMetadata,
-): MethodDecorator {
-  return function OperationMetadata(target, propertyKey, descriptor) {
-    Reflect.defineMetadata(
-      "nestia/OperationMetadata",
-      metadata,
-      target,
-      propertyKey,
-    );
-    return descriptor;
-  };
-}
+import { IOperationMetadata } from "../transformers/IOperationMetadata";
+
+export function OperationMetadata(
+  metadata: IOperationMetadata,
+): MethodDecorator {
+  return function OperationMetadata(target, propertyKey, descriptor) {
+    Reflect.defineMetadata(
+      "nestia/OperationMetadata",
+      metadata,
+      target,
+      propertyKey,
+    );
+    return descriptor;
+  };
+}

package/src/executable/internal/CommandParser.ts

@@ -1,15 +1,15 @@
-export namespace CommandParser {
-  export function parse(argList: string[]): Record<string, string> {
-    const output: Record<string, string> = {};
-    argList.forEach((arg, i) => {
-      if (arg.startsWith("--") === false) return;
-
-      const key = arg.slice(2);
-      const value: string | undefined = argList[i + 1];
-      if (value === undefined || value.startsWith("--")) return;
-
-      output[key] = value;
-    });
-    return output;
-  }
-}
+export namespace CommandParser {
+  export function parse(argList: string[]): Record<string, string> {
+    const output: Record<string, string> = {};
+    argList.forEach((arg, i) => {
+      if (arg.startsWith("--") === false) return;
+
+      const key = arg.slice(2);
+      const value: string | undefined = argList[i + 1];
+      if (value === undefined || value.startsWith("--")) return;
+
+      output[key] = value;
+    });
+    return output;
+  }
+}

package/src/executable/internal/NestiaConfigLoader.ts

@@ -1,78 +1,78 @@
-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/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;
+    }
+  };
+}