typia 6.10.0 → 7.0.0-dev.20240916

package/src/programmers/functional/FunctionalValidateParametersProgrammer.ts

@@ -5,7 +5,7 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { StringUtil } from "../../utils/StringUtil";
 
@@ -14,160 +14,80 @@ import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFuncti
 import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalValidateParametersProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.CallExpression => {
-      const { async } = FunctionalGeneralProgrammer.getReturnType(
-        project.checker,
-      )(declaration);
-      const result = decompose(project)(modulo)(equals)(declaration);
-      const caller: ts.CallExpression = ts.factory.createCallExpression(
-        expression,
-        undefined,
-        declaration.parameters.map((p) =>
-          ts.factory.createIdentifier(p.name.getText()),
-        ),
-      );
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            ...result.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                FunctionalValidateFunctionProgrammer.getReturnTypeNode(
-                  declaration,
-                  async,
-                ),
-                undefined,
-                ts.factory.createBlock(
-                  [
-                    ...result.statements,
-                    ts.factory.createReturnStatement(
-                      ts.factory.createObjectLiteralExpression(
-                        [
-                          ts.factory.createPropertyAssignment(
-                            "success",
-                            ts.factory.createTrue(),
-                          ),
-                          ts.factory.createPropertyAssignment(
-                            "data",
-                            async
-                              ? ts.factory.createAwaitExpression(caller)
-                              : caller,
-                          ),
-                          ts.factory.createPropertyAssignment(
-                            "errors",
-                            ts.factory.createArrayLiteralExpression([]),
-                          ),
-                        ],
-                        true,
-                      ),
-                    ),
-                  ],
-                  true,
-                ),
-              ),
-            ),
-          ],
-          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;
+    declaration: ts.FunctionDeclaration;
+  }
+  export interface IDecomposeOutput {
+    functions: ts.Statement[];
+    statements: ts.Statement[];
+  }
 
-  export const decompose =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      declaration: ts.FunctionDeclaration,
-    ): {
-      functions: ts.Statement[];
-      statements: ts.Statement[];
-    } => {
-      const resultName: string = StringUtil.escapeDuplicate(
-        declaration.parameters.map((p) => p.name.getText()),
-      )("paramErrorResults");
-      const validationResultArray: ts.ArrayLiteralExpression =
-        ts.factory.createArrayLiteralExpression(
-          declaration.parameters.map((p, i) =>
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier(`__validate_param_${i}`),
-                undefined,
-                [ts.factory.createIdentifier(p.name.getText())],
-              ),
-              ts.factory.createImportTypeNode(
-                ts.factory.createLiteralTypeNode(
-                  ts.factory.createStringLiteral("typia"),
-                ),
-                undefined,
-                ts.factory.createQualifiedName(
-                  ts.factory.createIdentifier("IValidation"),
-                  ts.factory.createIdentifier("IFailure"),
-                ),
-                undefined,
-                false,
-              ),
-            ),
-          ),
-          true,
-        );
-      const errorMatrix = ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(validationResultArray, "map"),
-        undefined,
+  export const write = (props: IProps): ts.CallExpression => {
+    const { async } = FunctionalGeneralProgrammer.getReturnType({
+      checker: props.context.checker,
+      declaration: props.declaration,
+    });
+    const result = decompose(props);
+    const caller: ts.CallExpression = ts.factory.createCallExpression(
+      props.expression,
+      undefined,
+      props.declaration.parameters.map((p) =>
+        ts.factory.createIdentifier(p.name.getText()),
+      ),
+    );
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
         [
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [
-              IdentifierFactory.parameter("r"),
-              IdentifierFactory.parameter("i"),
-            ],
-            undefined,
-            undefined,
-            ts.factory.createConditionalExpression(
-              ts.factory.createStrictEquality(
-                ts.factory.createTrue(),
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createIdentifier("r"),
-                  "success",
-                ),
-              ),
+          ...result.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
               undefined,
-              ts.factory.createIdentifier("r"),
+              props.declaration.parameters,
+              FunctionalValidateFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async,
+              }),
               undefined,
