typia 5.3.5-dev.20231206 → 5.3.5

package/src/programmers/http/HttpValidateQueryProgrammer.ts

@@ -1,75 +1,75 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
-
-export namespace HttpValidateQueryProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode(HttpQueryProgrammer.INPUT_TYPE),
-          ),
-        ],
-        ts.factory.createTypeReferenceNode(
-          `typia.IValidation<typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>>`,
-        ),
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "validate",
-            ValidateProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: true,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "query",
-            HttpQueryProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("query"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("validate"),
-                undefined,
-                [ts.factory.createIdentifier("output")],
-              ),
-              ts.factory.createTypeReferenceNode("any"),
-            ),
-          ),
-        ]),
-      );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
+
+export namespace HttpValidateQueryProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode(HttpQueryProgrammer.INPUT_TYPE),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode(
+          `typia.IValidation<typia.Resolved<${
+            name ?? TypeFactory.getFullName(project.checker)(type)
+          }>>`,
+        ),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "validate",
+            ValidateProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: true,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "query",
+            HttpQueryProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("query"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("validate"),
+                undefined,
+                [ts.factory.createIdentifier("output")],
+              ),
+              ts.factory.createTypeReferenceNode("any"),
+            ),
+          ),
+        ]),
+      );
+}

package/src/programmers/internal/application_alias.ts

@@ -1,65 +1,65 @@
-import { CommentFactory } from "../../factories/CommentFactory";
-
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { MetadataAlias } from "../../schemas/metadata/MetadataAlias";
-
-import { IJsonSchema } from "../../module";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { JSON_COMPONENTS_PREFIX } from "./JSON_SCHEMA_PREFIX";
-import { application_object } from "./application_object";
-import { application_schema } from "./application_schema";
-
-export const application_alias =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  <BlockNever extends boolean>(blockNever: BlockNever) =>
-  (components: IJsonComponents) =>
-  (alias: MetadataAlias) =>
-  (nullable: boolean): IJsonSchema.IReference => {
-    if (alias.value.size() === 1 && alias.value.objects.length === 1)
-      return application_object(options)(components)(alias.value.objects[0]!)(
-        nullable,
-      );
-
-    const key: string =
-      options.purpose === "ajv"
-        ? alias.name
-        : `${alias.name}${nullable ? ".Nullable" : ""}`;
-    const $id: string = `${JSON_COMPONENTS_PREFIX}/schemas/${key}`;
-
-    // TEMPORARY ASSIGNMENT
-    if (components.schemas?.[key] === undefined) {
-      components.schemas ??= {};
-      components.schemas[key] = {
-        $id: key,
-      } as any;
-
-      // GENERATE SCHEM
-      const schema: IJsonSchema = application_schema(options)(blockNever)(
-        components,
-      )(alias.value)({
-        deprecated:
-          alias.jsDocTags.some((tag) => tag.name === "deprecated") || undefined,
-        title: (() => {
-          const info: IJsDocTagInfo | undefined = alias.jsDocTags.find(
-            (tag) => tag.name === "title",
-          );
-          return info?.text?.length
-            ? CommentFactory.merge(info.text)
-            : undefined;
-        })(),
-        description: alias.description ?? undefined,
-        "x-typia-jsDocTags": alias.jsDocTags.length
-          ? alias.jsDocTags
-          : undefined,
-      })!;
-      components.schemas ??= {};
-      components.schemas[key] = {
-        $id: options.purpose === "ajv" ? $id : undefined,
-        $recursiveAnchor:
-          (options.purpose === "ajv" && alias.recursive) || undefined,
-        ...schema,
-      };
-    }
-    return { $ref: $id };
-  };
+import { CommentFactory } from "../../factories/CommentFactory";
+
+import { IJsonComponents } from "../../schemas/json/IJsonComponents";
+import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
+import { MetadataAlias } from "../../schemas/metadata/MetadataAlias";
+
+import { IJsonSchema } from "../../module";
+import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
+import { JSON_COMPONENTS_PREFIX } from "./JSON_SCHEMA_PREFIX";
+import { application_object } from "./application_object";
+import { application_schema } from "./application_schema";
+
+export const application_alias =
+  (options: JsonApplicationProgrammer.IOptions) =>
+  <BlockNever extends boolean>(blockNever: BlockNever) =>
+  (components: IJsonComponents) =>
+  (alias: MetadataAlias) =>
+  (nullable: boolean): IJsonSchema.IReference => {
+    if (alias.value.size() === 1 && alias.value.objects.length === 1)
+      return application_object(options)(components)(alias.value.objects[0]!)(
+        nullable,
+      );
+
+    const key: string =
+      options.purpose === "ajv"
+        ? alias.name
+        : `${alias.name}${nullable ? ".Nullable" : ""}`;
+    const $id: string = `${JSON_COMPONENTS_PREFIX}/schemas/${key}`;
+
+    // TEMPORARY ASSIGNMENT
+    if (components.schemas?.[key] === undefined) {
+      components.schemas ??= {};
+      components.schemas[key] = {
+        $id: key,
+      } as any;
+
+      // GENERATE SCHEM
+      const schema: IJsonSchema = application_schema(options)(blockNever)(
+        components,
+      )(alias.value)({
+        deprecated:
+          alias.jsDocTags.some((tag) => tag.name === "deprecated") || undefined,
+        title: (() => {
+          const info: IJsDocTagInfo | undefined = alias.jsDocTags.find(
+            (tag) => tag.name === "title",
+          );
+          return info?.text?.length
+            ? CommentFactory.merge(info.text)
+            : undefined;
+        })(),
+        description: alias.description ?? undefined,
+        "x-typia-jsDocTags": alias.jsDocTags.length
+          ? alias.jsDocTags
+          : undefined,
+      })!;
+      components.schemas ??= {};
+      components.schemas[key] = {
+        $id: options.purpose === "ajv" ? $id : undefined,
+        $recursiveAnchor:
+          (options.purpose === "ajv" && alias.recursive) || undefined,
+        ...schema,
+      };
+    }
+    return { $ref: $id };
+  };

