typia 6.10.0 → 7.0.0-dev.20240916

package/src/programmers/functional/FunctionalValidateReturnProgrammer.ts

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { StringUtil } from "../../utils/StringUtil";
 
@@ -12,115 +12,122 @@ import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFuncti
 import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalValidateReturnProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.CallExpression => {
-      const result = decompose(project)(modulo)(equals)(
-        expression,
-        declaration,
-      );
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            ...result.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                result.async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                FunctionalValidateFunctionProgrammer.getReturnTypeNode(
-                  declaration,
-                  result.async,
-                ),
-                undefined,
-                ts.factory.createBlock(result.statements, true),
-              ),
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    declaration: ts.FunctionDeclaration;
+    expression: ts.Expression;
+    init?: ts.Expression | undefined;
+  }
+  export interface IDecomposeProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    expression: ts.Expression;
+    declaration: ts.FunctionDeclaration;
+  }
+  export interface IDecomposeOutput {
+    async: boolean;
+    functions: ts.Statement[];
+    statements: ts.Statement[];
+  }
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const result = decompose(props);
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          ...result.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              result.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              FunctionalValidateFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async: result.async,
+              }),
+              undefined,
+              ts.factory.createBlock(result.statements, true),
             ),
-          ],
-          true,
-        ),
-      );
-    };
+          ),
+        ],
+        true,
+      ),
+    );
+  };
 
-  export const decompose =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): {
-      async: boolean;
-      functions: ts.Statement[];
-      statements: ts.Statement[];
-    } => {
-      const { type, async } = FunctionalGeneralProgrammer.getReturnType(
-        project.checker,
-      )(declaration);
-      const caller: ts.CallExpression = ts.factory.createCallExpression(
-        expression,
-        undefined,
-        declaration.parameters.map((p) =>
-          ts.factory.createIdentifier(p.name.getText()),
-        ),
-      );
+  export const decompose = (props: IDecomposeProps): IDecomposeOutput => {
+    const { type, async } = FunctionalGeneralProgrammer.getReturnType({
+      checker: props.context.checker,
+      declaration: props.declaration,
+    });
+    const caller: ts.CallExpression = ts.factory.createCallExpression(
+      props.expression,
+      undefined,
+      props.declaration.parameters.map((p) =>
+        ts.factory.createIdentifier(p.name.getText()),
+      ),
+    );
 
-      const name: string = StringUtil.escapeDuplicate(
-        declaration.parameters.map((p) => p.name.getText()),
-      )("result");
-      return {
-        async,
-        functions: [
-          StatementFactory.constant(
-            "__validate_return",
-            ValidateProgrammer.write(project)(modulo)(equals)(type),
+    const name: string = StringUtil.escapeDuplicate(
+      props.declaration.parameters.map((p) => p.name.getText()),
+    )("result");
+    return {
+      async,
+      functions: [
+        StatementFactory.constant(
+          "__validate_return",
+          ValidateProgrammer.write({
+            ...props,
+            type,
+            name: undefined,
+            init: undefined,
+          }),
+        ),
+      ],
+      statements: [
+        StatementFactory.constant(
+          name,
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("__validate_return"),
+            undefined,
+            [async ? ts.factory.createAwaitExpression(caller) : caller],
           ),
-        ],
-        statements: [
-          StatementFactory.constant(
-            name,
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__validate_return"),
-              undefined,
-              [async ? ts.factory.createAwaitExpression(caller) : caller],
+        ),
+        ts.factory.createIfStatement(
+          ts.factory.createStrictEquality(
+            ts.factory.createFalse(),
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier(name),
+              ts.factory.createIdentifier("success"),
             ),
           ),
-          ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-              ts.factory.createFalse(),
+          ts.factory.createExpressionStatement(
+            ts.factory.createBinaryExpression(
               ts.factory.createPropertyAccessExpression(
                 ts.factory.createIdentifier(name),
-                ts.factory.createIdentifier("success"),
+                ts.factory.createIdentifier("errors"),
               ),
-            ),
-            ts.factory.createExpressionStatement(
-              ts.factory.createBinaryExpression(
-                ts.factory.createPropertyAccessExpression(
+              ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+              FunctionalValidateFunctionProgrammer.hookErrors({
+                expression: ts.factory.createPropertyAccessExpression(
                   ts.factory.createIdentifier(name),
                   ts.factory.createIdentifier("errors"),
                 ),
-                ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                FunctionalValidateFunctionProgrammer.hookErrors({
-                  expression: ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier(name),
-                    ts.factory.createIdentifier("errors"),
-                  ),
-                  replacer: ts.factory.createStringLiteral("$input.return"),
-                }),
-              ),
+                replacer: ts.factory.createStringLiteral("$input.return"),
+              }),
             ),
           ),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("result"),
-          ),
-        ],
-      };
+        ),
+        ts.factory.createReturnStatement(ts.factory.createIdentifier("result")),
+      ],
     };
+  };
 }

package/src/programmers/functional/internal/FunctionalGeneralProgrammer.ts