-              ts.factory.createObjectLiteralExpression(
+              ts.factory.createBlock(
                 [
-                  ts.factory.createSpreadAssignment(
-                    ts.factory.createIdentifier("r"),
-                  ),
-                  ts.factory.createPropertyAssignment(
-                    "errors",
-                    FunctionalValidateFunctionProgrammer.hookErrors({
-                      expression: ts.factory.createPropertyAccessExpression(
-                        ts.factory.createIdentifier("r"),
-                        "errors",
-                      ),
-                      replacer: ts.factory.createTemplateExpression(
-                        ts.factory.createTemplateHead("$input.parameters["),
-                        [
-                          ts.factory.createTemplateSpan(
-                            ts.factory.createIdentifier("i"),
-                            ts.factory.createTemplateTail("]"),
-                          ),
-                        ],
-                      ),
-                    }),
+                  ...result.statements,
+                  ts.factory.createReturnStatement(
+                    ts.factory.createObjectLiteralExpression(
+                      [
+                        ts.factory.createPropertyAssignment(
+                          "success",
+                          ts.factory.createTrue(),
+                        ),
+                        ts.factory.createPropertyAssignment(
+                          "data",
+                          async
+                            ? ts.factory.createAwaitExpression(caller)
+                            : caller,
+                        ),
+                        ts.factory.createPropertyAssignment(
+                          "errors",
+                          ts.factory.createArrayLiteralExpression([]),
+                        ),
+                      ],
+                      true,
+                    ),
                   ),
                 ],
                 true,
@@ -175,93 +95,180 @@ export namespace FunctionalValidateParametersProgrammer {
             ),
           ),
         ],
+        true,
+      ),
+    );
+  };
+
+  export const decompose = (props: IDecomposeProps): IDecomposeOutput => {
+    const resultName: string = StringUtil.escapeDuplicate(
+      props.declaration.parameters.map((p) => p.name.getText()),
+    )("paramErrorResults");
+    const validationResultArray: ts.ArrayLiteralExpression =
+      ts.factory.createArrayLiteralExpression(
+        props.declaration.parameters.map((p, i) =>
+          ts.factory.createAsExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier(`__validate_param_${i}`),
+              undefined,
+              [ts.factory.createIdentifier(p.name.getText())],
+            ),
+            ts.factory.createImportTypeNode(
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral("typia"),
+              ),
+              undefined,
+              ts.factory.createQualifiedName(
+                ts.factory.createIdentifier("IValidation"),
+                ts.factory.createIdentifier("IFailure"),
+              ),
+              undefined,
+              false,
+            ),
+          ),
+        ),
+        true,
       );
-      const failures = ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(errorMatrix, "filter"),
-        undefined,
-        [
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [IdentifierFactory.parameter("r")],
-            undefined,
-            undefined,
+    const errorMatrix = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(validationResultArray, "map"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [IdentifierFactory.parameter("r"), IdentifierFactory.parameter("i")],
+          undefined,
+          undefined,
+          ts.factory.createConditionalExpression(
             ts.factory.createStrictEquality(
-              ts.factory.createFalse(),
+              ts.factory.createTrue(),
               ts.factory.createPropertyAccessExpression(
                 ts.factory.createIdentifier("r"),
                 "success",
               ),
             ),
+            undefined,
+            ts.factory.createIdentifier("r"),
+            undefined,
+            ts.factory.createObjectLiteralExpression(
+              [
+                ts.factory.createSpreadAssignment(
+                  ts.factory.createIdentifier("r"),
+                ),
+                ts.factory.createPropertyAssignment(
+                  "errors",
+                  FunctionalValidateFunctionProgrammer.hookErrors({
+                    expression: ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier("r"),
+                      "errors",
+                    ),
+                    replacer: ts.factory.createTemplateExpression(
+                      ts.factory.createTemplateHead("$input.parameters["),
+                      [
+                        ts.factory.createTemplateSpan(
+                          ts.factory.createIdentifier("i"),
+                          ts.factory.createTemplateTail("]"),
+                        ),
+                      ],
+                    ),
+                  }),
+                ),
+              ],
+              true,
+            ),
           ),
-        ],
-      );
-      return {
-        functions: declaration.parameters.map((p, i) =>
-          StatementFactory.constant(
-            `__validate_param_${i}`,
-            ValidateProgrammer.write(project)(modulo)(equals)(
-              project.checker.getTypeFromTypeNode(
-                p.type ?? TypeFactory.keyword("any"),
-              ),
+        ),
+      ],
+    );
+    const failures = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(errorMatrix, "filter"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [IdentifierFactory.parameter("r")],
+          undefined,
+          undefined,
+          ts.factory.createStrictEquality(
+            ts.factory.createFalse(),
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier("r"),
+              "success",
             ),
           ),
         ),
