@nestia/sdk 3.1.0-dev.20240429 → 3.1.0-dev.20240430

package/src/structures/INormalizedInput.ts

@@ -1,20 +1,20 @@
-import { RouteInfo, VersionValue } from "@nestjs/common/interfaces";
-
-export interface INormalizedInput {
-  include: INormalizedInput.IInput[];
-  globalPrefix?: {
-    prefix: string;
-    exclude?: Array<string | RouteInfo>;
-  };
-  versioning?: {
-    prefix: string;
-    defaultVersion?: VersionValue;
-  };
-}
-export namespace INormalizedInput {
-  export interface IInput {
-    paths: string[];
-    file: string;
-    controller?: Function;
-  }
-}
+import { RouteInfo, VersionValue } from "@nestjs/common/interfaces";
+
+export interface INormalizedInput {
+  include: INormalizedInput.IInput[];
+  globalPrefix?: {
+    prefix: string;
+    exclude?: Array<string | RouteInfo>;
+  };
+  versioning?: {
+    prefix: string;
+    defaultVersion?: VersionValue;
+  };
+}
+export namespace INormalizedInput {
+  export interface IInput {
+    paths: string[];
+    file: string;
+    controller?: Function;
+  }
+}

package/src/structures/IReflectController.ts

@@ -1,17 +1,17 @@
-import type { VERSION_NEUTRAL } from "@nestjs/common/interfaces";
-
-import { IReflectHttpOperation } from "./IReflectHttpOperation";
-import { IReflectWebSocketOperation } from "./IReflectWebSocketOperation";
-
-export interface IReflectController {
-  constructor: Function;
-  prototype: any;
-  file: string;
-  name: string;
-  prefixes: string[];
-  paths: string[];
-  versions: Array<string | typeof VERSION_NEUTRAL> | undefined;
-  operations: Array<IReflectHttpOperation | IReflectWebSocketOperation>;
-  security: Record<string, string[]>[];
-  swaggerTgas: string[];
-}
+import type { VERSION_NEUTRAL } from "@nestjs/common/interfaces";
+
+import { IReflectHttpOperation } from "./IReflectHttpOperation";
+import { IReflectWebSocketOperation } from "./IReflectWebSocketOperation";
+
+export interface IReflectController {
+  constructor: Function;
+  prototype: any;
+  file: string;
+  name: string;
+  prefixes: string[];
+  paths: string[];
+  versions: Array<string | typeof VERSION_NEUTRAL> | undefined;
+  operations: Array<IReflectHttpOperation | IReflectWebSocketOperation>;
+  security: Record<string, string[]>[];
+  swaggerTgas: string[];
+}

package/src/structures/ITypeTuple.ts

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

package/src/structures/ITypedHttpRoute.ts

@@ -1,55 +1,55 @@
-import ts from "typescript";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-
-import { IReflectController } from "./IReflectController";
-import { IReflectHttpOperation } from "./IReflectHttpOperation";
-
-export interface ITypedHttpRoute {
-  protocol: "http";
-  controller: IReflectController;
-  function: Function;
-  name: string;
-  method: string;
-  path: string;
-  encrypted: boolean;
-  status?: number;
-
-  accessors: string[];
-  parameters: ITypedHttpRoute.IParameter[];
-  imports: [string, string[]][];
-  output: ITypedHttpRoute.IOutput;
-
-  location: string;
-  description?: string;
-  operationId?: string;
-  jsDocTags: ts.JSDocTagInfo[];
-  setHeaders: Array<
-    | { type: "setter"; source: string; target?: string }
-    | { type: "assigner"; source: string }
-  >;
-  security: Record<string, string[]>[];
-  exceptions: Record<
-    number | "2XX" | "3XX" | "4XX" | "5XX",
-    ITypedHttpRoute.IOutput
-  >;
-  swaggerTags: string[];
-}
-
-export namespace ITypedHttpRoute {
-  export type IParameter = IReflectHttpOperation.IParameter & {
-    optional: boolean;
-    type: ts.Type;
-    typeName: string;
-    metadata?: Metadata;
-  };
-  export interface IOutput {
-    type: ts.Type;
-    typeName: string;
-    metadata?: Metadata;
-    description?: string;
-    contentType:
-      | "application/x-www-form-urlencoded"
-      | "application/json"
-      | "text/plain";
-  }
-}
+import ts from "typescript";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+import { IReflectController } from "./IReflectController";
+import { IReflectHttpOperation } from "./IReflectHttpOperation";
+
+export interface ITypedHttpRoute {
+  protocol: "http";
+  controller: IReflectController;
+  function: Function;
+  name: string;
+  method: string;
+  path: string;
+  encrypted: boolean;
+  status?: number;
+
+  accessors: string[];
+  parameters: ITypedHttpRoute.IParameter[];
+  imports: [string, string[]][];
+  output: ITypedHttpRoute.IOutput;
+
+  location: string;
+  description?: string;
+  operationId?: string;
+  jsDocTags: ts.JSDocTagInfo[];
+  setHeaders: Array<
+    | { type: "setter"; source: string; target?: string }
+    | { type: "assigner"; source: string }
+  >;
+  security: Record<string, string[]>[];
+  exceptions: Record<
+    number | "2XX" | "3XX" | "4XX" | "5XX",
+    ITypedHttpRoute.IOutput
+  >;
+  swaggerTags: string[];
+}
+
+export namespace ITypedHttpRoute {
+  export type IParameter = IReflectHttpOperation.IParameter & {
+    optional: boolean;
+    type: ts.Type;
+    typeName: string;
+    metadata?: Metadata;
+  };
+  export interface IOutput {
+    type: ts.Type;
+    typeName: string;
+    metadata?: Metadata;
+    description?: string;
+    contentType:
+      | "application/x-www-form-urlencoded"
+      | "application/json"
+      | "text/plain";
+  }
+}

package/src/structures/ITypedWebSocketRoute.ts

@@ -17,6 +17,7 @@ export interface ITypedWebSocketRoute {
 
   location: string;
   description?: string;
+  jsDocTags: ts.JSDocTagInfo[];
 }
 export namespace ITypedWebSocketRoute {
   export type IParameter =

package/src/structures/MethodType.ts

@@ -1,5 +1,5 @@
-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" | "rawBody" | "headers";
+export type ParamCategory = "param" | "query" | "body" | "rawBody" | "headers";

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/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;
+  }
+}

package/src/utils/PathUtil.ts

@@ -1,10 +1,10 @@
-export namespace PathUtil {
-  export const accessors = (path: string) =>
-    path
-      .split("/")
-      .filter((str) => str.length && str[0] !== ":")
-      .map(normalize);
-
-  const normalize = (str: string) =>
-    str.split("-").join("_").split(".").join("_");
-}
+export namespace PathUtil {
+  export const accessors = (path: string) =>
+    path
+      .split("/")
+      .filter((str) => str.length && str[0] !== ":")
+      .map(normalize);
+
+  const normalize = (str: string) =>
+    str.split("-").join("_").split(".").join("_");
+}

package/src/utils/SourceFinder.ts

