@nestia/sdk 2.4.3 → 2.4.4

package/src/generates/internal/SdkTypeDefiner.ts

@@ -1,119 +1,119 @@
-import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
-import { ImportDictionary } from "../../utils/ImportDictionary";
-import { SdkDtoGenerator } from "./SdkDtoGenerator";
-
-export namespace SdkTypeDefiner {
-  export const name =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (p: IRoute.IParameter | IRoute.IOutput): string =>
-      p.metadata
-        ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
-        : p.typeName;
-
-  export const headers =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (param: IRoute.IParameter): string => {
-      const type: string = name(config)(importer)(param);
-      if (config.primitive === false) return type;
-
-      const resolved: string = importer.external({
-        type: true,
-        library: "@nestia/fetcher",
-        instance: "Resolved",
-      });
-      return `${resolved}<${type}>`;
-    };
-
-  export const query =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (param: IRoute.IParameter): string => {
-      const type: string = name(config)(importer)(param);
-      if (config.primitive === false) return type;
-
-      const resolved: string = importer.external({
-        type: true,
-        library: "@nestia/fetcher",
-        instance: "Resolved",
-      });
-      return `${resolved}<${type}>`;
-    };
-
-  export const input =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (param: IRoute.IParameter): string => {
-      const type: string = name(config)(importer)(param);
-      if (config.primitive === false) return type;
-
-      const primitive: string = importer.external({
-        type: true,
-        library: "@nestia/fetcher",
-        instance: "Primitive",
-      });
-      return `${primitive}<${type}>`;
-    };
-
-  export const output =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (route: IRoute): string => {
-      if (config.propagate !== true) {
-        const type: string = name(config)(importer)(route.output);
-        if (type === "void" || config.primitive === false) return type;
-
-        const wrapper: string = importer.external({
-          type: true,
-          library: "@nestia/fetcher",
-          instance:
-            route.output.contentType === "application/x-www-form-urlencoded"
-              ? "Resolved"
-              : "Primitive",
-        });
-        return `${wrapper}<${type}>`;
-      }
-
-      const propagation: string = importer.external({
-        type: true,
-        library: "@nestia/fetcher",
-        instance: "IPropagation",
-      });
-      const branches: IBranch[] = [
-        {
-          status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
-          type: name(config)(importer)(route.output),
-        },
-        ...Object.entries(route.exceptions).map(([status, value]) => ({
-          status,
-          type: name(config)(importer)(value),
-        })),
-      ];
-      return (
-        `${propagation}<{\n` +
-        branches
-          .map(
-            (b) =>
-              `        ${
-                b.status.endsWith("XX") ? `"${b.status}"` : b.status
-              }: ${b.type};`,
-          )
-          .join("\n") +
-        "\n" +
-        `    }${route.status ? `, ${route.status}` : ""}>`
-      );
-    };
-
-  export const responseBody =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (route: IRoute): string =>
-      output({ ...config, propagate: false })(importer)(route);
-}
-
-interface IBranch {
-  status: string;
-  type: string;
-}
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "../../utils/ImportDictionary";
+import { SdkDtoGenerator } from "./SdkDtoGenerator";
+
+export namespace SdkTypeDefiner {
+  export const name =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (p: IRoute.IParameter | IRoute.IOutput): string =>
+      p.metadata
+        ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
+        : p.typeName;
+
+  export const headers =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): string => {
+      const type: string = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+
+      const resolved: string = importer.external({
+        type: true,
+        library: "@nestia/fetcher",
+        instance: "Resolved",
+      });
+      return `${resolved}<${type}>`;
+    };
+
+  export const query =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): string => {
+      const type: string = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+
+      const resolved: string = importer.external({
+        type: true,
+        library: "@nestia/fetcher",
+        instance: "Resolved",
+      });
+      return `${resolved}<${type}>`;
+    };
+
+  export const input =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): string => {
+      const type: string = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+
+      const primitive: string = importer.external({
+        type: true,
+        library: "@nestia/fetcher",
+        instance: "Primitive",
+      });
+      return `${primitive}<${type}>`;
+    };
+
+  export const output =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): string => {
+      if (config.propagate !== true) {
+        const type: string = name(config)(importer)(route.output);
+        if (type === "void" || config.primitive === false) return type;
+
+        const wrapper: string = importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance:
+            route.output.contentType === "application/x-www-form-urlencoded"
+              ? "Resolved"
+              : "Primitive",
+        });
+        return `${wrapper}<${type}>`;
+      }
+
+      const propagation: string = importer.external({
+        type: true,
+        library: "@nestia/fetcher",
+        instance: "IPropagation",
+      });
+      const branches: IBranch[] = [
+        {
+          status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
+          type: name(config)(importer)(route.output),
+        },
+        ...Object.entries(route.exceptions).map(([status, value]) => ({
+          status,
+          type: name(config)(importer)(value),
+        })),
+      ];
+      return (
+        `${propagation}<{\n` +
+        branches
+          .map(
+            (b) =>
+              `        ${
+                b.status.endsWith("XX") ? `"${b.status}"` : b.status
+              }: ${b.type};`,
+          )
+          .join("\n") +
+        "\n" +
+        `    }${route.status ? `, ${route.status}` : ""}>`
+      );
+    };
+
+  export const responseBody =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): string =>
+      output({ ...config, propagate: false })(importer)(route);
+}
+
+interface IBranch {
+  status: string;
+  type: string;
+}