-        statements: [
-          StatementFactory.constant(resultName, failures),
-          ts.factory.createIfStatement(
-            ts.factory.createStrictInequality(
-              ts.factory.createNumericLiteral("0"),
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createIdentifier(resultName),
-                "length",
-              ),
+      ],
+    );
+    return {
+      functions: props.declaration.parameters.map((p, i) =>
+        StatementFactory.constant(
+          `__validate_param_${i}`,
+          ValidateProgrammer.write({
+            ...props,
+            type: props.context.checker.getTypeFromTypeNode(
+              p.type ?? TypeFactory.keyword("any"),
             ),
-            ts.factory.createReturnStatement(
-              ts.factory.createObjectLiteralExpression(
-                [
-                  ts.factory.createPropertyAssignment(
-                    "success",
-                    ts.factory.createFalse(),
-                  ),
-                  ts.factory.createPropertyAssignment(
-                    "errors",
-                    ts.factory.createCallExpression(
-                      IdentifierFactory.access(
-                        ts.factory.createCallExpression(
-                          IdentifierFactory.access(
-                            ts.factory.createIdentifier(resultName),
-                          )("map"),
-                          undefined,
-                          [
-                            ts.factory.createArrowFunction(
-                              undefined,
-                              undefined,
-                              [
-                                IdentifierFactory.parameter(
-                                  "r",
-                                  TypeFactory.keyword("any"),
-                                ),
-                              ],
-                              undefined,
-                              undefined,
-                              IdentifierFactory.access(
-                                ts.factory.createIdentifier("r"),
-                              )("errors"),
-                            ),
-                          ],
-                        ),
-                      )("flat"),
-                      undefined,
-                      undefined,
-                    ),
+            name: undefined,
+            init: undefined,
+          }),
+        ),
+      ),
+      statements: [
+        StatementFactory.constant(resultName, failures),
+        ts.factory.createIfStatement(
+          ts.factory.createStrictInequality(
+            ts.factory.createNumericLiteral("0"),
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier(resultName),
+              "length",
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createObjectLiteralExpression(
+              [
+                ts.factory.createPropertyAssignment(
+                  "success",
+                  ts.factory.createFalse(),
+                ),
+                ts.factory.createPropertyAssignment(
+                  "errors",
+                  ts.factory.createCallExpression(
+                    IdentifierFactory.access(
+                      ts.factory.createCallExpression(
+                        IdentifierFactory.access(
+                          ts.factory.createIdentifier(resultName),
+                        )("map"),
+                        undefined,
+                        [
+                          ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            [
+                              IdentifierFactory.parameter(
+                                "r",
+                                TypeFactory.keyword("any"),
+                              ),
+                            ],
+                            undefined,
+                            undefined,
+                            IdentifierFactory.access(
+                              ts.factory.createIdentifier("r"),
+                            )("errors"),
+                          ),
+                        ],
+                      ),
+                    )("flat"),
+                    undefined,
+                    undefined,
                   ),
-                ],
-                true,
-              ),
+                ),
+              ],
+              true,
             ),
           ),
-        ],
-      };
+        ),
+      ],
     };
+  };
 }