typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/http/HttpIsQueryProgrammer.ts

@@ -24,10 +24,18 @@ export namespace HttpIsQueryProgrammer {
           ),
         ],
         ts.factory.createUnionTypeNode([
-          ts.factory.createTypeReferenceNode(
-            `typia.Resolved<${
-              name ?? TypeFactory.getFullName(project.checker)(type)
-            }>`,
+          ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("Resolved"),
+            [
+              ts.factory.createTypeReferenceNode(
+                name ?? TypeFactory.getFullName(project.checker)(type),
+              ),
+            ],
+            false,
           ),
           ts.factory.createLiteralTypeNode(ts.factory.createNull()),
         ]),
@@ -45,7 +53,7 @@ export namespace HttpIsQueryProgrammer {
             })(modulo)(false)(type, name),
           ),
           StatementFactory.constant(
-            "query",
+            "decode",
             HttpQueryProgrammer.write({
               ...project,
               options: {
@@ -58,7 +66,7 @@ export namespace HttpIsQueryProgrammer {
           StatementFactory.constant(
             "output",
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier("query"),
+              ts.factory.createIdentifier("decode"),
               undefined,
               [ts.factory.createIdentifier("input")],
             ),

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -46,11 +46,9 @@ export namespace HttpParameterProgrammer {
         ),
         StatementFactory.constant(
           "value",
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(importer.use("ParameterReader"))(atomic),
-            undefined,
-            [ts.factory.createIdentifier("input")],
-          ),
+          ts.factory.createCallExpression(importer.use(atomic), undefined, [
+            ts.factory.createIdentifier("input"),
+          ]),
         ),
         ts.factory.createReturnStatement(
           ts.factory.createCallExpression(
@@ -74,7 +72,7 @@ export namespace HttpParameterProgrammer {
           name ?? TypeFactory.getFullName(project.checker)(type),
         ),
         undefined,
-        ts.factory.createBlock([...importer.declare(), ...block], true),
+        ts.factory.createBlock([...importer.declare(modulo), ...block], true),
       );
     };
 

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -57,13 +57,24 @@ export namespace HttpQueryProgrammer {
             ts.factory.createTypeReferenceNode(INPUT_TYPE),
           ),
         ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
-        ts.factory.createBlock([...importer.declare(), ...statements], true),
+        ts.factory.createBlock(
+          [...importer.declare(modulo), ...statements],
+          true,
+        ),
       );
     };
 
@@ -132,7 +143,7 @@ export namespace HttpQueryProgrammer {
             ts.factory.createToken(ts.SyntaxKind.EqualsToken),
             ts.factory.createAsExpression(
               ts.factory.createCallExpression(
-                IdentifierFactory.access(importer.use("QueryReader"))("params"),
+                importer.use("params"),
                 undefined,
                 [input],
               ),
@@ -158,24 +169,25 @@ export namespace HttpQueryProgrammer {
   const decode_regular_property =
     (importer: FunctionImporter) =>
     (property: MetadataProperty): ts.PropertyAssignment => {
-      const key: string = property.key.constants[0]!.values[0] as string;
+      const key: string = property.key.constants[0]!.values[0]!.value as string;
       const value: Metadata = property.value;
 
       const [type, isArray]: [Atomic.Literal, boolean] = value.atomics.length
         ? [value.atomics[0]!.type, false]
         : value.constants.length
-        ? [value.constants[0]!.type, false]
-        : value.templates.length
-        ? ["string", false]
-        : (() => {
-            const meta =
-              value.arrays[0]?.type.value ?? value.tuples[0]!.type.elements[0]!;
-            return meta.atomics.length
-              ? [meta.atomics[0]!.type, true]
-              : meta.templates.length
-              ? ["string", true]
-              : [meta.constants[0]!.type, true];
-          })();
+          ? [value.constants[0]!.type, false]
+          : value.templates.length
+            ? ["string", false]
+            : (() => {
+                const meta =
+                  value.arrays[0]?.type.value ??
+                  value.tuples[0]!.type.elements[0]!;
+                return meta.atomics.length
+                  ? [meta.atomics[0]!.type, true]
+                  : meta.templates.length
+                    ? ["string", true]
+                    : [meta.constants[0]!.type, true];
+              })();
       return ts.factory.createPropertyAssignment(
         Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
         isArray
@@ -221,7 +233,7 @@ export namespace HttpQueryProgrammer {
     (onlyUndefindable: boolean) =>
     (value: ts.Expression) => {
       const call = ts.factory.createCallExpression(
-        IdentifierFactory.access(importer.use("QueryReader"))(type),
+        importer.use(type),
         undefined,
         [value],
       );
@@ -239,15 +251,11 @@ export namespace HttpQueryProgrammer {
     (value: Metadata) =>
     (expression: ts.Expression): ts.Expression =>
       value.nullable || value.isRequired() === false
-        ? ts.factory.createCallExpression(
-            IdentifierFactory.access(importer.use("QueryReader"))("array"),
-            undefined,
-            [
-              expression,
-              value.nullable
-                ? ts.factory.createNull()
-                : ts.factory.createIdentifier("undefined"),
-            ],
-          )
+        ? ts.factory.createCallExpression(importer.use("array"), undefined, [
+            expression,
+            value.nullable
+              ? ts.factory.createNull()
+              : ts.factory.createIdentifier("undefined"),
+          ])
         : expression;
 }

package/src/programmers/http/HttpValidateFormDataProgrammer.ts

@@ -0,0 +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 { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
+
+export namespace HttpValidateFormDataProgrammer {
+  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("FormData"),
+          ),
+        ],
+        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(
+            "decode",
+            HttpFormDataProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("decode"),
+              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/http/HttpValidateHeadersProgrammer.ts

@@ -44,7 +44,7 @@ export namespace HttpValidateHeadersProgrammer {
             })(modulo)(false)(type, name),
           ),
           StatementFactory.constant(
-            "headers",
+            "decode",
             HttpHeadersProgrammer.write({
               ...project,
               options: {
@@ -57,7 +57,7 @@ export namespace HttpValidateHeadersProgrammer {
           StatementFactory.constant(
             "output",
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier("headers"),
+              ts.factory.createIdentifier("decode"),
               undefined,
               [ts.factory.createIdentifier("input")],
             ),

package/src/programmers/http/HttpValidateQueryProgrammer.ts

@@ -42,7 +42,7 @@ export namespace HttpValidateQueryProgrammer {
             })(modulo)(false)(type, name),
           ),
           StatementFactory.constant(
-            "query",
+            "decode",
             HttpQueryProgrammer.write({
               ...project,
               options: {
@@ -55,7 +55,7 @@ export namespace HttpValidateQueryProgrammer {
           StatementFactory.constant(
             "output",
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier("query"),
+              ts.factory.createIdentifier("decode"),
               undefined,
               [ts.factory.createIdentifier("input")],
             ),

package/src/programmers/internal/application_array.ts

@@ -1,59 +1,36 @@
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_schema } from "./application_schema";
+import { application_plugin } from "./application_plugin";
 
 /**
  * @internal
  */
 export const application_array =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (components: IJsonComponents) =>
-  (array: MetadataArray): IJsonSchema.IArray[] => {
-    // BASE SCHEMA
-    const items: IJsonSchema = application_schema(options)(false)(components)(
-      array.type.value,
-    )({});
-    const base: IJsonSchema.IArray = {
-      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(options)({ ...base })(row)!,
-    );
-    const map: Map<string, IJsonSchema.IArray> = new Map(
-      union.map((u) => [JSON.stringify(u), u]),
+  <Version extends "3.0" | "3.1">(
+    generator: (value: Metadata) => Schema<Version>,
+  ) =>
+  (array: MetadataArray): ArraySchema<Version>[] =>
+    application_plugin(
+      {
+        type: "array",
+        items: generator(array.type.value),
+      } satisfies ArraySchema<Version>,
+      array.tags,
     );
-    return [...map.values()].map((s) => out(s));
-  };
 
-const application_array_tags =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (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;
-    if (options.surplus)
-      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;
-  };
+/**
+ * @internal
+ */
+type ArraySchema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IArray
+  : OpenApi.IJsonSchema.IArray;
+
+/**
+ * @internal
+ */
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema
+  : OpenApi.IJsonSchema;

package/src/programmers/internal/application_boolean.ts

@@ -1,35 +1,25 @@
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
 import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 
-import { IJsonSchema } from "../../module";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_default } from "./application_default";
+import { application_plugin } from "./application_plugin";
 
 /**
  * @internal
  */
-export const application_boolean =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (atomic: MetadataAtomic) =>
-  (attribute: IJsonSchema.IAttribute): IJsonSchema.IBoolean[] => {
-    const base: IJsonSchema.IBoolean = {
-      default: application_default(attribute)(
-        (alias) => alias === "true" || alias === "false",
-      )((str) => Boolean(str)),
+export const application_boolean = <Version extends "3.0" | "3.1">(
+  atomic: MetadataAtomic,
+): Schema<Version>[] =>
+  application_plugin(
+    {
       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,
-      ...(options.surplus
-        ? {
-            "x-typia-typeTags": defaultTags,
-          }
-        : {}),
-    }));
-  };
+    } satisfies Schema<Version>,
+    atomic.tags,
+  );
+
+/**
+ * @internal
+ */
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IBoolean
+  : OpenApi.IJsonSchema.IBoolean;

package/src/programmers/internal/application_escaped.ts

@@ -1,26 +1,25 @@
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
 
-import { IJsonComponents, IJsonSchema } from "../../module";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_schema } from "./application_schema";
-
+/**
+ * @internal
+ */
 export const application_escaped =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  <BlockNever extends boolean>(blockNever: BlockNever) =>
-  (components: IJsonComponents) =>
-  (resolved: MetadataEscaped): IJsonSchema[] => {
-    const output = application_schema(options)(blockNever)(components)(
-      resolved.returns,
-    )({});
+  <Version extends "3.0" | "3.1">(
+    generator: (meta: Metadata) => Schema<Version>,
+  ) =>
+  (resolved: MetadataEscaped): Schema<Version>[] => {
+    const output: Schema<Version> | null = generator(resolved.returns);
     if (output === null) return [];
 
     if (is_date(new Set())(resolved.original)) {
-      const string: IJsonSchema.IString | undefined = is_string(output)
+      const string: StringSchema<Version> | undefined = is_string(output)
         ? output
         : is_one_of(output)
-        ? output.oneOf.find(is_string)
-        : undefined;
+          ? output.oneOf.find(is_string)
+          : undefined;
       if (
         string !== undefined &&
         string.format !== "date" &&
@@ -31,12 +30,25 @@ export const application_escaped =
     return is_one_of(output) ? output.oneOf : [output];
   };
 
-const is_string = (elem: IJsonSchema): elem is IJsonSchema.IString =>
-  (elem as IJsonSchema.IString).type === "string";
+/**
+ * @internal
+ */
+const is_string = <Version extends "3.0" | "3.1">(
+  elem: Schema<Version>,
+): elem is StringSchema<Version> =>
+  (elem as StringSchema<Version>).type === "string";
 
-const is_one_of = (elem: IJsonSchema): elem is IJsonSchema.IOneOf =>
-  Array.isArray((elem as IJsonSchema.IOneOf).oneOf);
+/**
+ * @internal
+ */
+const is_one_of = <Version extends "3.0" | "3.1">(
+  elem: Schema<Version>,
+): elem is OneOfSchema<Version> =>
+  Array.isArray((elem as OneOfSchema<Version>).oneOf);
 
+/**
+ * @internal
+ */
 const is_date =
   (visited: Set<Metadata>) =>
   (meta: Metadata): boolean => {
@@ -50,3 +62,13 @@ const is_date =
       meta.aliases.some((alias) => is_date(visited)(alias.value))
     );
   };
+
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema
+  : OpenApi.IJsonSchema;
+type StringSchema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IString
+  : OpenApi.IJsonSchema.IString;
+type OneOfSchema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IOneOf
+  : OpenApi.IJsonSchema.IOneOf;

package/src/programmers/internal/application_number.ts

@@ -1,97 +1,25 @@
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
 
-import { IJsonSchema } from "../../module";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_default } from "./application_default";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 
-type Schema = IJsonSchema.INumber | IJsonSchema.IInteger;
+import { application_plugin } from "./application_plugin";
 
 /**
  * @internal
  */
-export const application_number =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (atomic: MetadataAtomic) =>
-  (attribute: IJsonSchema.IAttribute): Array<Schema> => {
-    // BASE CONFIGURATION
-    const base: Schema = {
+export const application_number = <Version extends "3.0" | "3.1">(
+  atomic: MetadataAtomic,
+): Schema<Version>[] =>
+  application_plugin(
+    {
       type: "number",
-    };
-    const out = (schema: Schema) => {
-      schema.default ??= application_default(attribute)((str) => {
-        const value: number = Number(str);
-        const conditions: boolean[] = [!Number.isNaN(value)];
-        if (schema.minimum !== undefined)
-          if (schema.exclusiveMinimum === true)
-            conditions.push(value > schema.minimum);
-          else conditions.push(value >= schema.minimum);
-        if (schema.maximum !== undefined)
-          if (schema.exclusiveMaximum === true)
-            conditions.push(value < schema.maximum);
-          else conditions.push(value <= schema.maximum);
-        if (schema.multipleOf !== undefined)
-          conditions.push(value % schema.multipleOf === 0);
-        return conditions.every((cond) => cond);
-      })((str) => Number(str));
-      return schema;
-    };
-    if (atomic.tags.length === 0) return [out(base)];
-
-    // CONSIDER TYPE TAGS
-    const union: Schema[] = atomic.tags.map(
-      (row) => application_number_tags(options)({ ...base })(row)!,
-    );
-    const map: Map<string, Schema> = new Map(
-      union.map((u) => [JSON.stringify(u), u]),
-    );
-    return [...map.values()].map((s) => out(s));
-  };
+    } satisfies Schema<Version>,
+    atomic.tags,
+  );
 
-const application_number_tags =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (base: Schema) =>
-  (row: IMetadataTypeTag[]): Schema => {
-    for (const tag of row
-      .slice()
-      .sort((a, b) => a.kind.localeCompare(b.kind))) {
-      if (
-        tag.kind === "type" &&
-        (tag.value === "int32" ||
-          tag.value === "uint32" ||
-          tag.value === "int64" ||
-          tag.value === "uint64")
-      )
-        base.type = "integer";
-      else if (tag.kind === "minimum" && typeof tag.value === "number")
-        base.minimum = tag.value;
-      else if (tag.kind === "maximum" && typeof tag.value === "number")
-        base.maximum = tag.value;
-      else if (
-        tag.kind === "exclusiveMinimum" &&
-        typeof tag.value === "number"
-      ) {
-        base.minimum = tag.value;
-        base.exclusiveMinimum = true;
-      } else if (
-        tag.kind === "exclusiveMaximum" &&
-        typeof tag.value === "number"
-      ) {
-        base.maximum = tag.value;
-        base.exclusiveMaximum = true;
-      } else if (tag.kind === "multipleOf" && typeof tag.value === "number")
-        base.multipleOf = tag.value;
-      else if (tag.kind === "default" && typeof tag.value === "number")
-        base.default = tag.value;
-    }
-    if (options.surplus)
-      base["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 base;
-  };
+/**
+ * @internal
+ */
+type Schema<Version extends "3.0" | "3.1"> = Version extends "3.0"
+  ? OpenApiV3.IJsonSchema.IInteger | OpenApiV3.IJsonSchema.INumber
+  : OpenApi.IJsonSchema.IInteger | OpenApi.IJsonSchema.INumber;

package/src/programmers/internal/application_plugin.ts

@@ -0,0 +1,19 @@
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+
+/**
+ * @internal
+ */
+export const application_plugin = <Schema extends object>(
+  schema: Schema,
+  tags: IMetadataTypeTag[][],
+): Schema[] => {
+  const plugins: IMetadataTypeTag[][] = tags
+    .map((row) => row.filter((t) => t.schema !== undefined))
+    .filter((row) => row.length !== 0);
+  if (tags.length === 0) return [schema];
+  return plugins.map((row) => {
+    const base: Schema = { ...schema };
+    for (const tag of row) Object.assign(base, tag.schema);
+    return base;
+  });
+};