@nestia/sdk 1.3.2 → 1.3.4

package/src/structures/IRoute.ts

@@ -1,39 +1,39 @@
-import ts from "typescript";
-
-import { ITypeTuple } from "./ITypeTuple";
-import { ParamCategory } from "./ParamCategory";
-
-export interface IRoute {
-    name: string;
-    method: string;
-    path: string;
-    encrypted: boolean;
-    status?: number;
-
-    parameters: IRoute.IParameter[];
-    imports: [string, string[]][];
-    output: ITypeTuple;
-
-    symbol: string;
-    description?: string;
-    tags: ts.JSDocTagInfo[];
-    setHeaders: Array<
-        | { type: "setter"; source: string; target?: string }
-        | { type: "assigner"; source: string }
-    >;
-}
-
-export namespace IRoute {
-    export interface IParameter {
-        name: string;
-        field: string | undefined;
-        category: ParamCategory;
-        encrypted: boolean;
-        type: ITypeTuple;
-        optional: boolean;
-        meta?: {
-            type: string;
-            nullable: boolean;
-        };
-    }
-}
+import ts from "typescript";
+
+import { ITypeTuple } from "./ITypeTuple";
+import { ParamCategory } from "./ParamCategory";
+
+export interface IRoute {
+    name: string;
+    method: string;
+    path: string;
+    encrypted: boolean;
+    status?: number;
+
+    parameters: IRoute.IParameter[];
+    imports: [string, string[]][];
+    output: ITypeTuple;
+
+    symbol: string;
+    description?: string;
+    tags: ts.JSDocTagInfo[];
+    setHeaders: Array<
+        | { type: "setter"; source: string; target?: string }
+        | { type: "assigner"; source: string }
+    >;
+}
+
+export namespace IRoute {
+    export interface IParameter {
+        name: string;
+        field: string | undefined;
+        category: ParamCategory;
+        encrypted: boolean;
+        type: ITypeTuple;
+        optional: boolean;
+        meta?: {
+            type: string;
+            nullable: boolean;
+        };
+    }
+}

package/src/structures/ISwaggerDocument.ts

