@nestia/sdk 4.2.0-dev.20241211 → 4.2.0

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

@@ -1,26 +1,26 @@
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-
-export namespace MetadataUtil {
-  export const visit = (closure: (m: Metadata) => unknown) => {
-    const visited: WeakSet<Metadata> = new WeakSet();
-    const iterate = (metadata: Metadata): void => {
-      if (visited.has(metadata)) return;
-      visited.add(metadata);
-      closure(metadata);
-      for (const alias of metadata.aliases) iterate(alias.type.value);
-      for (const array of metadata.arrays) iterate(array.type.value);
-      for (const tuple of metadata.tuples) tuple.type.elements.map(iterate);
-      for (const object of metadata.objects)
-        object.type.properties.forEach((p) => {
-          iterate(p.key);
-          iterate(p.value);
-        });
-      if (metadata.escaped) {
-        iterate(metadata.escaped.original);
-        iterate(metadata.escaped.returns);
-      }
-      if (metadata.rest) iterate(metadata.rest);
-    };
-    return iterate;
-  };
-}
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+export namespace MetadataUtil {
+  export const visit = (closure: (m: Metadata) => unknown) => {
+    const visited: WeakSet<Metadata> = new WeakSet();
+    const iterate = (metadata: Metadata): void => {
+      if (visited.has(metadata)) return;
+      visited.add(metadata);
+      closure(metadata);
+      for (const alias of metadata.aliases) iterate(alias.type.value);
+      for (const array of metadata.arrays) iterate(array.type.value);
+      for (const tuple of metadata.tuples) tuple.type.elements.map(iterate);
+      for (const object of metadata.objects)
+        object.type.properties.forEach((p) => {
+          iterate(p.key);
+          iterate(p.value);
+        });
+      if (metadata.escaped) {
+        iterate(metadata.escaped.original);
+        iterate(metadata.escaped.returns);
+      }
+      if (metadata.rest) iterate(metadata.rest);
+    };
+    return iterate;
+  };
+}

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,17 +1,17 @@
-export namespace StringUtil {
-  export const capitalize = (text: string): string =>
-    text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
-
-  export const escapeDuplicate =
-    (keep: string[]) =>
-    (change: string): string =>
-      keep.includes(change) ? escapeDuplicate(keep)(`_${change}`) : change;
-
-  export const isImplicit = (str: string) =>
-    str === "object" ||
-    str === "__type" ||
-    str === "__object" ||
-    str.startsWith("__type.") ||
-    str.startsWith("__object.") ||
-    str.includes("readonly [");
-}
+export namespace StringUtil {
+  export const capitalize = (text: string): string =>
+    text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+
+  export const escapeDuplicate =
+    (keep: string[]) =>
+    (change: string): string =>
+      keep.includes(change) ? escapeDuplicate(keep)(`_${change}`) : change;
+
+  export const isImplicit = (str: string) =>
+    str === "object" ||
+    str === "__type" ||
+    str === "__object" ||
+    str.startsWith("__type.") ||
+    str.startsWith("__object.") ||
+    str.includes("readonly [");
+}

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/src/utils/VersioningStrategy.ts

@@ -1,28 +1,28 @@
-import { VERSION_NEUTRAL, VersionValue } from "@nestjs/common/interfaces";
-
-import { INestiaProject } from "../structures/INestiaProject";
-
-export namespace VersioningStrategy {
-  export const cast = (
-    value: VersionValue | undefined,
-  ): Array<string | typeof VERSION_NEUTRAL> =>
-    value === undefined ? [] : Array.isArray(value) ? value : [value];
-
-  export const merge =
-    (project: Omit<INestiaProject, "config">) =>
-    (values: Array<string | typeof VERSION_NEUTRAL>): string[] => {
-      if (project.input.versioning === undefined) return [""];
-      const set: Set<string | typeof VERSION_NEUTRAL> = new Set(values);
-      const array: Array<string | typeof VERSION_NEUTRAL> =
-        set.size === 0
-          ? cast(project.input.versioning?.defaultVersion)
-          : Array.from(set);
-      return !!array?.length
-        ? array.map((x) =>
-            typeof x === "symbol"
-              ? ""
-              : `${project.input.versioning!.prefix}${x}`,
-          )
-        : [];
-    };
-}
+import { VERSION_NEUTRAL, VersionValue } from "@nestjs/common/interfaces";
+
+import { INestiaProject } from "../structures/INestiaProject";
+
+export namespace VersioningStrategy {
+  export const cast = (
+    value: VersionValue | undefined,
+  ): Array<string | typeof VERSION_NEUTRAL> =>
+    value === undefined ? [] : Array.isArray(value) ? value : [value];
+
+  export const merge =
+    (project: Omit<INestiaProject, "config">) =>
+    (values: Array<string | typeof VERSION_NEUTRAL>): string[] => {
+      if (project.input.versioning === undefined) return [""];
+      const set: Set<string | typeof VERSION_NEUTRAL> = new Set(values);
+      const array: Array<string | typeof VERSION_NEUTRAL> =
+        set.size === 0
+          ? cast(project.input.versioning?.defaultVersion)
+          : Array.from(set);
+      return !!array?.length
+        ? array.map((x) =>
+            typeof x === "symbol"
+              ? ""
+              : `${project.input.versioning!.prefix}${x}`,
+          )
+        : [];
+    };
+}

