@nestia/sdk 2.0.0-dev.20230831-5 → 2.0.0-dev.20230901-2

package/src/generates/internal/SwaggerSchemaValidator.ts

@@ -0,0 +1,216 @@
+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.");
+            // MUST BE LOWER-CASE
+            if (
+                typeof explore.property === "string" &&
+                explore.property !== explore.property.toLowerCase()
+            )
+                insert("property name must be lower-case.");
+            // 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/structures/IController.ts

@@ -67,10 +67,6 @@ export namespace IController {
         index: number;
         name: string;
         field: string | undefined;
-        meta?: {
-            type: string;
-            nullable: boolean;
-        };
     }
 
     export interface IException {

package/src/structures/IRoute.ts

@@ -1,7 +1,6 @@
 import ts from "typescript";
 
 import { IController } from "./IController";
-import { ITypeTuple } from "./ITypeTuple";
 
 export interface IRoute {
     name: string;
@@ -18,6 +17,7 @@ export interface IRoute {
     location: string;
     symbol: string;
     description?: string;
+    operationId?: string;
     tags: ts.JSDocTagInfo[];
     setHeaders: Array<
         | { type: "setter"; source: string; target?: string }
@@ -30,9 +30,12 @@ export interface IRoute {
 export namespace IRoute {
     export type IParameter = IController.IParameter & {
         optional: boolean;
-        type: ITypeTuple;
+        type: ts.Type;
+        typeName: string;
     };
-    export interface IOutput extends ITypeTuple {
+    export interface IOutput {
+        type: ts.Type;
+        typeName: string;
         description?: string;
         contentType: "application/json" | "text/plain";
     }

package/src/structures/ISwaggerError.ts

@@ -0,0 +1,8 @@
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+
+import { IRoute } from "./IRoute";
+
+export interface ISwaggerError extends MetadataFactory.IError {
+    route: IRoute;
+    from: string;
+}

package/src/structures/ISwaggerRoute.ts

@@ -1,9 +1,10 @@
 import { IJsonSchema } from "typia";
-import { IJsDocTagInfo } from "typia/lib/metadata/IJsDocTagInfo";
+import { IJsDocTagInfo } from "typia/lib/schemas/metadata/IJsDocTagInfo";
 
 export interface ISwaggerRoute {
     deprecated?: boolean;
     security?: Record<string, string[]>[];
+    operationId?: string;
     tags: string[];
     parameters: ISwaggerRoute.IParameter[];
     requestBody?: ISwaggerRoute.IRequestBody;

package/src/structures/ISwaggerSchemaTuple.ts

@@ -0,0 +1,7 @@
+import { IJsonSchema } from "typia";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+export interface ISwaggerSchemaTuple {
+    metadata: Metadata;
+    schema: IJsonSchema;
+}

package/src/structures/ITypeTuple.ts

@@ -2,5 +2,5 @@ import ts from "typescript";
 
 export interface ITypeTuple {
     type: ts.Type;
-    name: string;
+    typeName: string;
 }

package/src/utils/ImportDictionary.ts

@@ -4,20 +4,18 @@ import { HashSet } from "tstl/container/HashSet";
 import { Pair } from "tstl/utility/Pair";
 
 export class ImportDictionary {
-    private readonly externals_: HashMap<Pair<string, boolean>, IComposition> =
-        new HashMap();
-    private readonly internals_: HashMap<Pair<string, boolean>, IComposition> =
+    private readonly components_: HashMap<Pair<string, boolean>, IComposition> =
         new HashMap();
 
     public empty(): boolean {
-        return this.internals_.empty() && this.externals_.empty();
+        return this.components_.empty();
     }
 
     public external(props: ImportDictionary.IExternalProps): string {
-        const composition: IComposition = this.externals_.take(
+        const composition: IComposition = this.components_.take(
             new Pair(props.library, props.type),
             () => ({
-                location: props.library,
+                location: `node_modules/${props.library}`,
                 elements: new HashSet(),
                 default: false,
                 type: props.type,
@@ -36,7 +34,7 @@ export class ImportDictionary {
                 return props.file.substring(0, props.file.length - 3);
             return props.file;
         })();
-        const composition: IComposition = this.internals_.take(
+        const composition: IComposition = this.components_.take(
             new Pair(file, props.type),
             () => ({
                 location: file,
@@ -53,12 +51,26 @@ export class ImportDictionary {
     }
 
     public toScript(outDir: string): string {
-        const statements: string[] = [];
+        const external: string[] = [];
+        const internal: string[] = [];
+
+        const locator = (str: string) => {
+            const location: string = path
+                .relative(outDir, str)
+                .split("\\")
+                .join("/");
+            const index: number = location.lastIndexOf(NODE_MODULES);
+            return index === -1
+                ? location.startsWith("..")
+                    ? location
+                    : `./${location}`
+                : location.substring(index + NODE_MODULES.length);
+        };
         const enroll =
-            (locator: (str: string) => string) =>
-            (dict: HashMap<Pair<string, boolean>, IComposition>) => {
-                const compositions: IComposition[] = dict
+            (filter: (str: string) => boolean) => (container: string[]) => {
+                const compositions: IComposition[] = this.components_
                     .toJSON()
+                    .filter((c) => filter(c.second.location))
                     .map((e) => ({
                         ...e.second,
                         location: locator(e.second.location),
@@ -74,7 +86,7 @@ export class ImportDictionary {
                                 .sort((a, b) => a.localeCompare(b))
                                 .join(", ")} }`,
                         );
-                    statements.push(
+                    container.push(
                         `import ${c.type ? "type " : ""}${brackets.join(
                             ", ",
                         )} from "${c.location}";`,
@@ -82,20 +94,11 @@ export class ImportDictionary {
                 }
             };
 
-        enroll((str) => str)(this.externals_);
-        if (!this.externals_.empty() && !this.internals_.empty())
-            statements.push("");
-        enroll((str) => {
-            const location: string = path
-                .relative(outDir, str)
-                .split("\\")
-                .join("/");
-            const index: number = location.lastIndexOf(NODE_MODULES);
-            return index === -1
-                ? `./${location}`
-                : location.substring(index + NODE_MODULES.length);
-        })(this.internals_);
-        return statements.join("\n");
+        enroll((str) => str.indexOf(NODE_MODULES) !== -1)(external);
+        enroll((str) => str.indexOf(NODE_MODULES) === -1)(internal);
+
+        if (external.length && internal.length) external.push("");
+        return [...external, ...internal].join("\n");
     }
 }
 export namespace ImportDictionary {