package/src/generates/internal/SwaggerSchemaGenerator.ts

@@ -151,7 +151,15 @@ export namespace SwaggerSchemaGenerator {
                   schema: coalesce(props)(result),
                 },
               },
-        "x-nestia-encrypted": route.encrypted,
+        ...(props.config.additional === true
+          ? {
+              "x-nestia-encrypted": route.encrypted,
+            }
+          : route.encrypted === true
+          ? {
+              "x-nestia-encrypted": true,
+            }
+          : {}),
       };
       return output;
     };
@@ -206,7 +214,15 @@ export namespace SwaggerSchemaGenerator {
           },
         },
         required: true,
-        "x-nestia-encrypted": encrypted,
+        ...(props.config.additional === true
+          ? {
+              "x-nestia-encrypted": encrypted,
+            }
+          : encrypted === true
+          ? {
+              "x-nestia-encrypted": true,
+            }
+          : {}),
       };
     };
 

package/src/generates/internal/SwaggerSchemaValidator.ts

@@ -1,198 +1,198 @@
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { MetadataArray } from "typia/lib/schemas/metadata/MetadataArray";
-
-export namespace SwaggerSchemaValidator {
-  export const path = (meta: Metadata): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (meta.any) insert("do not allow any type");
-    if (meta.isRequired() === false) insert("do not allow undefindable type");
-
-    const atomics = CoreMetadataUtil.atomics(meta);
-    const expected: number =
-      meta.atomics.length +
-      meta.templates.length +
-      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-    if (meta.size() !== expected || atomics.size === 0)
-      insert("only atomic or constant types are allowed");
-    if (atomics.size > 1) insert("do not allow union type");
-
-    return errors;
-  };
-
-  export const query = (
-    meta: Metadata,
-    explore: MetadataFactory.IExplore,
-  ): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (explore.top === true) {
-      // TOP MUST BE ONLY OBJECT
-      if (meta.objects.length !== 1 || meta.bucket() !== 1)
-        insert("only one object type is allowed.");
-      if (meta.nullable === true) insert("query parameters cannot be null.");
-      if (meta.isRequired() === false)
-        insert("query parameters cannot be undefined.");
-    } else if (
-      explore.nested !== null &&
-      explore.nested instanceof MetadataArray
-    ) {
-      const atomics = CoreMetadataUtil.atomics(meta);
-      const expected: number =
-        meta.atomics.length +
-        meta.templates.length +
-        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-      if (atomics.size > 1) insert("union type is not allowed in array.");
-      if (meta.nullable) insert("nullable type is not allowed in array.");
-      if (meta.isRequired() === false)
-        insert("optional type is not allowed in array.");
-      if (meta.size() !== expected)
-        insert("only atomic or constant types are allowed in array.");
-    } else if (explore.object && explore.property !== null) {
-      //----
-      // COMMON
-      //----
-      // PROPERTY MUST BE SOLE
-      if (typeof explore.property === "object")
-        insert("dynamic property is not allowed.");
-      // DO NOT ALLOW TUPLE TYPE
-      if (meta.tuples.length) insert("tuple type is not allowed.");
-      // DO NOT ALLOW UNION TYPE
-      if (CoreMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
-      // DO NOT ALLOW NESTED OBJECT
-      if (
-        meta.objects.length ||
-        meta.sets.length ||
-        meta.maps.length ||
-        meta.natives.length
-      )
-        insert("nested object type is not allowed.");
-
-      //----
-      // ARRAY CASES
-      //----
-      const isArray: boolean = meta.arrays.length > 1 || meta.tuples.length > 1;
-      // ARRAY TYPE MUST BE REQUIRED
-      if (isArray && meta.isRequired() === false)
-        insert("optional type is not allowed when array.");
-      // SET-COOKIE MUST BE ARRAY
-      if (explore.property === "set-cookie" && !isArray)
-        insert("set-cookie property must be array.");
-    }
-    return errors;
-  };
-
-  export const headers = (
-    meta: Metadata,
-    explore: MetadataFactory.IExplore,
-  ): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (explore.top === true) {
-      // TOP MUST BE ONLY OBJECT
-      if (meta.objects.length !== 1 || meta.bucket() !== 1)
-        insert("only one object type is allowed.");
-      if (meta.nullable === true) insert("headers cannot be null.");
-      if (meta.isRequired() === false) insert("headers cannot be null.");
-    } else if (
-      explore.nested !== null &&
-      explore.nested instanceof MetadataArray
-    ) {
-      const atomics = CoreMetadataUtil.atomics(meta);
-      const expected: number =
-        meta.atomics.length +
-        meta.templates.length +
-        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
-      if (atomics.size > 1) insert("union type is not allowed in array.");
-      if (meta.nullable) insert("nullable type is not allowed in array.");
-      if (meta.isRequired() === false) insert("optional type is not allowed.");
-      if (meta.size() !== expected)
-        insert("only atomic or constant types are allowed in array.");
-    } else if (explore.object && explore.property !== null) {
-      //----
-      // COMMON
-      //----
-      // PROPERTY MUST BE SOLE
-      if (typeof explore.property === "object")
-        insert("dynamic property is not allowed.");
-      // DO NOT ALLOW TUPLE TYPE
-      if (meta.tuples.length) insert("tuple type is not allowed.");
-      // DO NOT ALLOW UNION TYPE
-      if (CoreMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
-      // DO NOT ALLOW NESTED OBJECT
-      if (
-        meta.objects.length ||
-        meta.sets.length ||
-        meta.maps.length ||
-        meta.natives.length
-      )
-        insert("nested object type is not allowed.");
-      // DO NOT ALLOW NULLABLE
-      if (meta.nullable) insert("nullable type is not allowed.");
-
-      //----
-      // ARRAY CASES
-      //----
-      const isArray: boolean = meta.arrays.length > 1;
-      // ARRAY TYPE MUST BE REQUIRED
-      if (isArray && meta.isRequired() === false)
-        insert("optional type is not allowed when array.");
-      // SET-COOKIE MUST BE ARRAY
-      if (explore.property === "set-cookie" && !isArray)
-        insert("set-cookie property must be array.");
-      // MUST BE SINGULAR CASE
-      if (
-        typeof explore.property === "string" &&
-        SINGULAR.has(explore.property) &&
-        isArray
-      )
-        insert("property cannot be array.");
-    }
-    return errors;
-  };
-}
-
-namespace CoreMetadataUtil {
-  export const atomics = (
-    meta: Metadata,
-  ): Set<"boolean" | "bigint" | "number" | "string"> =>
-    new Set([
-      ...meta.atomics.map((a) => a.type),
-      ...meta.constants.map((c) => c.type),
-      ...(meta.templates.length ? (["string"] as const) : []),
-    ]);
-
-  export const isUnion = (meta: Metadata): boolean =>
-    atomics(meta).size +
-      meta.arrays.length +
-      meta.tuples.length +
-      meta.natives.length +
-      meta.maps.length +
-      meta.objects.length >
-    1;
-}
-
-const SINGULAR: Set<string> = new Set([
-  "age",
-  "authorization",
-  "content-length",
-  "content-type",
-  "etag",
-  "expires",
-  "from",
-  "host",
-  "if-modified-since",
-  "if-unmodified-since",
-  "last-modified",
-  "location",
-  "max-forwards",
-  "proxy-authorization",
-  "referer",
-  "retry-after",
-  "server",
-  "user-agent",
-]);
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataArray } from "typia/lib/schemas/metadata/MetadataArray";
+
+export namespace SwaggerSchemaValidator {
+  export const path = (meta: Metadata): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (meta.any) insert("do not allow any type");
+    if (meta.isRequired() === false) insert("do not allow undefindable type");
+
+    const atomics = CoreMetadataUtil.atomics(meta);
+    const expected: number =
+      meta.atomics.length +
+      meta.templates.length +
+      meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+    if (meta.size() !== expected || atomics.size === 0)
+      insert("only atomic or constant types are allowed");
+    if (atomics.size > 1) insert("do not allow union type");
+
+    return errors;
+  };
+
+  export const query = (
+    meta: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (explore.top === true) {
+      // TOP MUST BE ONLY OBJECT
+      if (meta.objects.length !== 1 || meta.bucket() !== 1)
+        insert("only one object type is allowed.");
+      if (meta.nullable === true) insert("query parameters cannot be null.");
+      if (meta.isRequired() === false)
+        insert("query parameters cannot be undefined.");
+    } else if (
+      explore.nested !== null &&
+      explore.nested instanceof MetadataArray
+    ) {
+      const atomics = CoreMetadataUtil.atomics(meta);
+      const expected: number =
+        meta.atomics.length +
+        meta.templates.length +
+        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+      if (atomics.size > 1) insert("union type is not allowed in array.");
+      if (meta.nullable) insert("nullable type is not allowed in array.");
+      if (meta.isRequired() === false)
+        insert("optional type is not allowed in array.");
+      if (meta.size() !== expected)
+        insert("only atomic or constant types are allowed in array.");
+    } else if (explore.object && explore.property !== null) {
+      //----
+      // COMMON
+      //----
+      // PROPERTY MUST BE SOLE
+      if (typeof explore.property === "object")
+        insert("dynamic property is not allowed.");
+      // DO NOT ALLOW TUPLE TYPE
+      if (meta.tuples.length) insert("tuple type is not allowed.");
+      // DO NOT ALLOW UNION TYPE
+      if (CoreMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
+      // DO NOT ALLOW NESTED OBJECT
+      if (
+        meta.objects.length ||
+        meta.sets.length ||
+        meta.maps.length ||
+        meta.natives.length
+      )
+        insert("nested object type is not allowed.");
+
+      //----
+      // ARRAY CASES
+      //----
+      const isArray: boolean = meta.arrays.length > 1 || meta.tuples.length > 1;
+      // ARRAY TYPE MUST BE REQUIRED
+      if (isArray && meta.isRequired() === false)
+        insert("optional type is not allowed when array.");
+      // SET-COOKIE MUST BE ARRAY
+      if (explore.property === "set-cookie" && !isArray)
+        insert("set-cookie property must be array.");
+    }
+    return errors;
+  };
+
+  export const headers = (
+    meta: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (explore.top === true) {
+      // TOP MUST BE ONLY OBJECT
+      if (meta.objects.length !== 1 || meta.bucket() !== 1)
+        insert("only one object type is allowed.");
+      if (meta.nullable === true) insert("headers cannot be null.");
+      if (meta.isRequired() === false) insert("headers cannot be null.");
+    } else if (
+      explore.nested !== null &&
+      explore.nested instanceof MetadataArray
+    ) {
+      const atomics = CoreMetadataUtil.atomics(meta);
+      const expected: number =
+        meta.atomics.length +
+        meta.templates.length +
+        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+      if (atomics.size > 1) insert("union type is not allowed in array.");
+      if (meta.nullable) insert("nullable type is not allowed in array.");
+      if (meta.isRequired() === false) insert("optional type is not allowed.");
+      if (meta.size() !== expected)
+        insert("only atomic or constant types are allowed in array.");
+    } else if (explore.object && explore.property !== null) {
+      //----
+      // COMMON
+      //----
+      // PROPERTY MUST BE SOLE
+      if (typeof explore.property === "object")
+        insert("dynamic property is not allowed.");
+      // DO NOT ALLOW TUPLE TYPE
+      if (meta.tuples.length) insert("tuple type is not allowed.");
+      // DO NOT ALLOW UNION TYPE
+      if (CoreMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
+      // DO NOT ALLOW NESTED OBJECT
+      if (
+        meta.objects.length ||
+        meta.sets.length ||
+        meta.maps.length ||
+        meta.natives.length
+      )
+        insert("nested object type is not allowed.");
+      // DO NOT ALLOW NULLABLE
+      if (meta.nullable) insert("nullable type is not allowed.");
+
+      //----
+      // ARRAY CASES
+      //----
+      const isArray: boolean = meta.arrays.length > 1;
+      // ARRAY TYPE MUST BE REQUIRED
+      if (isArray && meta.isRequired() === false)
+        insert("optional type is not allowed when array.");
+      // SET-COOKIE MUST BE ARRAY
+      if (explore.property === "set-cookie" && !isArray)
+        insert("set-cookie property must be array.");
+      // MUST BE SINGULAR CASE
+      if (
+        typeof explore.property === "string" &&
+        SINGULAR.has(explore.property) &&
+        isArray
+      )
+        insert("property cannot be array.");
+    }
+    return errors;
+  };
+}
+
+namespace CoreMetadataUtil {
+  export const atomics = (
+    meta: Metadata,
+  ): Set<"boolean" | "bigint" | "number" | "string"> =>
+    new Set([
+      ...meta.atomics.map((a) => a.type),
+      ...meta.constants.map((c) => c.type),
+      ...(meta.templates.length ? (["string"] as const) : []),
+    ]);
+
+  export const isUnion = (meta: Metadata): boolean =>
+    atomics(meta).size +
+      meta.arrays.length +
+      meta.tuples.length +
+      meta.natives.length +
+      meta.maps.length +
+      meta.objects.length >
+    1;
+}
+
+const SINGULAR: Set<string> = new Set([
+  "age",
+  "authorization",
+  "content-length",
+  "content-type",
+  "etag",
+  "expires",
+  "from",
+  "host",
+  "if-modified-since",
+  "if-unmodified-since",
+  "last-modified",
+  "location",
+  "max-forwards",
+  "proxy-authorization",
+  "referer",
+  "retry-after",
+  "server",
+  "user-agent",
+]);