package/src/programmers/internal/application_array.ts

@@ -1,59 +1,59 @@
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_schema } from "./application_schema";
-
-/**
- * @internal
- */
-export const application_array =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (components: IJsonComponents) =>
-  (array: MetadataArray) =>
-  (attribute: IJsonSchema.IAttribute): IJsonSchema.IArray[] => {
-    // BASE SCHEMA
-    const items: IJsonSchema = application_schema(options)(false)(components)(
-      array.type.value,
-    )(attribute);
-    const base: IJsonSchema.IArray = {
-      ...attribute,
-      type: "array",
-      items: null!,
-    };
-    const out = (schema: IJsonSchema.IArray) => {
-      schema.items = items;
-      return schema;
-    };
-    if (array.tags.length === 0) return [out(base)];
-
-    // CONSIDER TYPE TAGS
-    const union: IJsonSchema.IArray[] = array.tags.map(
-      (row) => application_array_tags({ ...base })(row)!,
-    );
-    const map: Map<string, IJsonSchema.IArray> = new Map(
-      union.map((u) => [JSON.stringify(u), u]),
-    );
-    return [...map.values()].map((s) => out(s));
-  };
-
-const application_array_tags =
-  (schema: IJsonSchema.IArray) =>
-  (row: IMetadataTypeTag[]): IJsonSchema.IArray => {
-    for (const tag of row.slice().sort((a, b) => a.kind.localeCompare(b.kind)))
-      if (tag.kind === "minItems" && typeof tag.value === "number")
-        schema.minItems = tag.value;
-      else if (tag.kind === "maxItems" && typeof tag.value === "number")
-        schema.maxItems = tag.value;
-    schema["x-typia-typeTags"] = row.map((tag) => ({
-      target: tag.target,
-      name: tag.name,
-      kind: tag.kind,
-      value: tag.value,
-      validate: tag.validate,
-      exclusive: tag.exclusive,
-    }));
-    return schema;
-  };
+import { IJsonComponents } from "../../schemas/json/IJsonComponents";
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
+import { application_schema } from "./application_schema";
+
+/**
+ * @internal
+ */
+export const application_array =
+  (options: JsonApplicationProgrammer.IOptions) =>
+  (components: IJsonComponents) =>
+  (array: MetadataArray) =>
+  (attribute: IJsonSchema.IAttribute): IJsonSchema.IArray[] => {
+    // BASE SCHEMA
+    const items: IJsonSchema = application_schema(options)(false)(components)(
+      array.type.value,
+    )(attribute);
+    const base: IJsonSchema.IArray = {
+      ...attribute,
+      type: "array",
+      items: null!,
+    };
+    const out = (schema: IJsonSchema.IArray) => {
+      schema.items = items;
+      return schema;
+    };
+    if (array.tags.length === 0) return [out(base)];
+
+    // CONSIDER TYPE TAGS
+    const union: IJsonSchema.IArray[] = array.tags.map(
+      (row) => application_array_tags({ ...base })(row)!,
+    );
+    const map: Map<string, IJsonSchema.IArray> = new Map(
+      union.map((u) => [JSON.stringify(u), u]),
+    );
+    return [...map.values()].map((s) => out(s));
+  };
+
+const application_array_tags =
+  (schema: IJsonSchema.IArray) =>
+  (row: IMetadataTypeTag[]): IJsonSchema.IArray => {
+    for (const tag of row.slice().sort((a, b) => a.kind.localeCompare(b.kind)))
+      if (tag.kind === "minItems" && typeof tag.value === "number")
+        schema.minItems = tag.value;
+      else if (tag.kind === "maxItems" && typeof tag.value === "number")
+        schema.maxItems = tag.value;
+    schema["x-typia-typeTags"] = row.map((tag) => ({
+      target: tag.target,
+      name: tag.name,
+      kind: tag.kind,
+      value: tag.value,
+      validate: tag.validate,
+      exclusive: tag.exclusive,
+    }));
+    return schema;
+  };