package/src/validators/HttpHeadersValidator.ts

@@ -1,34 +1,34 @@
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { MetadataArrayType } from "typia/lib/schemas/metadata/MetadataArrayType";
-
-export namespace HttpHeadersValidator {
-  export const validate = (
-    meta: Metadata,
-    explore: MetadataFactory.IExplore,
-  ): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (explore.top === true) {
-      const expected: number =
-        meta.atomics.length +
-        meta.templates.length +
-        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
-        meta.arrays.length;
-      if (meta.size() !== expected)
-        insert("Only atomic or array of atomic types are allowed.");
-    } else if (
-      explore.nested !== null &&
-      explore.nested instanceof MetadataArrayType
-    ) {
-      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)
-        insert("Only atomic types are allowed in array.");
-    }
-    return errors;
-  };
-}
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataArrayType } from "typia/lib/schemas/metadata/MetadataArrayType";
+
+export namespace HttpHeadersValidator {
+  export const validate = (
+    meta: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (explore.top === true) {
+      const expected: number =
+        meta.atomics.length +
+        meta.templates.length +
+        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
+        meta.arrays.length;
+      if (meta.size() !== expected)
+        insert("Only atomic or array of atomic types are allowed.");
+    } else if (
+      explore.nested !== null &&
+      explore.nested instanceof MetadataArrayType
+    ) {
+      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)
+        insert("Only atomic types are allowed in array.");
+    }
+    return errors;
+  };
+}

package/src/validators/HttpQueryValidator.ts

@@ -1,34 +1,34 @@
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-import { MetadataArrayType } from "typia/lib/schemas/metadata/MetadataArrayType";
-
-export namespace HttpQueryValidator {
-  export const validate = (
-    meta: Metadata,
-    explore: MetadataFactory.IExplore,
-  ): string[] => {
-    const errors: string[] = [];
-    const insert = (msg: string) => errors.push(msg);
-
-    if (explore.top === true) {
-      const expected: number =
-        meta.atomics.length +
-        meta.templates.length +
-        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
-        meta.arrays.length;
-      if (meta.size() !== expected)
-        insert("Only atomic or array of atomic types are allowed.");
-    } else if (
-      explore.nested !== null &&
-      explore.nested instanceof MetadataArrayType
-    ) {
-      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)
-        insert("Only atomic types are allowed in array.");
-    }
-    return errors;
-  };
-}
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+import { MetadataArrayType } from "typia/lib/schemas/metadata/MetadataArrayType";
+
+export namespace HttpQueryValidator {
+  export const validate = (
+    meta: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    const errors: string[] = [];
+    const insert = (msg: string) => errors.push(msg);
+
+    if (explore.top === true) {
+      const expected: number =
+        meta.atomics.length +
+        meta.templates.length +
+        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
+        meta.arrays.length;
+      if (meta.size() !== expected)
+        insert("Only atomic or array of atomic types are allowed.");
+    } else if (
+      explore.nested !== null &&
+      explore.nested instanceof MetadataArrayType
+    ) {
+      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)
+        insert("Only atomic types are allowed in array.");
+    }
+    return errors;
+  };
+}