@@ -1,66 +1,66 @@
-import fs from "fs";
-import glob from "glob";
-import path from "path";
-
-export namespace SourceFinder {
-  interface IProps {
-    exclude?: string[];
-    include: string[];
-    filter: (location: string) => Promise<boolean>;
-  }
-
-  export const find = async (props: IProps): Promise<string[]> => {
-    const dict: Set<string> = new Set();
-
-    await emplace(props.filter)(props.include)((str) => dict.add(str));
-    if (props.exclude?.length)
-      await emplace(props.filter)(props.exclude)((str) => dict.delete(str));
-
-    return [...dict];
-  };
-
-  const emplace =
-    (filter: (file: string) => Promise<boolean>) =>
-    (input: string[]) =>
-    async (closure: (location: string) => void): Promise<void> => {
-      for (const pattern of input) {
-        if (_Is_file(pattern)) {
-          closure(path.resolve(pattern));
-          continue;
-        }
-        for (const file of await _Glob(pattern)) {
-          const stats: fs.Stats = await fs.promises.stat(file);
-          if (stats.isDirectory() === true)
-            await iterate(filter)(closure)(file);
-          else if (stats.isFile() && (await filter(file))) closure(file);
-        }
-      }
-    };
-
-  const iterate =
-    (filter: (location: string) => Promise<boolean>) =>
-    (closure: (location: string) => void) =>
-    async (location: string): Promise<void> => {
-      const directory: string[] = await fs.promises.readdir(location);
-      for (const file of directory) {
-        const next: string = path.resolve(`${location}/${file}`);
-        const stats: fs.Stats = await fs.promises.stat(next);
-
-        if (stats.isDirectory() === true) await iterate(filter)(closure)(next);
-        else if (stats.isFile() && (await filter(next))) closure(next);
-      }
-    };
-
-  const _Glob = (pattern: string): Promise<string[]> =>
-    new Promise((resolve, reject) => {
-      glob(pattern, (err, matches) => {
-        if (err) reject(err);
-        else resolve(matches.map((str) => path.resolve(str)));
-      });
-    });
-
-  const _Is_file = (pattern: string): boolean =>
-    pattern.endsWith(".ts") &&
-    !pattern.endsWith(".d.ts") &&
-    fs.existsSync(pattern);
-}
+import fs from "fs";
+import glob from "glob";
+import path from "path";
+
+export namespace SourceFinder {
+  interface IProps {
+    exclude?: string[];
+    include: string[];
+    filter: (location: string) => Promise<boolean>;
+  }
+
+  export const find = async (props: IProps): Promise<string[]> => {
+    const dict: Set<string> = new Set();
+
+    await emplace(props.filter)(props.include)((str) => dict.add(str));
+    if (props.exclude?.length)
+      await emplace(props.filter)(props.exclude)((str) => dict.delete(str));
+
+    return [...dict];
+  };
+
+  const emplace =
+    (filter: (file: string) => Promise<boolean>) =>
+    (input: string[]) =>
+    async (closure: (location: string) => void): Promise<void> => {
+      for (const pattern of input) {
+        if (_Is_file(pattern)) {
+          closure(path.resolve(pattern));
+          continue;
+        }
+        for (const file of await _Glob(pattern)) {
+          const stats: fs.Stats = await fs.promises.stat(file);
+          if (stats.isDirectory() === true)
+            await iterate(filter)(closure)(file);
+          else if (stats.isFile() && (await filter(file))) closure(file);
+        }
+      }
+    };
+
+  const iterate =
+    (filter: (location: string) => Promise<boolean>) =>
+    (closure: (location: string) => void) =>
+    async (location: string): Promise<void> => {
+      const directory: string[] = await fs.promises.readdir(location);
+      for (const file of directory) {
+        const next: string = path.resolve(`${location}/${file}`);
+        const stats: fs.Stats = await fs.promises.stat(next);
+
+        if (stats.isDirectory() === true) await iterate(filter)(closure)(next);
+        else if (stats.isFile() && (await filter(next))) closure(next);
+      }
+    };
+
+  const _Glob = (pattern: string): Promise<string[]> =>
+    new Promise((resolve, reject) => {
+      glob(pattern, (err, matches) => {
+        if (err) reject(err);
+        else resolve(matches.map((str) => path.resolve(str)));
+      });
+    });
+
+  const _Is_file = (pattern: string): boolean =>
+    pattern.endsWith(".ts") &&
+    !pattern.endsWith(".d.ts") &&
+    fs.existsSync(pattern);
+}

package/src/utils/StringUtil.ts

@@ -1,6 +1,6 @@
-export namespace StringUtil {
-  export const escapeDuplicate =
-    (keep: string[]) =>
-    (change: string): string =>
-      keep.includes(change) ? escapeDuplicate(keep)(`_${change}`) : change;
-}
+export namespace StringUtil {
+  export const escapeDuplicate =
+    (keep: string[]) =>
+    (change: string): string =>
+      keep.includes(change) ? escapeDuplicate(keep)(`_${change}`) : change;
+}

package/src/utils/StripEnums.ts

@@ -1,5 +1,5 @@
-export type StripEnums<T extends Record<string, any>> = {
-  [Key in keyof T]: T[Key] extends string | boolean | object | undefined | any[]
-    ? T[Key]
-    : any;
-};
+export type StripEnums<T extends Record<string, any>> = {
+  [Key in keyof T]: T[Key] extends string | boolean | object | undefined | any[]
+    ? T[Key]
+    : any;
+};