package/src/programmers/internal/application_boolean.ts

@@ -1,30 +1,30 @@
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { IJsonSchema } from "../../module";
-import { application_default } from "./application_default";
-
-/**
- * @internal
- */
-export const application_boolean =
-  (atomic: MetadataAtomic) =>
-  (attribute: IJsonSchema.IAttribute): IJsonSchema.IBoolean[] => {
-    const base: IJsonSchema.IBoolean = {
-      ...attribute,
-      default: application_default(attribute)(
-        (alias) => alias === "true" || alias === "false",
-      )((str) => Boolean(str)),
-      type: "boolean",
-    };
-    const defaultTags: IMetadataTypeTag[] = atomic.tags
-      .filter((row) => row.some((tag) => tag.kind === "default"))
-      .map((row) => row.filter((tag) => tag.kind === "default"))
-      .flat();
-    if (defaultTags.length === 0) return [base];
-    return defaultTags.map((tag) => ({
-      ...base,
-      default: tag.value,
-      "x-typia-typeTags": defaultTags,
-    }));
-  };
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IJsonSchema } from "../../module";
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_boolean =
+  (atomic: MetadataAtomic) =>
+  (attribute: IJsonSchema.IAttribute): IJsonSchema.IBoolean[] => {
+    const base: IJsonSchema.IBoolean = {
+      ...attribute,
+      default: application_default(attribute)(
+        (alias) => alias === "true" || alias === "false",
+      )((str) => Boolean(str)),
+      type: "boolean",
+    };
+    const defaultTags: IMetadataTypeTag[] = atomic.tags
+      .filter((row) => row.some((tag) => tag.kind === "default"))
+      .map((row) => row.filter((tag) => tag.kind === "default"))
+      .flat();
+    if (defaultTags.length === 0) return [base];
+    return defaultTags.map((tag) => ({
+      ...base,
+      default: tag.value,
+      "x-typia-typeTags": defaultTags,
+    }));
+  };

package/src/programmers/internal/application_constant.ts

@@ -1,26 +1,26 @@
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { MetadataConstant } from "../../schemas/metadata/MetadataConstant";
-
-import { application_default } from "./application_default";
-
-/**
- * @internal
- */
-export const application_constant =
-  (constant: MetadataConstant) =>
-  (attribute: IJsonSchema.IAttribute): IJsonSchema.IEnumeration<any> => ({
-    ...attribute,
-    type: constant.type,
-    enum: constant.values as any,
-    default: application_default(attribute)((alias) =>
-      constant.values.some((v) => v.toString() === alias),
-    )(
-      constant.type === "string"
-        ? (str) => str
-        : constant.type === "number"
-        ? (str) => Number(str)
-        : constant.type === "boolean"
-        ? (str) => Boolean(str)
-        : (str) => BigInt(str) as any,
-    ),
-  });
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { MetadataConstant } from "../../schemas/metadata/MetadataConstant";
+
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_constant =
+  (constant: MetadataConstant) =>
+  (attribute: IJsonSchema.IAttribute): IJsonSchema.IEnumeration<any> => ({
+    ...attribute,
+    type: constant.type,
+    enum: constant.values as any,
+    default: application_default(attribute)((alias) =>
+      constant.values.some((v) => v.toString() === alias),
+    )(
+      constant.type === "string"
+        ? (str) => str
+        : constant.type === "number"
+        ? (str) => Number(str)
+        : constant.type === "boolean"
+        ? (str) => Boolean(str)
+        : (str) => BigInt(str) as any,
+    ),
+  });

package/src/programmers/internal/application_default.ts

@@ -1,17 +1,17 @@
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-
-/**
- * @internal
- */
-export const application_default =
-  (attribute: IJsonSchema.IAttribute) =>
-  (pred: (value: string) => boolean) =>
-  <T>(caster: (str: string) => T): T | undefined => {
-    const defaults = (attribute["x-typia-jsDocTags"] ?? []).filter(
-      (tag) => tag.name === "default",
-    );
-    for (const alias of defaults)
-      if (alias.text?.length && pred(alias.text[0]!.text))
-        return caster(alias.text[0]!.text);
-    return undefined;
-  };
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+
+/**
+ * @internal
+ */
+export const application_default =
+  (attribute: IJsonSchema.IAttribute) =>
+  (pred: (value: string) => boolean) =>
+  <T>(caster: (str: string) => T): T | undefined => {
+    const defaults = (attribute["x-typia-jsDocTags"] ?? []).filter(
+      (tag) => tag.name === "default",
+    );
+    for (const alias of defaults)
+      if (alias.text?.length && pred(alias.text[0]!.text))
+        return caster(alias.text[0]!.text);
+    return undefined;
+  };

package/src/programmers/internal/application_default_string.ts

@@ -1,33 +1,33 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IJsonSchema } from "../../module";
-import { application_default } from "./application_default";
-
-/**
- * @internal
- */
-export const application_default_string =
-  (meta: Metadata) =>
-  (attribute: IJsonSchema.IAttribute) =>
-  (schema: IJsonSchema.IString) =>
-    application_default(attribute)((str) => {
-      const conditions: boolean[] = [];
-
-      // OTHER ATOMIC TYPES
-      if (meta.atomics.find((a) => a.type === "number" || a.type === "bigint"))
-        conditions.push(Number.isNaN(Number(str)));
-      if (meta.atomics.find((a) => a.type === "boolean"))
-        conditions.push(str !== "true" && str !== "false");
-      for (const constant of meta.constants)
-        for (const value of constant.values)
-          conditions.push(str !== value.toString());
-
-      // CONSIDER TAGS
-      if (schema.minLength !== undefined)
-        conditions.push(str.length >= schema.minLength);
-      if (schema.maxLength !== undefined)
-        conditions.push(str.length <= schema.maxLength);
-      if (schema.pattern !== undefined)
-        conditions.push(new RegExp(schema.pattern).test(str));
-      return conditions.every((c) => c);
-    })((str) => str);
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IJsonSchema } from "../../module";
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_default_string =
+  (meta: Metadata) =>
+  (attribute: IJsonSchema.IAttribute) =>
+  (schema: IJsonSchema.IString) =>
+    application_default(attribute)((str) => {
+      const conditions: boolean[] = [];
+
+      // OTHER ATOMIC TYPES
+      if (meta.atomics.find((a) => a.type === "number" || a.type === "bigint"))
+        conditions.push(Number.isNaN(Number(str)));
+      if (meta.atomics.find((a) => a.type === "boolean"))
+        conditions.push(str !== "true" && str !== "false");
+      for (const constant of meta.constants)
+        for (const value of constant.values)
+          conditions.push(str !== value.toString());
+
+      // CONSIDER TAGS
+      if (schema.minLength !== undefined)
+        conditions.push(str.length >= schema.minLength);
+      if (schema.maxLength !== undefined)
+        conditions.push(str.length <= schema.maxLength);
+      if (schema.pattern !== undefined)
+        conditions.push(new RegExp(schema.pattern).test(str));
+      return conditions.every((c) => c);
+    })((str) => str);