typia 5.5.0-dev.20240302 → 5.5.0-dev.20240303-2

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -0,0 +1,99 @@
+import ts from "typescript";
+import { IProject } from "../../transformers/IProject";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { AssertProgrammer } from "../AssertProgrammer";
+
+export namespace FunctionalAssertParametersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ): ts.ArrowFunction => {
+      const { assert, call } = prepare(project)(modulo)(equals)(
+        declaration,
+        init,
+      );
+      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";
+      })();
+
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type,
+        undefined,
+        ts.factory.createBlock(
+          [
+            assert,
+            call,
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                expression,
+                undefined,
+                declaration.parameters.map((p) =>
+                  ts.factory.createIdentifier(p.name.getText()),
+                ),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const prepare =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (declaration: ts.FunctionDeclaration, init?: ts.Expression) => {
+      const typeNode: ts.TypeNode = ts.factory.createTypeLiteralNode([
+        ts.factory.createPropertySignature(
+          undefined,
+          "parameters",
+          undefined,
+          ts.factory.createTupleTypeNode(
+            declaration.parameters.map((p) => p.type!),
+          ),
+        ),
+      ]);
+      const type: ts.Type = project.checker.getTypeFromTypeNode(typeNode);
+
+      const assert = StatementFactory.constant(
+        "assert",
+        AssertProgrammer.write(project)(modulo)(equals)(type, undefined, init),
+      );
+      const call = ts.factory.createExpressionStatement(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("assert"),
+          undefined,
+          [
+            ts.factory.createObjectLiteralExpression(
+              [
+                ts.factory.createPropertyAssignment(
+                  "parameters",
+                  ts.factory.createArrayLiteralExpression(
+                    declaration.parameters.map((p) =>
+                      ts.factory.createIdentifier(p.name.getText()),
+                    ),
+                  ),
+                ),
+              ],
+              true,
+            ),
+          ],
+        ),
+      );
+      return { assert, call, type };
+    };
+}

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

@@ -0,0 +1,83 @@
+import ts from "typescript";
+import { IProject } from "../../transformers/IProject";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { AssertProgrammer } from "../AssertProgrammer";
+
+export namespace FunctionAssertReturnProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ): ts.ArrowFunction => {
+      const { async, assert, variable, call, returns } = prepare(project)(
+        modulo,
+      )(equals)(expression, declaration, init);
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type,
+        undefined,
+        ts.factory.createBlock([assert, variable, call, returns], true),
+      );
+    };
+
+  export const prepare =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ) => {
+      const [type, async]: [ts.Type, boolean] = (() => {
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+          declaration.type!,
+        );
+        return type.isTypeParameter() && type.symbol.name === "Promise"
+          ? [type.aliasTypeArguments![0]!, true]
+          : [type, false];
+      })();
+      const assert = StatementFactory.constant(
+        "assert",
+        AssertProgrammer.write(project)(modulo)(equals)(type, undefined, init),
+      );
+      const funcCaller = ts.factory.createCallExpression(
+        expression,
+        undefined,
+        declaration.parameters.map((p) =>
+          ts.factory.createIdentifier(p.name.getText()),
+        ),
+      );
+      const variable = StatementFactory.constant(
+        "output",
+        async ? ts.factory.createAwaitExpression(funcCaller) : funcCaller,
+      );
+
+      const call = ts.factory.createExpressionStatement(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("assert"),
+          undefined,
+          [
+            ts.factory.createObjectLiteralExpression([
+              ts.factory.createPropertyAssignment(
+                "return",
+                ts.factory.createIdentifier("output"),
+              ),
+            ]),
+          ],
+        ),
+      );
+      const returns = ts.factory.createReturnStatement(
+        ts.factory.createIdentifier("output"),
+      );
+      return { async, type, assert, variable, call, returns };
+    };
+}

package/src/transformers/CallExpressionTransformer.ts

@@ -96,6 +96,10 @@ import { CreateHttpAssertFormDataTransformer } from "./features/http/CreateHttpA
 import { CreateHttpFormDataTransformer } from "./features/http/CreateHttpFormDataTransformer";
 import { CreateHttpIsFormDataTransformer } from "./features/http/CreateHttpIsFormDataTransformer";
 import { CreateHttpValidateFormDataTransformer } from "./features/http/CreateHttpValidateFormDataTransformer";
+import { FunctionalGenericTransformer } from "./features/functional/FunctionalGenericTransformer";
+import { FunctionalAssertFunctionProgrammer } from "../programmers/functional/FunctionalAssertFunctionProgrammer";
+import { FunctionalAssertParametersProgrammer } from "../programmers/functional/FunctionalAssertParametersProgrammer";
+import { FunctionAssertReturnProgrammer } from "../programmers/functional/FunctionalAssertReturnProgrammer";
 
 export namespace CallExpressionTransformer {
   export const transform =
@@ -187,6 +191,45 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     createValidateEquals: () => CreateValidateTransformer.transform(true),
     createRandom: () => CreateRandomTransformer.transform,
   },
+  functional: {
+    // ASSERTIONS
+    assertFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertFunction",
+        equals: false,
+        programmer: FunctionalAssertFunctionProgrammer.write,
+      }),
+    assertParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertParameters",
+        equals: false,
+        programmer: FunctionalAssertParametersProgrammer.write,
+      }),
+    assertReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertReturn",
+        equals: false,
+        programmer: FunctionAssertReturnProgrammer.write,
+      }),
+    assertEqualsFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertEqualsFunction",
+        equals: true,
+        programmer: FunctionalAssertFunctionProgrammer.write,
+      }),
+    assertEqualsParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertEqualsParameters",
+        equals: true,
+        programmer: FunctionalAssertParametersProgrammer.write,
+      }),
+    assertEqualsReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertEqualsReturn",
+        equals: true,
+        programmer: FunctionAssertReturnProgrammer.write,
+      }),
+  },
   http: {
     // FORM-DATA
     formData: () => HttpFormDataTransformer.transform,

package/src/transformers/features/functional/FunctionalGenericTransformer.ts

@@ -0,0 +1,60 @@
+import ts from "typescript";
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+import { TypeFactory } from "../../../factories/TypeFactory";
+
+export namespace FunctionalGenericTransformer {
+  export const transform =
+    (props: {
+      method: string;
+      programmer: (
+        project: IProject,
+      ) => (
+        modulo: ts.LeftHandSideExpression,
+      ) => (
+        equals: boolean,
+      ) => (
+        expression: ts.CallExpression,
+        declaration: ts.FunctionDeclaration,
+        init?: ts.Expression,
+      ) => ts.Expression;
+      equals: boolean;
+    }) =>
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (expression: ts.CallExpression) => {
+      // CHECK PARAMETER
+      if (expression.arguments.length === 0)
+        throw new TransformerError({
+          code: `typia.functional.${props.method}`,
+          message: `no input value.`,
+        });
+
+      // GET TYPE INFO
+      const [type, generic]: [ts.Type, boolean] =
+        expression.typeArguments && expression.typeArguments[0]
+          ? [
+              project.checker.getTypeFromTypeNode(expression.typeArguments[0]),
+              true,
+            ]
+          : [
+              project.checker.getTypeAtLocation(expression.arguments[0]!),
+              false,
+            ];
+      if (generic === true)
+        throw new TransformerError({
+          code: `typia.functional.${props.method}`,
+          message: `non-specified generic argument.`,
+        });
+      else if (TypeFactory.isFunction(type) === false)
+        throw new TransformerError({
+          code: `typia.functional.${props.method}`,
+          message: `input value is not a function.`,
+        });
+      return props.programmer(project)(modulo)(props.equals)(
+        expression,
+        type.symbol!.declarations![0] as ts.FunctionDeclaration,
+        expression.arguments[1],
+      );
+    };
+}