@nestia/sdk 2.4.2 → 2.4.3

package/src/generates/internal/SwaggerSchemaValidator.ts

@@ -1,210 +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",
+]);

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as nestia from "./module";
-
-export * from "./module";
-export default nestia;
+import * as nestia from "./module";
+
+export * from "./module";
+export default nestia;

package/src/module.ts

@@ -1,2 +1,2 @@
-export * from "./INestiaConfig";
-export * from "./NestiaSdkApplication";
+export * from "./INestiaConfig";
+export * from "./NestiaSdkApplication";

package/src/structures/IController.ts

@@ -3,91 +3,89 @@ import type { VERSION_NEUTRAL, VersionValue } from "@nestjs/common/interfaces";
 import type { ParamCategory } from "./ParamCategory";
 
 export interface IController {
-    file: string;
+  file: string;
+  name: string;
+  prefixes: string[];
+  paths: string[];
+  versions:
+    | Array<Exclude<VersionValue, Array<string | typeof VERSION_NEUTRAL>>>
+    | undefined;
+  functions: IController.IFunction[];
+  security: Record<string, string[]>[];
+  swaggerTgas: string[];
+}
+
+export namespace IController {
+  export interface IFunction {
     name: string;
-    prefixes: string[];
+    method: string;
     paths: string[];
     versions:
-        | Array<Exclude<VersionValue, Array<string | typeof VERSION_NEUTRAL>>>
-        | undefined;
-    functions: IController.IFunction[];
+      | Array<Exclude<VersionValue, Array<string | typeof VERSION_NEUTRAL>>>
+      | undefined;
+    encrypted: boolean;
+    parameters: IParameter[];
+    status?: number;
+    type?: string;
+    contentType: "application/json" | "text/plain";
     security: Record<string, string[]>[];
-    swaggerTgas: string[];
-}
-
-export namespace IController {
-    export interface IFunction {
-        name: string;
-        method: string;
-        paths: string[];
-        versions:
-            | Array<
-                  Exclude<VersionValue, Array<string | typeof VERSION_NEUTRAL>>
-              >
-            | undefined;
-        encrypted: boolean;
-        parameters: IParameter[];
-        status?: number;
-        type?: string;
-        contentType: "application/json" | "text/plain";
-        security: Record<string, string[]>[];
-        exceptions: Record<
-            number | "2XX" | "3XX" | "4XX" | "5XX",
-            IController.IException
-        >;
-        swaggerTags: string[];
-    }
+    exceptions: Record<
+      number | "2XX" | "3XX" | "4XX" | "5XX",
+      IController.IException
+    >;
+    swaggerTags: string[];
+  }
 
-    export type IParameter =
-        | ICommonParameter
-        | IQueryParameter
-        | IHeadersParameter
-        | IBodyParameter
-        | IPathParameter;
-    export interface ICommonParameter {
-        custom: false;
-        category: ParamCategory;
-        index: number;
-        name: string;
-        field: string | undefined;
-    }
-    export interface IHeadersParameter {
-        custom: true;
-        category: "headers";
-        index: number;
-        name: string;
-        field: string | undefined;
-    }
-    export interface IQueryParameter {
-        custom: true;
-        category: "query";
-        index: number;
-        name: string;
-        field: string | undefined;
-    }
-    export interface IBodyParameter {
-        custom: true;
-        category: "body";
-        index: number;
-        name: string;
-        field: string | undefined;
-        encrypted: boolean;
-        contentType:
-            | "application/json"
-            | "application/x-www-form-urlencoded"
-            | "text/plain";
-    }
-    export interface IPathParameter {
-        custom: true;
-        category: "param";
-        index: number;
-        name: string;
-        field: string | undefined;
-    }
+  export type IParameter =
+    | ICommonParameter
+    | IQueryParameter
+    | IHeadersParameter
+    | IBodyParameter
+    | IPathParameter;
+  export interface ICommonParameter {
+    custom: false;
+    category: ParamCategory;
+    index: number;
+    name: string;
+    field: string | undefined;
+  }
+  export interface IHeadersParameter {
+    custom: true;
+    category: "headers";
+    index: number;
+    name: string;
+    field: string | undefined;
+  }
+  export interface IQueryParameter {
+    custom: true;
+    category: "query";
+    index: number;
+    name: string;
+    field: string | undefined;
+  }
+  export interface IBodyParameter {
+    custom: true;
+    category: "body";
+    index: number;
+    name: string;
+    field: string | undefined;
+    encrypted: boolean;
+    contentType:
+      | "application/json"
+      | "application/x-www-form-urlencoded"
+      | "text/plain";
+  }
+  export interface IPathParameter {
+    custom: true;
+    category: "param";
+    index: number;
+    name: string;
+    field: string | undefined;
+  }
 
-    export interface IException {
-        type: string;
-        status: number | "2XX" | "3XX" | "4XX" | "5XX";
-        description: string | undefined;
-    }
+  export interface IException {
+    type: string;
+    status: number | "2XX" | "3XX" | "4XX" | "5XX";
+    description: string | undefined;
+  }
 }

package/src/structures/IErrorReport.ts

@@ -1,6 +1,6 @@
-export interface IErrorReport {
-    file: string;
-    controller: string;
-    function: string | null;
-    message: string;
-}
+export interface IErrorReport {
+  file: string;
+  controller: string;
+  function: string | null;
+  message: string;
+}

package/src/structures/INestiaProject.ts

@@ -1,13 +1,13 @@
-import ts from "typescript";
-
-import { INestiaConfig } from "../INestiaConfig";
-import { IErrorReport } from "./IErrorReport";
-import { INormalizedInput } from "./INormalizedInput";
-
-export interface INestiaProject {
-    config: INestiaConfig;
-    input: INormalizedInput;
-    checker: ts.TypeChecker;
-    errors: IErrorReport[];
-    warnings: IErrorReport[];
-}
+import ts from "typescript";
+
+import { INestiaConfig } from "../INestiaConfig";
+import { IErrorReport } from "./IErrorReport";
+import { INormalizedInput } from "./INormalizedInput";
+
+export interface INestiaProject {
+  config: INestiaConfig;
+  input: INormalizedInput;
+  checker: ts.TypeChecker;
+  errors: IErrorReport[];
+  warnings: IErrorReport[];
+}