typia 5.5.0-dev.20240304 → 5.5.0-dev.20240305

package/src/programmers/functional/FunctionalValidateParametersProgrammer.ts

@@ -0,0 +1,212 @@
+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 { StringUtil } from "../../utils/StringUtil";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFunctionProgrammer";
+
+export namespace FunctionalValidateParametersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.ArrowFunction => {
+      const async: boolean = (() => {
+        if (declaration.type === undefined) return false;
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+          declaration.type,
+        );
+        return type.isTypeParameter() && type.symbol.name === "Promise";
+      })();
+      const caller: ts.CallExpression = ts.factory.createCallExpression(
+        expression,
+        undefined,
+        declaration.parameters.map((p) =>
+          ts.factory.createIdentifier(p.name.getText()),
+        ),
+      );
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type
+          ? ts.factory.createImportTypeNode(
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral("typia"),
+              ),
+              undefined,
+              ts.factory.createIdentifier("IValidation"),
+              [declaration.type],
+            )
+          : undefined,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...writeStatements(project)(modulo)(equals)(declaration),
+            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,
+        ),
+      );
+    };
+
+  export const writeStatements =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (declaration: ts.FunctionDeclaration): ts.Statement[] => {
+      const resultName: string = StringUtil.escapeDuplicate(
+        declaration.parameters.map((p) => p.name.getText()),
+      )("paramResults");
+      const validationResultArray: ts.ArrayLiteralExpression =
+        ts.factory.createArrayLiteralExpression(
+          declaration.parameters.map((p) =>
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ValidateProgrammer.write(project)(modulo)(equals)(
+                  project.checker.getTypeFromTypeNode(
+                    p.type ?? TypeFactory.keyword("any"),
+                  ),
+                ),
+                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(
+          validationResultArray,
+          "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",
+              ),
+            ),
+          ),
+        ],
+      );
+      const errorMatrix = ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier(resultName),
+          "map",
+        ),
+        undefined,
+        [
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [
+              IdentifierFactory.parameter("r"),
+              IdentifierFactory.parameter("i"),
+            ],
+            undefined,
+            undefined,
+            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("]"),
+                  ),
+                ],
+              ),
+            }),
+          ),
+        ],
+      );
+      return [
+        StatementFactory.constant(resultName, failures),
+        ts.factory.createIfStatement(
+          ts.factory.createBinaryExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier(resultName),
+              "length",
+            ),
+            ts.SyntaxKind.GreaterThanToken,
+            ts.factory.createNumericLiteral("0"),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createObjectLiteralExpression(
+              [
+                ts.factory.createPropertyAssignment(
+                  "success",
+                  ts.factory.createFalse(),
+                ),
+                ts.factory.createPropertyAssignment(
+                  "errors",
+                  ts.factory.createCallExpression(
+                    ts.factory.createPropertyAccessExpression(
+                      errorMatrix,
+                      "flat",
+                    ),
+                    undefined,
+                    undefined,
+                  ),
+                ),
+              ],
+              true,
+            ),
+          ),
+        ),
+      ];
+    };
+}

package/src/programmers/functional/FunctionalValidateReturnProgrammer.ts