@@ -3,32 +3,32 @@ import ts from "typescript";
 import { TypeFactory } from "../../../factories/TypeFactory";
 
 export namespace FunctionalGeneralProgrammer {
+  export interface IProps {
+    checker: ts.TypeChecker;
+    declaration: ts.FunctionDeclaration | ts.SignatureDeclaration;
+  }
   export interface IOutput {
     type: ts.Type;
     async: boolean;
   }
-  export const getReturnType =
-    (checker: ts.TypeChecker) =>
-    (
-      declaration: ts.FunctionDeclaration | ts.SignatureDeclaration,
-    ): IOutput => {
-      const signature: ts.Signature | undefined =
-        checker.getSignatureFromDeclaration(declaration);
-      const type: ts.Type =
-        signature?.getReturnType() ??
-        checker.getTypeFromTypeNode(TypeFactory.keyword("any"));
+  export const getReturnType = (props: IProps): IOutput => {
+    const signature: ts.Signature | undefined =
+      props.checker.getSignatureFromDeclaration(props.declaration);
+    const type: ts.Type =
+      signature?.getReturnType() ??
+      props.checker.getTypeFromTypeNode(TypeFactory.keyword("any"));
 
-      if (type.symbol?.name === "Promise") {
-        const generic: readonly ts.Type[] = checker.getTypeArguments(
-          type as ts.TypeReference,
-        );
-        return generic.length === 1
-          ? { type: generic[0]!, async: true }
-          : {
-              type: checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
-              async: false,
-            };
-      }
-      return { type, async: false };
-    };
+    if (type.symbol?.name === "Promise") {
+      const generic: readonly ts.Type[] = props.checker.getTypeArguments(
+        type as ts.TypeReference,
+      );
+      return generic.length === 1
+        ? { type: generic[0]!, async: true }
+        : {
+            type: props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+            async: false,
+          };
+    }
+    return { type, async: false };
+  };
 }

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

@@ -4,7 +4,8 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
@@ -13,24 +14,26 @@ import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
 
 export namespace HttpAssertFormDataProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
-    init: ts.Expression | undefined;
+    init?: ts.Expression | undefined;
   }): FeatureProgrammer.IDecomposed => {
     const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
       ...props,
-      project: {
-        ...props.project,
+      context: {
+        ...props.context,
         options: {
-          ...props.project.options,
+          ...props.context.options,
           functional: false,
           numeric: true,
         },
       },
-      equals: false,
-      guard: false,
+      config: {
+        equals: false,
+        guard: false,
+      },
     });
     const decode: FeatureProgrammer.IDecomposed =
       HttpFormDataProgrammer.decompose(props);
@@ -70,22 +73,18 @@ export namespace HttpAssertFormDataProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        importer,
-        type,
-        name,
-        init,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }

package/src/programmers/http/HttpAssertHeadersProgrammer.ts

@@ -4,7 +4,8 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
@@ -13,24 +14,26 @@ import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
 
 export namespace HttpAssertHeadersProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
-    init: ts.Expression | undefined;
+    init?: ts.Expression | undefined;
   }): FeatureProgrammer.IDecomposed => {
     const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
       ...props,
-      project: {
-        ...props.project,
+      context: {
+        ...props.context,
         options: {
-          ...props.project.options,
+          ...props.context.options,
           functional: false,
           numeric: false,
         },
       },
-      equals: false,
-      guard: false,
+      config: {
+        equals: false,
+        guard: false,
+      },
     });
     const decode: FeatureProgrammer.IDecomposed =
       HttpHeadersProgrammer.decompose(props);
@@ -70,22 +73,18 @@ export namespace HttpAssertHeadersProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        importer,
-        type,
-        name,
-        init,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }

package/src/programmers/http/HttpAssertQueryProgrammer.ts

@@ -4,7 +4,8 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
@@ -12,26 +13,32 @@ import { FunctionImporter } from "../helpers/FunctionImporter";
 import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
 
 export namespace HttpAssertQueryProgrammer {
+  export interface IProps extends IProgrammerProps {
+    allowOptional?: boolean;
+  }
+
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
-    init: ts.Expression | undefined;
+    init?: ts.Expression | undefined;
     allowOptional: boolean;
   }): FeatureProgrammer.IDecomposed => {
     const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
       ...props,
-      project: {
-        ...props.project,
+      context: {
+        ...props.context,
         options: {
-          ...props.project.options,
+          ...props.context.options,
           functional: false,
           numeric: false,
         },
       },
-      equals: false,
-      guard: false,
+      config: {
+        equals: false,
+        guard: false,
+      },
     });
     const decode: FeatureProgrammer.IDecomposed =
       HttpQueryProgrammer.decompose(props);
@@ -71,23 +78,19 @@ export namespace HttpAssertQueryProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression, allowOptional: boolean = false) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        importer,
-        type,
-        name,
-        init,
-        allowOptional,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+      allowOptional: !!props.allowOptional,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -11,7 +11,8 @@ import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 import { TransformerError } from "../../transformers/TransformerError";
 
 import { Atomic } from "../../typings/Atomic";
@@ -24,7 +25,7 @@ import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpFormDataProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
@@ -32,8 +33,8 @@ export namespace HttpFormDataProgrammer {
     // ANALYZE TYPE
     const collection: MetadataCollection = new MetadataCollection();
     const result = MetadataFactory.analyze(
-      props.project.checker,
-      props.project.context,
+      props.context.checker,
+      props.context.transformer,
     )({
       escape: false,
       constant: true,
@@ -69,7 +70,7 @@ export namespace HttpFormDataProgrammer {
           [
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.project.checker)(props.type),
+                TypeFactory.getFullName(props.context.checker)(props.type),
             ),
           ],
           false,
@@ -80,23 +81,20 @@ export namespace HttpFormDataProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 
   export const validate = (
     meta: Metadata,