typia 7.0.0-dev.20241002-2 → 7.0.0-dev.20241005

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -20,9 +20,10 @@ import { Atomic } from "../../typings/Atomic";
 
 import { Escaper } from "../../utils/Escaper";
 import { MapUtil } from "../../utils/MapUtil";
+import { StringUtil } from "../../utils/StringUtil";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpHeadersProgrammer {
@@ -30,7 +31,7 @@ export namespace HttpHeadersProgrammer {
 
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -49,14 +50,15 @@ export namespace HttpHeadersProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.http.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: props.functor.method,
+        errors: result.errors,
+      });
 
     // DO TRANSFORM
     const object: MetadataObject = result.data.objects[0]!;
     const statements: ts.Statement[] = decode_object({
-      importer: props.importer,
+      context: props.context,
       object,
     });
     return {
@@ -95,22 +97,22 @@ export namespace HttpHeadersProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };
 
   export const validate = (
-    meta: Metadata,
+    metadata: Metadata,
     explore: MetadataFactory.IExplore,
   ): string[] => {
     const errors: string[] = [];
@@ -118,10 +120,10 @@ export namespace HttpHeadersProgrammer {
 
     if (explore.top === true) {
       // TOP MUST BE ONLY OBJECT
-      if (meta.objects.length !== 1 || meta.bucket() !== 1)
+      if (metadata.objects.length !== 1 || metadata.bucket() !== 1)
         insert("only one object type is allowed.");
-      if (meta.nullable === true) insert("headers cannot be null.");
-      if (meta.isRequired() === false) insert("headers cannot be null.");
+      if (metadata.nullable === true) insert("headers cannot be null.");
+      if (metadata.isRequired() === false) insert("headers cannot be null.");
     } else if (
       explore.nested !== null &&
       explore.nested instanceof MetadataArrayType
@@ -129,17 +131,19 @@ export namespace HttpHeadersProgrammer {
       //----
       // ARRAY
       //----
-      const atomics = HttpMetadataUtil.atomics(meta);
+      const atomics = HttpMetadataUtil.atomics(metadata);
       const expected: number =
-        meta.atomics.length +
-        meta.templates.length +
-        meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+        metadata.atomics.length +
+        metadata.templates.length +
+        metadata.constants
+          .map((c) => c.values.length)
+          .reduce((a, b) => a + b, 0);
       if (atomics.size > 1) insert("union type is not allowed in array.");
-      if (meta.size() !== expected)
+      if (metadata.size() !== expected)
         insert("only atomic or constant types are allowed in array.");
-      if (meta.nullable === true)
+      if (metadata.nullable === true)
         insert("nullable type is not allowed in array.");
-      if (meta.isRequired() === false)
+      if (metadata.isRequired() === false)
         insert("optional type is not allowed in array.");
     } else if (explore.object && explore.property !== null) {
       //----
@@ -149,25 +153,26 @@ export namespace HttpHeadersProgrammer {
       if (typeof explore.property === "object")
         insert("dynamic property is not allowed.");
       // DO NOT ALLOW TUPLE TYPE
-      if (meta.tuples.length) insert("tuple type is not allowed.");
+      if (metadata.tuples.length) insert("tuple type is not allowed.");
       // DO NOT ALLOW UNION TYPE
-      if (HttpMetadataUtil.isUnion(meta)) insert("union type is not allowed.");
+      if (HttpMetadataUtil.isUnion(metadata))
+        insert("union type is not allowed.");
       // DO NOT ALLOW NESTED OBJECT
       if (
-        meta.objects.length ||
-        meta.sets.length ||
-        meta.maps.length ||
-        meta.natives.length
+        metadata.objects.length ||
+        metadata.sets.length ||
+        metadata.maps.length ||
+        metadata.natives.length
       )
         insert("nested object type is not allowed.");
       // DO NOT ALLOW NULLABLE
-      if (meta.nullable === true) insert("nullable type is not allowed.");
+      if (metadata.nullable === true) insert("nullable type is not allowed.");
 
       //----
       // SPECIAL KEY NAMES
       //----
       const isArray: boolean =
-        meta.arrays.length >= 1 || meta.tuples.length >= 1;
+        metadata.arrays.length >= 1 || metadata.tuples.length >= 1;
       // SET-COOKIE MUST BE ARRAY
       if (
         typeof explore.property === "string" &&
@@ -202,7 +207,7 @@ export namespace HttpHeadersProgrammer {
   };
 
   const decode_object = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     object: MetadataObject;
   }): ts.Statement[] => {
     const output: ts.Identifier = ts.factory.createIdentifier("output");
@@ -218,7 +223,7 @@ export namespace HttpHeadersProgrammer {
             )
               optionals.push(p.key.constants[0]!.values[0]!.value as string);
             return decode_regular_property({
-              importer: props.importer,
+              context: props.context,
               property: p,
             });
           }),
@@ -244,7 +249,7 @@ export namespace HttpHeadersProgrammer {
   };
 
   const decode_regular_property = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     property: MetadataProperty;
   }): ts.PropertyAssignment => {
     const key: string = props.property.key.constants[0]!.values[0]!
@@ -278,14 +283,14 @@ export namespace HttpHeadersProgrammer {
         ? key === "set-cookie"
           ? input
           : decode_array({
-              importer: props.importer,
+              context: props.context,
               type,
               key,
               value,
               input,
             })
         : decode_value({
-            importer: props.importer,
+            context: props.context,
             type,
             input,
           }),
@@ -293,25 +298,47 @@ export namespace HttpHeadersProgrammer {
   };
 
   const decode_value = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     type: Atomic.Literal;
     input: ts.Expression;
   }) =>
     props.type === "string"
       ? props.input
       : ts.factory.createCallExpression(
-          props.importer.use(props.type),
+          props.context.importer.internal(
+            `httpHeaderRead${StringUtil.capitalize(props.type)}`,
+          ),
           undefined,
           [props.input],
         );
 
   const decode_array = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     type: Atomic.Literal;
     key: string;
     value: Metadata;
     input: ts.Expression;
   }) => {
+    const reader =
+      props.type === "string"
+        ? ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("str")],
+            undefined,
+            undefined,
+            ts.factory.createCallExpression(
+              IdentifierFactory.access(
+                ts.factory.createIdentifier("str"),
+                "trim",
+              ),
+              undefined,
+              undefined,
+            ),
+          )
+        : props.context.importer.internal(
+            `httpHeaderRead${StringUtil.capitalize(props.type)}`,
+          );
     const split: ts.CallChain = ts.factory.createCallChain(
       ts.factory.createPropertyAccessChain(
         ts.factory.createCallChain(
@@ -333,7 +360,7 @@ export namespace HttpHeadersProgrammer {
       ),
       undefined,
       undefined,
-      [props.importer.use(props.type)],
+      [reader],
     );
     return ts.factory.createConditionalExpression(
       ExpressionFactory.isArray(props.input),
@@ -341,7 +368,7 @@ export namespace HttpHeadersProgrammer {
       ts.factory.createCallExpression(
         IdentifierFactory.access(props.input, "map"),
         undefined,
-        [props.importer.use(props.type)],
+        [reader],
       ),
       undefined,
       props.value.isRequired() === false

package/src/programmers/http/HttpIsFormDataProgrammer.ts

@@ -8,13 +8,13 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
 
 export namespace HttpIsFormDataProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -92,16 +92,16 @@ export namespace HttpIsFormDataProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/http/HttpIsHeadersProgrammer.ts

@@ -8,13 +8,13 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
 
 export namespace HttpIsHeadersProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -92,16 +92,16 @@ export namespace HttpIsHeadersProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/http/HttpIsQueryProgrammer.ts

@@ -8,7 +8,7 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
 
 export namespace HttpIsQueryProgrammer {
@@ -18,7 +18,7 @@ export namespace HttpIsQueryProgrammer {
 
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
     allowOptional: boolean;
@@ -97,17 +97,17 @@ export namespace HttpIsQueryProgrammer {
   };
 
   export const write = (props: IProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
       allowOptional: !!props.allowOptional,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -11,8 +11,9 @@ import { Metadata } from "../../schemas/metadata/Metadata";
 import { IProgrammerProps } from "../../transformers/IProgrammerProps";
 import { TransformerError } from "../../transformers/TransformerError";
 
+import { StringUtil } from "../../utils/StringUtil";
+
 import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
 import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpParameterProgrammer {
@@ -30,12 +31,12 @@ export namespace HttpParameterProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(props.modulo.getText())(result.errors);
+      throw TransformerError.from({
+        code: props.modulo.getText(),
+        errors: result.errors,
+      });
 
     const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
-    const importer: FunctionImporter = new FunctionImporter(
-      props.modulo.getText(),
-    );
     const block: ts.Statement[] = [
       StatementFactory.constant({
         name: "assert",
@@ -56,7 +57,9 @@ export namespace HttpParameterProgrammer {
       StatementFactory.constant({
         name: "value",
         value: ts.factory.createCallExpression(
-          importer.use(atomic),
+          props.context.importer.internal(
+            `httpParameterRead${StringUtil.capitalize(atomic)}`,
+          ),
           undefined,
           [ts.factory.createIdentifier("input")],
         ),
@@ -87,10 +90,7 @@ export namespace HttpParameterProgrammer {
           }),
       ),
       undefined,
-      ts.factory.createBlock(
-        [...importer.declare(props.modulo), ...block],
-        true,
-      ),
+      ts.factory.createBlock(block, true),
     );
   };
 

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -18,9 +18,10 @@ import { TransformerError } from "../../transformers/TransformerError";
 import { Atomic } from "../../typings/Atomic";
 
 import { Escaper } from "../../utils/Escaper";
+import { StringUtil } from "../../utils/StringUtil";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpQueryProgrammer {
@@ -32,7 +33,7 @@ export namespace HttpQueryProgrammer {
 
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     allowOptional: boolean;
     type: ts.Type;
     name: string | undefined;
@@ -53,14 +54,15 @@ export namespace HttpQueryProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.http.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: props.functor.method,
+        errors: result.errors,
+      });
 
     // DO TRANSFORM
     const object: MetadataObject = result.data.objects[0]!;
     const statements: ts.Statement[] = decode_object({
-      importer: props.importer,
+      context: props.context,
       object,
     });
     return {
@@ -99,17 +101,17 @@ export namespace HttpQueryProgrammer {
   };
 
   export const write = (props: IProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
       allowOptional: !!props.allowOptional,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };
@@ -180,7 +182,7 @@ export namespace HttpQueryProgrammer {
   };
 
   const decode_object = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     object: MetadataObject;
   }): ts.Statement[] => {
     const input: ts.Identifier = ts.factory.createIdentifier("input");
@@ -193,7 +195,7 @@ export namespace HttpQueryProgrammer {
           ts.factory.createToken(ts.SyntaxKind.EqualsToken),
           ts.factory.createAsExpression(
             ts.factory.createCallExpression(
-              props.importer.use("params"),
+              props.context.importer.internal("httpQueryParseURLSearchParams"),
               undefined,
               [input],
             ),
@@ -206,7 +208,7 @@ export namespace HttpQueryProgrammer {
         value: ts.factory.createObjectLiteralExpression(
           props.object.properties.map((p) =>
             decode_regular_property({
-              importer: props.importer,
+              context: props.context,
               property: p,
             }),
           ),
@@ -220,7 +222,7 @@ export namespace HttpQueryProgrammer {
   };
 
   const decode_regular_property = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     property: MetadataProperty;
   }): ts.PropertyAssignment => {
     const key: string = props.property.key.constants[0]!.values[0]!
@@ -247,7 +249,7 @@ export namespace HttpQueryProgrammer {
       Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
       isArray
         ? decode_array({
-            importer: props.importer,
+            context: props.context,
             metadata: value,
             input: ts.factory.createCallExpression(
               IdentifierFactory.access(
@@ -267,7 +269,7 @@ export namespace HttpQueryProgrammer {
                   undefined,
                   undefined,
                   decode_value({
-                    importer: props.importer,
+                    context: props.context,
                     type,
                     coalesce: false,
                     input: ts.factory.createIdentifier("elem"),
@@ -277,7 +279,7 @@ export namespace HttpQueryProgrammer {
             ),
           })
         : decode_value({
-            importer: props.importer,
+            context: props.context,
             type,
             coalesce: value.nullable === false && value.isRequired() === false,
             input: ts.factory.createCallExpression(
@@ -290,13 +292,15 @@ export namespace HttpQueryProgrammer {
   };
 
   const decode_value = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     type: Atomic.Literal;
     coalesce: boolean;
     input: ts.Expression;
   }) => {
     const call = ts.factory.createCallExpression(
-      props.importer.use(props.type),
+      props.context.importer.internal(
+        `httpQueryRead${StringUtil.capitalize(props.type)}`,
+      ),
       undefined,
       [props.input],
     );
@@ -310,13 +314,13 @@ export namespace HttpQueryProgrammer {
   };
 
   const decode_array = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     metadata: Metadata;
     input: ts.Expression;
   }): ts.Expression =>
     props.metadata.nullable || props.metadata.isRequired() === false
       ? ts.factory.createCallExpression(
-          props.importer.use("array"),
+          props.context.importer.internal("httpQueryReadArray"),
           undefined,
           [
             props.input,

package/src/programmers/http/HttpValidateFormDataProgrammer.ts

@@ -8,14 +8,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
 
 export namespace HttpValidateFormDataProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -74,16 +74,16 @@ export namespace HttpValidateFormDataProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/http/HttpValidateHeadersProgrammer.ts

@@ -8,14 +8,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
 
 export namespace HttpValidateHeadersProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -74,16 +74,16 @@ export namespace HttpValidateHeadersProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };