@nestia/sdk 3.0.0-dev.20231209 → 3.0.0-dev.20240412

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/IRoute.ts

@@ -1,53 +1,53 @@
-import ts from "typescript";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-
-import { IController } from "./IController";
-
-export interface IRoute {
-  name: string;
-  method: string;
-  path: string;
-  encrypted: boolean;
-  status?: number;
-
-  accessors: string[];
-  parameters: IRoute.IParameter[];
-  imports: [string, string[]][];
-  output: IRoute.IOutput;
-
-  location: string;
-  symbol: {
-    class: string;
-    function: 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", IRoute.IOutput>;
-  swaggerTags: string[];
-}
-
-export namespace IRoute {
-  export type IParameter = IController.IParameter & {
-    optional: boolean;
-    type: ts.Type;
-    typeName: string;
-    metadata?: Metadata;
-  };
-  export interface IOutput {
-    type: ts.Type;
-    typeName: string;
-    metadata?: Metadata;
-    description?: string;
-    contentType:
-      | "application/json"
-      | "application/octet-stream"
-      | "application/x-www-form-urlencoded"
-      | "text/plain";
-  }
-}
+import ts from "typescript";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+import { IController } from "./IController";
+
+export interface IRoute {
+  controller: Function;
+  name: string;
+  method: string;
+  path: string;
+  encrypted: boolean;
+  status?: number;
+
+  accessors: string[];
+  parameters: IRoute.IParameter[];
+  imports: [string, string[]][];
+  output: IRoute.IOutput;
+
+  location: string;
+  target: {
+    class: Function;
+    function: Function;
+  };
+  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", IRoute.IOutput>;
+  swaggerTags: string[];
+}
+
+export namespace IRoute {
+  export type IParameter = IController.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/ISwaggerLazyProperty.ts

@@ -1,7 +1,7 @@
-import { IJsonSchema } from "typia";
+import { OpenApi } from "@samchon/openapi";
 
 export interface ISwaggerLazyProperty {
-  schema: IJsonSchema;
+  schema: OpenApi.IJsonSchema;
   object: string;
   property: string;
 }

package/src/structures/ISwaggerLazySchema.ts

@@ -1,7 +1,7 @@
-import { IJsonSchema } from "typia";
+import { OpenApi } from "@samchon/openapi";
 import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 
 export interface ISwaggerLazySchema {
   metadata: Metadata;
-  schema: IJsonSchema;
+  schema: OpenApi.IJsonSchema;
 }

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

package/src/structures/TypeEntry.ts

@@ -1,4 +1,4 @@
-import { hash } from "tstl/functional/hash";
+import { hash } from "tstl";
 import ts from "typescript";
 
 export class TypeEntry {

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

@@ -0,0 +1,6 @@
+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;
+};

package/assets/bundle/api/utils/NestiaSimulator.ts

@@ -1,70 +0,0 @@
-import { HttpError } from "@nestia/fetcher";
-
-import typia from "typia";
-
-export namespace NestiaSimulator {
-    export interface IProps {
-        host: string;
-        path: string;
-        method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
-        contentType: string;
-    }
-
-    export const assert = (props: IProps) => {
-        return {
-            param: param(props),
-            query: query(props),
-            body: body(props),
-        };
-    };
-    const param =
-        (props: IProps) =>
-        (name: string) =>
-        <T>(task: () => T): void => {
-            validate(
-                (exp) => `URL parameter "${name}" is not ${exp.expected} type.`,
-            )(props)(task);
-        };
-
-    const query =
-        (props: IProps) =>
-        <T>(task: () => T): void =>
-            validate(
-                () =>
-                    "Request query parameters are not following the promised type.",
-            )(props)(task);
-
-    const body =
-        (props: IProps) =>
-        <T>(task: () => T): void =>
-            validate(() => "Request body is not following the promised type.")(
-                props,
-            )(task);
-
-    const validate =
-        (message: (exp: typia.TypeGuardError) => string, path?: string) =>
-        (props: IProps) =>
-        <T>(task: () => T): void => {
-            try {
-                task();
-            } catch (exp) {
-                if (typia.is<typia.TypeGuardError>(exp))
-                    throw new HttpError(
-                        props.method,
-                        props.host + props.path,
-                        400,
-                        {
-                            "Content-Type": props.contentType,
-                        },
-                        JSON.stringify({
-                            method: exp.method,
-                            path: path ?? exp.path,
-                            expected: exp.expected,
-                            value: exp.value,
-                            message: message(exp),
-                        }),
-                    );
-                throw exp;
-            }
-        };
-}

package/lib/generates/internal/SdkDtoGenerator.d.ts

@@ -1,9 +0,0 @@
-import ts from "typescript";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
-import { ImportDictionary } from "../../utils/ImportDictionary";
-export declare namespace SdkDtoGenerator {
-    const generate: (checker: ts.TypeChecker) => (config: INestiaConfig) => (routes: IRoute[]) => Promise<void>;
-    const decode: (config: INestiaConfig) => (importer: ImportDictionary) => (meta: Metadata, parentEscaped?: boolean) => string;
-}