@nestia/sdk 11.0.0-dev.20260316 → 11.0.1

package/src/analyses/ReflectHttpOperationResponseAnalyzer.ts

@@ -1,126 +1,126 @@
-import { SwaggerExample } from "@nestia/core";
-import {
-  HEADERS_METADATA,
-  HTTP_CODE_METADATA,
-  INTERCEPTORS_METADATA,
-} from "@nestjs/common/constants";
-import { HttpQueryProgrammer, JsonMetadataFactory } from "@typia/core";
-import typia from "typia";
-
-import { IReflectController } from "../structures/IReflectController";
-import { IReflectHttpOperationSuccess } from "../structures/IReflectHttpOperationSuccess";
-import { IReflectOperationError } from "../structures/IReflectOperationError";
-import { IOperationMetadata } from "../transformers/IOperationMetadata";
-import { TextPlainValidator } from "../transformers/TextPlainValidator";
-
-export namespace ReflectHttpOperationResponseAnalyzer {
-  export interface IContext {
-    controller: IReflectController;
-    function: Function;
-    functionName: string;
-    httpMethod: string;
-    metadata: IOperationMetadata;
-    errors: IReflectOperationError[];
-  }
-
-  export const analyze = (
-    ctx: IContext,
-  ): IReflectHttpOperationSuccess | null => {
-    const errors: Array<string | IOperationMetadata.IError> = [];
-    const report = () => {
-      ctx.errors.push({
-        file: ctx.controller.file,
-        class: ctx.controller.class.name,
-        function: ctx.functionName,
-        from: "return",
-        contents: errors,
-      });
-      return null;
-    };
-
-    const encrypted: boolean = hasInterceptor({
-      name: "EncryptedRouteInterceptor",
-      function: ctx.function,
-    });
-    const contentType: string | null = encrypted
-      ? "text/plain"
-      : hasInterceptor({
-            name: "TypedQueryRouteInterceptor",
-            function: ctx.function,
-          })
-        ? "application/x-www-form-urlencoded"
-        : (Reflect.getMetadata(HEADERS_METADATA, ctx.function)?.find(
-            (h: Record<string, string>) =>
-              typeof h?.name === "string" &&
-              typeof h?.value === "string" &&
-              h.name.toLowerCase() === "content-type",
-          )?.value ??
-          Reflect.getMetadata("swagger/apiProduces", ctx.function)?.[0] ??
-          (ctx.httpMethod === "HEAD" ? null : "application/json"));
-
-    const schema =
-      contentType === "application/json"
-        ? ctx.metadata.success.primitive
-        : ctx.metadata.success.resolved;
-    if (schema.success === false) errors.push(...schema.errors);
-    if (ctx.httpMethod === "HEAD" && contentType !== null)
-      errors.push(`HEAD method must not have a content type.`);
-    if (
-      typia.is<IReflectHttpOperationSuccess["contentType"]>(contentType) ===
-      false
-    )
-      errors.push(
-        `@nestia/sdk does not support ${JSON.stringify(contentType)} content type.`,
-      );
-
-    if (errors.length) return report();
-    else if (
-      ctx.metadata.success.type === null ||
-      schema.success === false ||
-      !typia.is<IReflectHttpOperationSuccess["contentType"]>(contentType)
-    )
-      return null;
-
-    const example: SwaggerExample.IData<any> | undefined = Reflect.getMetadata(
-      "nestia/SwaggerExample/Response",
-      ctx.function,
-    );
-    return {
-      contentType,
-      encrypted,
-      status:
-        getStatus(ctx.function) ?? (ctx.httpMethod === "POST" ? 201 : 200),
-      type: ctx.metadata.success.type,
-      ...schema.data,
-      validate:
-        contentType === "application/json" || encrypted === true
-          ? JsonMetadataFactory.validate
-          : contentType === "application/x-www-form-urlencoded"
-            ? HttpQueryProgrammer.validate
-            : contentType === "text/plain"
-              ? TextPlainValidator.validate
-              : (next) =>
-                  next.metadata.size() !== 0
-                    ? ["HEAD method must not have any return value."]
-                    : [],
-      example: example?.example,
-      examples: example?.examples,
-    };
-  };
-
-  const getStatus = (func: Function): number | null => {
-    const text = Reflect.getMetadata(HTTP_CODE_METADATA, func);
-    if (text === undefined) return null;
-    const value: number = Number(text);
-    return isNaN(value) ? null : value;
-  };
-
-  const hasInterceptor = (props: {
-    name: string;
-    function: Function;
-  }): boolean => {
-    const meta = Reflect.getMetadata(INTERCEPTORS_METADATA, props.function);
-    if (Array.isArray(meta) === false) return false;
-    return meta.some((elem) => elem?.constructor?.name === props.name);
-  };
-}
+import { SwaggerExample } from "@nestia/core";
+import {
+  HEADERS_METADATA,
+  HTTP_CODE_METADATA,
+  INTERCEPTORS_METADATA,
+} from "@nestjs/common/constants";
+import { HttpQueryProgrammer, JsonMetadataFactory } from "@typia/core";
+import typia from "typia";
+
+import { IReflectController } from "../structures/IReflectController";
+import { IReflectHttpOperationSuccess } from "../structures/IReflectHttpOperationSuccess";
+import { IReflectOperationError } from "../structures/IReflectOperationError";
+import { IOperationMetadata } from "../transformers/IOperationMetadata";
+import { TextPlainValidator } from "../transformers/TextPlainValidator";
+
+export namespace ReflectHttpOperationResponseAnalyzer {
+  export interface IContext {
+    controller: IReflectController;
+    function: Function;
+    functionName: string;
+    httpMethod: string;
+    metadata: IOperationMetadata;
+    errors: IReflectOperationError[];
+  }
+
+  export const analyze = (
+    ctx: IContext,
+  ): IReflectHttpOperationSuccess | null => {
+    const errors: Array<string | IOperationMetadata.IError> = [];
+    const report = () => {
+      ctx.errors.push({
+        file: ctx.controller.file,
+        class: ctx.controller.class.name,
+        function: ctx.functionName,
+        from: "return",
+        contents: errors,
+      });
+      return null;
+    };
+
+    const encrypted: boolean = hasInterceptor({
+      name: "EncryptedRouteInterceptor",
+      function: ctx.function,
+    });
+    const contentType: string | null = encrypted
+      ? "text/plain"
+      : hasInterceptor({
+            name: "TypedQueryRouteInterceptor",
+            function: ctx.function,
+          })
+        ? "application/x-www-form-urlencoded"
+        : (Reflect.getMetadata(HEADERS_METADATA, ctx.function)?.find(
+            (h: Record<string, string>) =>
+              typeof h?.name === "string" &&
+              typeof h?.value === "string" &&
+              h.name.toLowerCase() === "content-type",
+          )?.value ??
+          Reflect.getMetadata("swagger/apiProduces", ctx.function)?.[0] ??
+          (ctx.httpMethod === "HEAD" ? null : "application/json"));
+
+    const schema =
+      contentType === "application/json"
+        ? ctx.metadata.success.primitive
+        : ctx.metadata.success.resolved;
+    if (schema.success === false) errors.push(...schema.errors);
+    if (ctx.httpMethod === "HEAD" && contentType !== null)
+      errors.push(`HEAD method must not have a content type.`);
+    if (
+      typia.is<IReflectHttpOperationSuccess["contentType"]>(contentType) ===
+      false
+    )
+      errors.push(
+        `@nestia/sdk does not support ${JSON.stringify(contentType)} content type.`,
+      );
+
+    if (errors.length) return report();
+    else if (
+      ctx.metadata.success.type === null ||
+      schema.success === false ||
+      !typia.is<IReflectHttpOperationSuccess["contentType"]>(contentType)
+    )
+      return null;
+
+    const example: SwaggerExample.IData<any> | undefined = Reflect.getMetadata(
+      "nestia/SwaggerExample/Response",
+      ctx.function,
+    );
+    return {
+      contentType,
+      encrypted,
+      status:
+        getStatus(ctx.function) ?? (ctx.httpMethod === "POST" ? 201 : 200),
+      type: ctx.metadata.success.type,
+      ...schema.data,
+      validate:
+        contentType === "application/json" || encrypted === true
+          ? JsonMetadataFactory.validate
+          : contentType === "application/x-www-form-urlencoded"
+            ? HttpQueryProgrammer.validate
+            : contentType === "text/plain"
+              ? TextPlainValidator.validate
+              : (next) =>
+                  next.metadata.size() !== 0
+                    ? ["HEAD method must not have any return value."]
+                    : [],
+      example: example?.example,
+      examples: example?.examples,
+    };
+  };
+
+  const getStatus = (func: Function): number | null => {
+    const text = Reflect.getMetadata(HTTP_CODE_METADATA, func);
+    if (text === undefined) return null;
+    const value: number = Number(text);
+    return isNaN(value) ? null : value;
+  };
+
+  const hasInterceptor = (props: {
+    name: string;
+    function: Function;
+  }): boolean => {
+    const meta = Reflect.getMetadata(INTERCEPTORS_METADATA, props.function);
+    if (Array.isArray(meta) === false) return false;
+    return meta.some((elem) => elem?.constructor?.name === props.name);
+  };
+}

package/src/analyses/TypedHttpRouteAnalyzer.ts

@@ -1,208 +1,208 @@
-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)}]`;
-};
+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)}]`;
+};