typia 5.3.11 → 6.0.0-dev.20240118

package/src/notations.ts

@@ -1,5 +1,3 @@
-import { Namespace } from "./functional/Namespace";
-
 import { CamelCase } from "./CamelCase";
 import { IValidation } from "./IValidation";
 import { PascalCase } from "./PascalCase";
@@ -41,7 +39,6 @@ export function camel<T>(input: T): CamelCase<T>;
 export function camel(): never {
   return halt("camel");
 }
-Object.assign(camel, Namespace.notations.camel("camel"));
 
 /**
  * Converts to camel case with type assertion.
@@ -77,8 +74,6 @@ export function assertCamel<T>(input: unknown): CamelCase<T>;
 export function assertCamel(): never {
   return halt("assertCamel");
 }
-Object.assign(assertCamel, Namespace.notations.camel("assertCamel"));
-Object.assign(assertCamel, Namespace.assert("notations.assertCamel"));
 
 /**
  * Converts to camel case with type checking.
@@ -114,8 +109,6 @@ export function isCamel<T>(input: unknown): CamelCase<T> | null;
 export function isCamel(): never {
   return halt("isCamel");
 }
-Object.assign(isCamel, Namespace.notations.camel("isCamel"));
-Object.assign(isCamel, Namespace.is());
 
 /**
  * Converts to camel case with type validation.
@@ -155,8 +148,6 @@ export function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;
 export function validateCamel(): never {
   return halt("validateCamel");
 }
-Object.assign(validateCamel, Namespace.notations.camel("validateCamel"));
-Object.assign(validateCamel, Namespace.validate());
 
 /* -----------------------------------------------------------
     PASCAL CASE
@@ -188,7 +179,6 @@ export function pascal<T>(input: T): PascalCase<T>;
 export function pascal(): never {
   return halt("pascal");
 }
-Object.assign(pascal, Namespace.notations.pascal("pascal"));
 
 /**
  * Converts to pascal case with type assertion.
@@ -224,8 +214,6 @@ export function assertPascal<T>(input: unknown): PascalCase<T>;
 export function assertPascal(): never {
   return halt("assertPascal");
 }
-Object.assign(assertPascal, Namespace.notations.pascal("assertPascal"));
-Object.assign(assertPascal, Namespace.assert("notations.assertPascal"));
 
 /**
  * Converts to pascal case with type checking.
@@ -261,8 +249,6 @@ export function isPascal<T>(input: unknown): PascalCase<T> | null;
 export function isPascal(): never {
   return halt("isPascal");
 }
-Object.assign(isPascal, Namespace.notations.pascal("isPascal"));
-Object.assign(isPascal, Namespace.is());
 
 /**
  * Converts to pascal case with type validation.
@@ -302,8 +288,6 @@ export function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;
 export function validatePascal(): never {
   return halt("validatePascal");
 }
-Object.assign(validatePascal, Namespace.notations.pascal("validatePascal"));
-Object.assign(validatePascal, Namespace.validate());
 
 /* -----------------------------------------------------------
     SNAKE CASE
@@ -335,7 +319,6 @@ export function snake<T>(input: T): SnakeCase<T>;
 export function snake(): never {
   return halt("snake");
 }
-Object.assign(snake, Namespace.notations.snake("snake"));
 
 /**
  * Converts to snake case with type assertion.
@@ -371,8 +354,6 @@ export function assertSnake<T>(input: unknown): SnakeCase<T>;
 export function assertSnake(): never {
   return halt("assertSnake");
 }
-Object.assign(assertSnake, Namespace.notations.snake("assertSnake"));
-Object.assign(assertSnake, Namespace.assert("notations.assertSnake"));
 
 /**
  * Converts to snake case with type checking.
@@ -408,8 +389,6 @@ export function isSnake<T>(input: unknown): SnakeCase<T> | null;
 export function isSnake(): never {
   return halt("isSnake");
 }
-Object.assign(isSnake, Namespace.notations.snake("isSnake"));
-Object.assign(isSnake, Namespace.is());
 
 /**
  * Converts to snake case with type validation.
@@ -449,8 +428,6 @@ export function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;
 export function validateSnake(): never {
   return halt("validateSnake");
 }
-Object.assign(validateSnake, Namespace.notations.snake("validateSnake"));
-Object.assign(validateSnake, Namespace.validate());
 
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
@@ -482,7 +459,6 @@ export function createCamel<T>(): (input: T) => CamelCase<T>;
 export function createCamel(): never {
   halt("createCamel");
 }
-Object.assign(createCamel, Namespace.notations.camel("createCamel"));
 
 /**
  * Creates a reusable {@link assertCamel} function.
@@ -511,14 +487,6 @@ export function createAssertCamel<T>(): (input: T) => CamelCase<T>;
 export function createAssertCamel(): never {
   halt("createAssertCamel");
 }
-Object.assign(
-  createAssertCamel,
-  Namespace.notations.camel("createAssertCamel"),
-);
-Object.assign(
-  createAssertCamel,
-  Namespace.assert("notations.createAssertCamel"),
-);
 
 /**
  * Creates a reusable {@link isCamel} function.
@@ -547,8 +515,6 @@ export function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
 export function createIsCamel(): never {
   halt("createIsCamel");
 }
-Object.assign(createIsCamel, Namespace.notations.camel("createIsCamel"));
-Object.assign(createIsCamel, Namespace.is());
 
 /**
  * Creates a reusable {@link validateCamel} function.
@@ -579,11 +545,6 @@ export function createValidateCamel<T>(): (
 export function createValidateCamel(): never {
   halt("createValidateCamel");
 }
-Object.assign(
-  createValidateCamel,
-  Namespace.notations.camel("createValidateCamel"),
-);
-Object.assign(createValidateCamel, Namespace.validate());
 
 /**
  * Creates a reusable {@link pascal} function.
@@ -612,7 +573,6 @@ export function createPascal<T>(): (input: T) => PascalCase<T>;
 export function createPascal(): never {
   halt("createPascal");
 }
-Object.assign(createPascal, Namespace.notations.pascal("createPascal"));
 
 /**
  * Creates a reusable {@link assertPascal} function.
@@ -641,14 +601,6 @@ export function createAssertPascal<T>(): (input: T) => PascalCase<T>;
 export function createAssertPascal(): never {
   halt("createAssertPascal");
 }
-Object.assign(
-  createAssertPascal,
-  Namespace.notations.pascal("createAssertPascal"),
-);
-Object.assign(
-  createAssertPascal,
-  Namespace.assert("notations.createAssertPascal"),
-);
 
 /**
  * Creates a reusable {@link isPascal} function.
@@ -677,8 +629,6 @@ export function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
 export function createIsPascal(): never {
   halt("createIsPascal");
 }
-Object.assign(createIsPascal, Namespace.notations.pascal("createIsPascal"));
-Object.assign(createIsPascal, Namespace.is());
 
 /**
  * Creates a reusable {@link validatePascal} function.
@@ -709,11 +659,6 @@ export function createValidatePascal<T>(): (
 export function createValidatePascal(): never {
   halt("createValidatePascal");
 }
-Object.assign(
-  createValidatePascal,
-  Namespace.notations.pascal("createValidatePascal"),
-);
-Object.assign(createValidatePascal, Namespace.validate());
 
 /**
  * Creates a reusable {@link snake} function.
@@ -742,7 +687,6 @@ export function createSnake<T>(): (input: T) => SnakeCase<T>;
 export function createSnake(): never {
   halt("createSnake");
 }
-Object.assign(createSnake, Namespace.notations.snake("createSnake"));
 
 /**
  * Creates a reusable {@link assertSnake} function.
@@ -771,14 +715,6 @@ export function createAssertSnake<T>(): (input: T) => SnakeCase<T>;
 export function createAssertSnake(): never {
   halt("createAssertSnake");
 }
-Object.assign(
-  createAssertSnake,
-  Namespace.notations.snake("createAssertSnake"),
-);
-Object.assign(
-  createAssertSnake,
-  Namespace.assert("notations.createAssertSnake"),
-);
 
 /**
  * Creates a reusable {@link isSnake} function.
@@ -807,8 +743,6 @@ export function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
 export function createIsSnake(): never {
   halt("createIsSnake");
 }
-Object.assign(createIsSnake, Namespace.notations.snake("createIsSnake"));
-Object.assign(createIsSnake, Namespace.is());
 
 /**
  * Creates a reusable {@link validateSnake} function.
@@ -839,11 +773,6 @@ export function createValidateSnake<T>(): (
 export function createValidateSnake(): never {
   halt("createValidateSnake");
 }
-Object.assign(
-  createValidateSnake,
-  Namespace.notations.snake("createValidateSnake"),
-);
-Object.assign(createValidateSnake, Namespace.validate());
 
 /**
  * @internal

package/src/programmers/AssertProgrammer.ts

@@ -8,7 +8,7 @@ import { IProject } from "../transformers/IProject";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
@@ -84,7 +84,7 @@ export namespace AssertProgrammer {
         combiner: combiner(props.equals)(project)(importer),
         joiner: joiner(props.equals)(project)(importer),
         success: ts.factory.createTrue(),
-        addition: () => importer.declare(modulo),
+        addition: () => importer.declare(),
       })(importer)(type, name);
 
       return ts.factory.createArrowFunction(
@@ -276,7 +276,7 @@ export namespace AssertProgrammer {
       expected: string,
       value: ts.Expression,
     ): ts.Expression =>
-      ts.factory.createCallExpression(importer.use("guard"), undefined, [
+      ts.factory.createCallExpression(importer.use("guard", true), undefined, [
         exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
         ts.factory.createObjectLiteralExpression(
           [

package/src/programmers/CheckerProgrammer.ts

@@ -19,7 +19,7 @@ import { TransformerError } from "../transformers/TransformerError";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
 import { AtomicPredicator } from "./helpers/AtomicPredicator";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { ICheckEntry } from "./helpers/ICheckEntry";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";

package/src/programmers/FeatureProgrammer.ts

@@ -13,7 +13,7 @@ import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { IProject } from "../transformers/IProject";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { UnionExplorer } from "./helpers/UnionExplorer";
 import { feature_object_entries } from "./internal/feature_object_entries";

package/src/programmers/IsProgrammer.ts

@@ -11,7 +11,7 @@ import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { IProject } from "../transformers/IProject";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { disable_function_importer_declare } from "./helpers/disable_function_importer_declare";
@@ -122,7 +122,7 @@ export namespace IsProgrammer {
           numeric: OptionPredicator.numeric(project.options),
         })(project)(importer),
         trace: equals,
-        addition: () => importer.declare(modulo),
+        addition: () => importer.declare(),
       };
 
       config.decoder = () => (input, target, explore) => {

package/src/programmers/RandomProgrammer.ts

@@ -21,7 +21,7 @@ import { TransformerError } from "../transformers/TransformerError";
 
 import { Escaper } from "../utils/Escaper";
 
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { RandomJoiner } from "./helpers/RandomJoiner";
 import { RandomRanger } from "./helpers/RandomRanger";
 import { random_custom } from "./internal/random_custom";
@@ -88,7 +88,7 @@ export namespace RandomProgrammer {
           undefined,
           ts.factory.createBlock(
             [
-              ...importer.declare(modulo),
+              ...importer.declare(),
               ...functions.objects,
               ...functions.arrays,
               ...functions.tuples,
@@ -265,7 +265,7 @@ export namespace RandomProgrammer {
       // PICK UP A TYPE
       if (expressions.length === 1) return expressions[0]!;
       return ts.factory.createCallExpression(
-        ts.factory.createCallExpression(importer.use("pick"), undefined, [
+        ts.factory.createCallExpression(COALESCE(importer)("pick"), undefined, [
           ts.factory.createArrayLiteralExpression(
             expressions.map((expr) =>
               ts.factory.createArrowFunction(

package/src/programmers/ValidateProgrammer.ts

@@ -9,7 +9,7 @@ import { IProject } from "../transformers/IProject";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_everything } from "./internal/check_everything";
 import { check_object } from "./internal/check_object";
@@ -84,7 +84,7 @@ export namespace ValidateProgrammer {
         combiner: combine(equals)(project)(importer),
         joiner: joiner(equals)(project)(importer),
         success: ts.factory.createTrue(),
-        addition: () => importer.declare(modulo),
+        addition: () => importer.declare(),
       })(importer)(type, name);
 
       return ts.factory.createArrowFunction(
@@ -121,13 +121,16 @@ export namespace ValidateProgrammer {
                   "$report",
                   ts.factory.createCallExpression(
                     IdentifierFactory.access(
-                      ts.factory.createParenthesizedExpression(
-                        ts.factory.createAsExpression(
-                          modulo,
-                          TypeFactory.keyword("any"),
-                        ),
+                      ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("require"),
+                        [],
+                        [
+                          ts.factory.createStringLiteral(
+                            "typia/lib/functional/$report",
+                          ),
+                        ],
                       ),
-                    )("report"),
+                    )("$report"),
                     [],
                     [ts.factory.createIdentifier("errors")],
                   ),

package/src/programmers/helpers/{FunctionImporeter.ts → FunctionImporter.ts}

@@ -2,10 +2,9 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
 
 export class FunctionImporter {
-  private readonly used_: Set<string> = new Set();
+  private readonly used_: Map<string, boolean> = new Map();
   private readonly local_: Set<string> = new Set();
   private readonly unions_: Map<string, [string, ts.ArrowFunction]> = new Map();
   private sequence_: number = 0;
@@ -16,8 +15,8 @@ export class FunctionImporter {
     return this.used_.size === 0;
   }
 
-  public use(name: string): ts.Identifier {
-    this.used_.add(name);
+  public use(name: string, currying: boolean = false): ts.Identifier {
+    this.used_.set(name, !!currying);
     return ts.factory.createIdentifier("$" + name);
   }
 
@@ -30,21 +29,25 @@ export class FunctionImporter {
     return this.local_.has(name);
   }
 
-  public declare(
-    modulo: ts.LeftHandSideExpression,
-    includeUnions: boolean = true,
-  ): ts.Statement[] {
+  public declare(includeUnions: boolean = true): ts.Statement[] {
     return [
-      ...[...this.used_].map((name) =>
-        StatementFactory.constant(
-          "$" + name,
-          IdentifierFactory.access(
-            ts.factory.createParenthesizedExpression(
-              ts.factory.createAsExpression(modulo, TypeFactory.keyword("any")),
-            ),
-          )(name),
-        ),
-      ),
+      ...[...this.used_].map(([key, value]) => {
+        const accessor = IdentifierFactory.access(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("require"),
+            undefined,
+            [ts.factory.createStringLiteral(`typia/lib/functional/$${key}`)],
+          ),
+        )(`$${key}`);
+        return StatementFactory.constant(
+          `$${key}`,
+          value
+            ? ts.factory.createCallExpression(accessor, undefined, [
+                ts.factory.createStringLiteral(this.method),
+              ])
+            : accessor,
+        );
+      }),
       ...(includeUnions === true
         ? [...this.unions_.values()].map(([key, arrow]) =>
             StatementFactory.constant(key, arrow),

package/src/programmers/helpers/StringifyJoinder.ts

@@ -5,7 +5,7 @@ import { TemplateFactory } from "../../factories/TemplateFactory";
 
 import { stringify_dynamic_properties } from "../internal/stringify_dynamic_properties";
 import { stringify_regular_properties } from "../internal/stringify_regular_properties";
-import { FunctionImporter } from "./FunctionImporeter";
+import { FunctionImporter } from "./FunctionImporter";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace StringifyJoiner {
@@ -65,14 +65,13 @@ export namespace StringifyJoiner {
     TemplateFactory.generate([
       ts.factory.createStringLiteral(`[`),
       ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
+        IdentifierFactory.access(
           ts.factory.createCallExpression(
             IdentifierFactory.access(input)("map"),
             undefined,
             [arrow],
           ),
-          ts.factory.createIdentifier("join"),
-        ),
+        )("join"),
         undefined,
         [ts.factory.createStringLiteral(`,`)],
       ),

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-import { FunctionImporter } from "./FunctionImporeter";
+import { FunctionImporter } from "./FunctionImporter";
 
 export const disable_function_importer_declare = (
   importer: FunctionImporter,
@@ -9,10 +9,11 @@ export const disable_function_importer_declare = (
 const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
   method: importer.method,
   empty: (): boolean => importer.empty(),
-  use: (name: string): ts.Identifier => importer.use(name),
+  use: (name: string, currying?: boolean): ts.Identifier =>
+    importer.use(name, currying),
   useLocal: (name: string): string => importer.useLocal(name),
   hasLocal: (name: string): boolean => importer.hasLocal(name),
-  declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
+  declare: (): ts.Statement[] => [],
   declareUnions: (): ts.Statement[] => [],
   increment: (): number => importer.increment(),
   emplaceUnion: (

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -20,7 +20,7 @@ import { Atomic } from "../../typings/Atomic";
 import { Escaper } from "../../utils/Escaper";
 import { MapUtil } from "../../utils/MapUtil";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpHeadersProgrammer {
@@ -65,10 +65,7 @@ export namespace HttpHeadersProgrammer {
           }>`,
         ),
         undefined,
-        ts.factory.createBlock(
-          [...importer.declare(modulo), ...statements],
-          true,
-        ),
+        ts.factory.createBlock([...importer.declare(), ...statements], true),
       );
     };
 
@@ -243,7 +240,7 @@ export namespace HttpHeadersProgrammer {
     (value: ts.Expression) =>
       type === "string"
         ? value
-        : ts.factory.createCallExpression(importer.use(type), undefined, [
+        : ts.factory.createCallExpression(reader(importer)(type), undefined, [
             value,
           ]);
 
@@ -270,7 +267,7 @@ export namespace HttpHeadersProgrammer {
         ),
         undefined,
         undefined,
-        [importer.use(type)],
+        [reader(importer)(type)],
       );
       return ts.factory.createConditionalExpression(
         ExpressionFactory.isArray(accessor),
@@ -278,7 +275,7 @@ export namespace HttpHeadersProgrammer {
         ts.factory.createCallExpression(
           IdentifierFactory.access(accessor)("map"),
           undefined,
-          [importer.use(type)],
+          [reader(importer)(type)],
         ),
         undefined,
         value.isRequired() === false
@@ -312,3 +309,6 @@ const SINGULAR: Set<string> = new Set([
   "server",
   "user-agent",
 ]);
+
+const reader = (importer: FunctionImporter) => (type: Atomic.Literal) =>
+  IdentifierFactory.access(importer.use("HeadersReader"))(type);

package/src/programmers/http/HttpParameterProgrammer.ts

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

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -18,7 +18,7 @@ import { Atomic } from "../../typings/Atomic";
 
 import { Escaper } from "../../utils/Escaper";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpQueryProgrammer {
@@ -63,10 +63,7 @@ export namespace HttpQueryProgrammer {
           }>`,
         ),
         undefined,
-        ts.factory.createBlock(
-          [...importer.declare(modulo), ...statements],
-          true,
-        ),
+        ts.factory.createBlock([...importer.declare(), ...statements], true),
       );
     };
 
@@ -135,7 +132,7 @@ export namespace HttpQueryProgrammer {
             ts.factory.createToken(ts.SyntaxKind.EqualsToken),
             ts.factory.createAsExpression(
               ts.factory.createCallExpression(
-                importer.use("params"),
+                IdentifierFactory.access(importer.use("QueryReader"))("params"),
                 undefined,
                 [input],
               ),
@@ -224,7 +221,7 @@ export namespace HttpQueryProgrammer {
     (onlyUndefindable: boolean) =>
     (value: ts.Expression) => {
       const call = ts.factory.createCallExpression(
-        importer.use(type),
+        IdentifierFactory.access(importer.use("QueryReader"))(type),
         undefined,
         [value],
       );
@@ -242,11 +239,15 @@ export namespace HttpQueryProgrammer {
     (value: Metadata) =>
     (expression: ts.Expression): ts.Expression =>
       value.nullable || value.isRequired() === false
-        ? ts.factory.createCallExpression(importer.use("array"), undefined, [
-            expression,
-            value.nullable
-              ? ts.factory.createNull()
-              : ts.factory.createIdentifier("undefined"),
-          ])
+        ? ts.factory.createCallExpression(
+            IdentifierFactory.access(importer.use("QueryReader"))("array"),
+            undefined,
+            [
+              expression,
+              value.nullable
+                ? ts.factory.createNull()
+                : ts.factory.createIdentifier("undefined"),
+            ],
+          )
         : expression;
 }

package/src/programmers/internal/check_dynamic_key.ts

@@ -4,7 +4,7 @@ import { Metadata } from "../../schemas/metadata/Metadata";
 
 import { IProject } from "../../transformers/IProject";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { ICheckEntry } from "../helpers/ICheckEntry";
 import { check_bigint } from "./check_bigint";
 import { check_number } from "./check_number";

package/src/programmers/internal/check_dynamic_properties.ts

@@ -6,7 +6,7 @@ import { StatementFactory } from "../../factories/StatementFactory";
 
 import { IProject } from "../../transformers/IProject";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
 import { check_dynamic_key } from "./check_dynamic_key";
 import { check_everything } from "./check_everything";

package/src/programmers/internal/check_object.ts

@@ -2,7 +2,7 @@ import ts from "typescript";
 
 import { IProject } from "../../transformers/IProject";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
 import { check_dynamic_properties } from "./check_dynamic_properties";
 import { check_everything } from "./check_everything";

package/src/programmers/internal/feature_object_entries.ts

@@ -7,7 +7,7 @@ import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { Escaper } from "../../utils/Escaper";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 
 /**
  * @internal