@@ -0,0 +1,115 @@
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFunctionProgrammer";
+
+export namespace FunctionalValidateReturnProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.ArrowFunction => {
+      const { async, statements } = writeStatements(project)(modulo)(equals)(
+        expression,
+        declaration,
+      );
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type
+          ? ts.factory.createImportTypeNode(
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral("typia"),
+              ),
+              undefined,
+              ts.factory.createIdentifier("IValidation"),
+              [declaration.type],
+            )
+          : undefined,
+        undefined,
+        ts.factory.createBlock(statements, true),
+      );
+    };
+
+  export const writeStatements =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): {
+      async: boolean;
+      statements: ts.Statement[];
+    } => {
+      const [type, async]: [ts.Type, boolean] = (() => {
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+          declaration.type ?? TypeFactory.keyword("any"),
+        );
+        return type.isTypeParameter() && type.symbol.name === "Promise"
+          ? [type.aliasTypeArguments![0]!, true]
+          : [type, false];
+      })();
+      const caller: ts.CallExpression = ts.factory.createCallExpression(
+        expression,
+        undefined,
+        declaration.parameters.map((p) =>
+          ts.factory.createIdentifier(p.name.getText()),
+        ),
+      );
+
+      const name: string = StringUtil.escapeDuplicate(
+        declaration.parameters.map((p) => p.name.getText()),
+      )("result");
+      const statements: ts.Statement[] = [
+        StatementFactory.constant(
+          name,
+          ts.factory.createCallExpression(
+            ValidateProgrammer.write(project)(modulo)(equals)(type),
+            undefined,
+            [async ? ts.factory.createAwaitExpression(caller) : caller],
+          ),
+        ),
+        ts.factory.createIfStatement(
+          ts.factory.createPrefixUnaryExpression(
+            ts.SyntaxKind.ExclamationToken,
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier(name),
+              ts.factory.createIdentifier("success"),
+            ),
+          ),
+          ts.factory.createExpressionStatement(
+            ts.factory.createBinaryExpression(
+              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"),
+              }),
+            ),
+          ),
+        ),
+        ts.factory.createReturnStatement(ts.factory.createIdentifier("result")),
+      ];
+      return { async, statements };
+    };
+}

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

@@ -24,10 +24,18 @@ export namespace HttpAssertFormDataProgrammer {
           ),
           AssertProgrammer.Guardian.parameter(init),
         ],
-        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([

package/src/programmers/http/HttpAssertHeadersProgrammer.ts

@@ -26,10 +26,18 @@ export namespace HttpAssertHeadersProgrammer {
           ),
           AssertProgrammer.Guardian.parameter(init),
         ],
-        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([

package/src/programmers/http/HttpAssertQueryProgrammer.ts

@@ -24,10 +24,18 @@ export namespace HttpAssertQueryProgrammer {
           ),
           AssertProgrammer.Guardian.parameter(init),
         ],
-        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([

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -55,10 +55,18 @@ export namespace HttpFormDataProgrammer {
             ts.factory.createTypeReferenceNode("FormData"),
           ),
         ],
-        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(

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -59,10 +59,18 @@ export namespace HttpHeadersProgrammer {
             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(

package/src/programmers/http/HttpIsFormDataProgrammer.ts

@@ -24,10 +24,18 @@ export namespace HttpIsFormDataProgrammer {
           ),
         ],
         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()),
         ]),

package/src/programmers/http/HttpIsHeadersProgrammer.ts

@@ -26,10 +26,18 @@ export namespace HttpIsHeadersProgrammer {
           ),
         ],
         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()),
         ]),

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()),
         ]),

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -57,10 +57,18 @@ 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(

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -25,10 +25,18 @@ export namespace JsonAssertParseProgrammer {
           IdentifierFactory.parameter("input", TypeFactory.keyword("string")),
           AssertProgrammer.Guardian.parameter(init),
         ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Primitive<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Primitive"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
         ts.factory.createBlock([

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -22,10 +22,18 @@ export namespace JsonIsParseProgrammer {
         undefined,
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode(
-          `typia.Primitive<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Primitive"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
         ts.factory.createBlock([

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -21,10 +21,18 @@ export namespace MiscAssertCloneProgrammer {
           IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
           AssertProgrammer.Guardian.parameter(init),
         ],
-        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([

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -631,10 +631,18 @@ export namespace MiscCloneProgrammer {
               name ?? TypeFactory.getFullName(project.checker)(type),
             ),
           output: (type, name) =>
-            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,
             ),
         },
         prefix: PREFIX,

package/src/programmers/misc/MiscIsCloneProgrammer.ts

@@ -19,10 +19,18 @@ export namespace MiscIsCloneProgrammer {
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
         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()),
         ]),