@@ -1,120 +1,120 @@
-import { IJsonComponents, IJsonSchema } from "typia";
-import { IJsDocTagInfo } from "typia/lib/metadata/IJsDocTagInfo";
-
-export interface ISwaggerDocument {
-    openapi: "3.0.1";
-    servers: ISwaggerDocument.IServer[];
-    info: ISwaggerDocument.IInfo;
-    components: ISwaggerDocument.IComponents;
-    security?: Record<string, string[]>[];
-    paths: Record<string, ISwaggerDocument.IPath>;
-}
-export namespace ISwaggerDocument {
-    export interface IServer {
-        url: string;
-        description?: string;
-    }
-
-    export interface IInfo {
-        version: string;
-        title: string;
-        description?: string;
-    }
-
-    export interface IComponents extends IJsonComponents {
-        securitySchemes?: Record<string, ISecurityScheme>;
-    }
-
-    /* ---------------------------------------------------------
-        SECURITY SCHEMES
-    --------------------------------------------------------- */
-    export type ISecurityScheme =
-        | ISecurityScheme.IHttpBasic
-        | ISecurityScheme.IHttpBearer
-        | ISecurityScheme.IApiKey
-        | ISecurityScheme.IOpenId
-        | ISecurityScheme.IOAuth2;
-    export namespace ISecurityScheme {
-        export interface IHttpBasic {
-            type: "http";
-            schema: "basic";
-        }
-        export interface IHttpBearer {
-            type: "http";
-            scheme: "bearer";
-            bearerFormat?: string;
-        }
-        export interface IApiKey {
-            type: "apiKey";
-            in: "header" | "query" | "cookie";
-            name: string;
-        }
-
-        export interface IOpenId {
-            type: "openIdConnect";
-            openIdConnectUrl: string;
-        }
-
-        export interface IOAuth2 {
-            type: "oauth2";
-            flows: IOAuth2.IFlowSet;
-            description?: string;
-        }
-        export namespace IOAuth2 {
-            export interface IFlowSet {
-                authorizationCode?: IFlow;
-                implicit?: Omit<IFlow, "tokenUrl">;
-                password?: Omit<IFlow, "authorizationUrl">;
-                clientCredentials?: Omit<IFlow, "authorizationUrl">;
-            }
-            export interface IFlow {
-                authorizationUrl: string;
-                tokenUrl: string;
-                refreshUrl: string;
-                scopes?: Record<string, string>;
-            }
-        }
-    }
-
-    /* ---------------------------------------------------------
-        ROUTE FUNCTIONS
-    --------------------------------------------------------- */
-    export type IPath = Record<string, IRoute>;
-    export interface IRoute {
-        tags: string[];
-        parameters: IParameter[];
-        requestBody?: IRequestBody;
-        responses: IResponseBody;
-        summary?: string;
-        description?: string;
-        "x-nestia-namespace": string;
-        "x-nestia-jsDocTags": IJsDocTagInfo[];
-    }
-
-    export interface IParameter {
-        name: string;
-        in: string;
-        schema: IJsonSchema;
-        required: boolean;
-        description: string;
-    }
-    export interface IRequestBody {
-        description: string;
-        content: IJsonContent;
-        required: true;
-        "x-nestia-encrypted": boolean;
-    }
-    export type IResponseBody = Record<
-        string,
-        {
-            description: string;
-            content?: IJsonContent;
-            "x-nestia-encrypted"?: boolean;
-        }
-    >;
-    export interface IJsonContent {
-        "application/json": {
-            schema: IJsonSchema;
-        };
-    }
-}
+import { IJsonComponents, IJsonSchema } from "typia";
+import { IJsDocTagInfo } from "typia/lib/metadata/IJsDocTagInfo";
+
+export interface ISwaggerDocument {
+    openapi: "3.0.1";
+    servers: ISwaggerDocument.IServer[];
+    info: ISwaggerDocument.IInfo;
+    components: ISwaggerDocument.IComponents;
+    security?: Record<string, string[]>[];
+    paths: Record<string, ISwaggerDocument.IPath>;
+}
+export namespace ISwaggerDocument {
+    export interface IServer {
+        url: string;
+        description?: string;
+    }
+
+    export interface IInfo {
+        version: string;
+        title: string;
+        description?: string;
+    }
+
+    export interface IComponents extends IJsonComponents {
+        securitySchemes?: Record<string, ISecurityScheme>;
+    }
+
+    /* ---------------------------------------------------------
+        SECURITY SCHEMES
+    --------------------------------------------------------- */
+    export type ISecurityScheme =
+        | ISecurityScheme.IHttpBasic
+        | ISecurityScheme.IHttpBearer
+        | ISecurityScheme.IApiKey
+        | ISecurityScheme.IOpenId
+        | ISecurityScheme.IOAuth2;
+    export namespace ISecurityScheme {
+        export interface IHttpBasic {
+            type: "http";
+            schema: "basic";
+        }
+        export interface IHttpBearer {
+            type: "http";
+            scheme: "bearer";
+            bearerFormat?: string;
+        }
+        export interface IApiKey {
+            type: "apiKey";
+            in: "header" | "query" | "cookie";
+            name: string;
+        }
+
+        export interface IOpenId {
+            type: "openIdConnect";
+            openIdConnectUrl: string;
+        }
+
+        export interface IOAuth2 {
+            type: "oauth2";
+            flows: IOAuth2.IFlowSet;
+            description?: string;
+        }
+        export namespace IOAuth2 {
+            export interface IFlowSet {
+                authorizationCode?: IFlow;
+                implicit?: Omit<IFlow, "tokenUrl">;
+                password?: Omit<IFlow, "authorizationUrl">;
+                clientCredentials?: Omit<IFlow, "authorizationUrl">;
+            }
+            export interface IFlow {
+                authorizationUrl: string;
+                tokenUrl: string;
+                refreshUrl: string;
+                scopes?: Record<string, string>;
+            }
+        }
+    }
+
+    /* ---------------------------------------------------------
+        ROUTE FUNCTIONS
+    --------------------------------------------------------- */
+    export type IPath = Record<string, IRoute>;
+    export interface IRoute {
+        tags: string[];
+        parameters: IParameter[];
+        requestBody?: IRequestBody;
+        responses: IResponseBody;
+        summary?: string;
+        description?: string;
+        "x-nestia-namespace": string;
+        "x-nestia-jsDocTags": IJsDocTagInfo[];
+    }
+
+    export interface IParameter {
+        name: string;
+        in: string;
+        schema: IJsonSchema;
+        required: boolean;
+        description: string;
+    }
+    export interface IRequestBody {
+        description: string;
+        content: IJsonContent;
+        required: true;
+        "x-nestia-encrypted": boolean;
+    }
+    export type IResponseBody = Record<
+        string,
+        {
+            description: string;
+            content?: IJsonContent;
+            "x-nestia-encrypted"?: boolean;
+        }
+    >;
+    export interface IJsonContent {
+        "application/json": {
+            schema: IJsonSchema;
+        };
+    }
+}

package/src/structures/ITypeTuple.ts

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

package/src/structures/MethodType.ts

@@ -1,11 +1,11 @@
-export type MethodType = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-
-export namespace MethodType {
-    export const VALUES: MethodType[] = [
-        "GET",
-        "POST",
-        "PUT",
-        "PATCH",
-        "DELETE",
-    ];
-}
+export type MethodType = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+export namespace MethodType {
+    export const VALUES: MethodType[] = [
+        "GET",
+        "POST",
+        "PUT",
+        "PATCH",
+        "DELETE",
+    ];
+}

package/src/structures/ParamCategory.ts

@@ -1 +1 @@
-export type ParamCategory = "param" | "query" | "body";
+export type ParamCategory = "param" | "query" | "body";

package/src/structures/TypeEntry.ts

@@ -1,22 +1,22 @@
-import { hash } from "tstl/functional/hash";
-import ts from "typescript";
-
-export class TypeEntry {
-    public constructor(
-        public readonly type: ts.Type,
-        public readonly nullable: boolean,
-        public readonly required: boolean,
-    ) {}
-
-    public equals(obj: TypeEntry): boolean {
-        return (
-            this.type === obj.type &&
-            this.nullable === obj.nullable &&
-            this.required === obj.required
-        );
-    }
-
-    public hashCode(): number {
-        return hash(this.type, this.nullable, this.required);
-    }
-}
+import { hash } from "tstl/functional/hash";
+import ts from "typescript";
+
+export class TypeEntry {
+    public constructor(
+        public readonly type: ts.Type,
+        public readonly nullable: boolean,
+        public readonly required: boolean,
+    ) {}
+
+    public equals(obj: TypeEntry): boolean {
+        return (
+            this.type === obj.type &&
+            this.nullable === obj.nullable &&
+            this.required === obj.required
+        );
+    }
+
+    public hashCode(): number {
+        return hash(this.type, this.nullable, this.required);
+    }
+}

package/src/utils/ArrayUtil.ts

@@ -1,26 +1,26 @@
-export namespace ArrayUtil {
-    export function has<T>(array: T[], ...items: T[]): boolean {
-        return items.every(
-            (elem) => array.find((org) => org === elem) !== undefined,
-        );
-    }
-
-    export async function asyncMap<Input, Output>(
-        array: Input[],
-        closure: (input: Input) => Promise<Output>,
-    ): Promise<Output[]> {
-        const ret: Output[] = [];
-        for (const elem of array) ret.push(await closure(elem));
-        return ret;
-    }
-
-    export async function asyncFilter<Input>(
-        array: Input[],
-        closure: (input: Input) => Promise<boolean>,
-    ): Promise<Input[]> {
-        const ret: Input[] = [];
-        for (const elem of array)
-            if ((await closure(elem)) === true) ret.push(elem);
-        return ret;
-    }
-}
+export namespace ArrayUtil {
+    export function has<T>(array: T[], ...items: T[]): boolean {
+        return items.every(
+            (elem) => array.find((org) => org === elem) !== undefined,
+        );
+    }
+
+    export async function asyncMap<Input, Output>(
+        array: Input[],
+        closure: (input: Input) => Promise<Output>,
+    ): Promise<Output[]> {
+        const ret: Output[] = [];
+        for (const elem of array) ret.push(await closure(elem));
+        return ret;
+    }
+
+    export async function asyncFilter<Input>(
+        array: Input[],
+        closure: (input: Input) => Promise<boolean>,
+    ): Promise<Input[]> {
+        const ret: Input[] = [];
+        for (const elem of array)
+            if ((await closure(elem)) === true) ret.push(elem);
+        return ret;
+    }
+}

package/src/utils/FileRetriever.ts

@@ -1,22 +1,22 @@
-import fs from "fs";
-import path from "path";
-
-export namespace FileRetriever {
-    export const directory =
-        (name: string) =>
-        (dir: string, depth: number = 0): string | null => {
-            const location: string = path.join(dir, name);
-            if (fs.existsSync(location)) return dir;
-            else if (depth > 2) return null;
-            return directory(name)(path.join(dir, ".."), depth + 1);
-        };
-
-    export const file =
-        (name: string) =>
-        (directory: string, depth: number = 0): string | null => {
-            const location: string = path.join(directory, name);
-            if (fs.existsSync(location)) return location;
-            else if (depth > 2) return null;
-            return file(name)(path.join(directory, ".."), depth + 1);
-        };
-}
+import fs from "fs";
+import path from "path";
+
+export namespace FileRetriever {
+    export const directory =
+        (name: string) =>
+        (dir: string, depth: number = 0): string | null => {
+            const location: string = path.join(dir, name);
+            if (fs.existsSync(location)) return dir;
+            else if (depth > 2) return null;
+            return directory(name)(path.join(dir, ".."), depth + 1);
+        };
+
+    export const file =
+        (name: string) =>
+        (directory: string, depth: number = 0): string | null => {
+            const location: string = path.join(directory, name);
+            if (fs.existsSync(location)) return location;
+            else if (depth > 2) return null;
+            return file(name)(path.join(directory, ".."), depth + 1);
+        };
+}

package/src/utils/ImportDictionary.ts

@@ -1,56 +1,56 @@
-import path from "path";
-import { HashMap } from "tstl/container/HashMap";
-import { HashSet } from "tstl/container/HashSet";
-import { Pair } from "tstl/utility/Pair";
-
-export class ImportDictionary {
-    private readonly dict_: HashMap<string, Pair<boolean, HashSet<string>>> =
-        new HashMap();
-
-    public empty(): boolean {
-        return this.dict_.empty();
-    }
-
-    public emplace(file: string, realistic: boolean, instance: string): void {
-        if (file.substr(-5) === ".d.ts") file = file.substr(0, file.length - 5);
-        else if (file.substr(-3) === ".ts")
-            file = file.substr(0, file.length - 3);
-        else
-            throw new Error(
-                `Error on ImportDictionary.emplace(): extension of the target file "${file}" is not "ts".`,
-            );
-
-        const pair: Pair<boolean, HashSet<string>> = this.dict_.take(
-            file,
-            () => new Pair(realistic, new HashSet()),
-        );
-        pair.second.insert(instance);
-    }
-
-    public toScript(outDir: string): string {
-        const statements: string[] = [];
-        for (const it of this.dict_) {
-            const file: string = (() => {
-                const location: string = path
-                    .relative(outDir, it.first)
-                    .split("\\")
-                    .join("/");
-                const index: number = location.lastIndexOf(NODE_MODULES);
-                return index === -1
-                    ? `./${location}`
-                    : location.substring(index + NODE_MODULES.length);
-            })();
-            const realistic: boolean = it.second.first;
-            const instances: string[] = it.second.second.toJSON();
-
-            statements.push(
-                `import ${!realistic ? "type " : ""}{ ${instances.join(
-                    ", ",
-                )} } from "${file}";`,
-            );
-        }
-        return statements.join("\n");
-    }
-}
-
-const NODE_MODULES = "node_modules/";
+import path from "path";
+import { HashMap } from "tstl/container/HashMap";
+import { HashSet } from "tstl/container/HashSet";
+import { Pair } from "tstl/utility/Pair";
+
+export class ImportDictionary {
+    private readonly dict_: HashMap<string, Pair<boolean, HashSet<string>>> =
+        new HashMap();
+
+    public empty(): boolean {
+        return this.dict_.empty();
+    }
+
+    public emplace(file: string, realistic: boolean, instance: string): void {
+        if (file.substr(-5) === ".d.ts") file = file.substr(0, file.length - 5);
+        else if (file.substr(-3) === ".ts")
+            file = file.substr(0, file.length - 3);
+        else
+            throw new Error(
+                `Error on ImportDictionary.emplace(): extension of the target file "${file}" is not "ts".`,
+            );
+
+        const pair: Pair<boolean, HashSet<string>> = this.dict_.take(
+            file,
+            () => new Pair(realistic, new HashSet()),
+        );
+        pair.second.insert(instance);
+    }
+
+    public toScript(outDir: string): string {
+        const statements: string[] = [];
+        for (const it of this.dict_) {
+            const file: string = (() => {
+                const location: string = path
+                    .relative(outDir, it.first)
+                    .split("\\")
+                    .join("/");
+                const index: number = location.lastIndexOf(NODE_MODULES);
+                return index === -1
+                    ? `./${location}`
+                    : location.substring(index + NODE_MODULES.length);
+            })();
+            const realistic: boolean = it.second.first;
+            const instances: string[] = it.second.second.toJSON();
+
+            statements.push(
+                `import ${!realistic ? "type " : ""}{ ${instances.join(
+                    ", ",
+                )} } from "${file}";`,
+            );
+        }
+        return statements.join("\n");
+    }
+}
+
+const NODE_MODULES = "node_modules/";

package/src/utils/MapUtil.ts

@@ -1,14 +1,14 @@
-export namespace MapUtil {
-    export function take<Key, T>(
-        dict: Map<Key, T>,
-        key: Key,
-        generator: () => T,
-    ): T {
-        const oldbie: T | undefined = dict.get(key);
-        if (oldbie) return oldbie;
-
-        const value: T = generator();
-        dict.set(key, value);
-        return value;
-    }
-}
+export namespace MapUtil {
+    export function take<Key, T>(
+        dict: Map<Key, T>,
+        key: Key,
+        generator: () => T,
+    ): T {
+        const oldbie: T | undefined = dict.get(key);
+        if (oldbie) return oldbie;
+
+        const value: T = generator();
+        dict.set(key, value);
+        return value;
+    }
+}