typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/functional/FunctionalValidateFunctionProgrammer.ts

@@ -0,0 +1,113 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { FunctionalValidateParametersProgrammer } from "./FunctionalValidateParametersProgrammer";
+import { FunctionalValidateReturnProgrammer } from "./FunctionalValidateReturnProgrammer";
+
+export namespace FunctionalValidateFunctionProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.ArrowFunction => {
+      const { async, statements } =
+        FunctionalValidateReturnProgrammer.writeStatements(project)(modulo)(
+          equals,
+        )(expression, declaration);
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        getReturnTypeNode(declaration, async),
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...FunctionalValidateParametersProgrammer.writeStatements(project)(
+              modulo,
+            )(equals)(declaration),
+            ...statements,
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const hookErrors = (props: {
+    expression: ts.Expression;
+    replacer: ts.Expression;
+  }): ts.CallExpression =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(props.expression, "map"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [IdentifierFactory.parameter("error")],
+          undefined,
+          undefined,
+          ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createSpreadAssignment(
+                ts.factory.createIdentifier("error"),
+              ),
+              ts.factory.createPropertyAssignment(
+                "path",
+                ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier("error"),
+                      "path",
+                    ),
+                    "replace",
+                  ),
+                  undefined,
+                  [ts.factory.createStringLiteral("$input"), props.replacer],
+                ),
+              ),
+            ],
+            true,
+          ),
+        ),
+      ],
+    );
+
+  export const getReturnTypeNode = (
+    declaration: ts.FunctionDeclaration,
+    async: boolean,
+  ): ts.TypeNode | undefined =>
+    declaration.type
+      ? async
+        ? !!(declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
+          ? ts.factory.createTypeReferenceNode("Promise", [
+              ts.factory.createImportTypeNode(
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createStringLiteral("typia"),
+                ),
+                undefined,
+                ts.factory.createIdentifier("IValidation"),
+                [
+                  (declaration.type! as ts.TypeReferenceNode)
+                    .typeArguments![0]!,
+                ],
+              ),
+            ])
+          : undefined
+        : ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("IValidation"),
+            [declaration.type],
+          )
+      : undefined;
+}

package/src/programmers/functional/FunctionalValidateParametersProgrammer.ts

@@ -0,0 +1,203 @@
+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";
+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.ArrowFunction => {
+      const { 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()),
+        ),
+      );
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        FunctionalValidateFunctionProgrammer.getReturnTypeNode(
+          declaration,
+          async,
+        ),
+        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,107 @@
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFunctionProgrammer";
+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.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,
+        FunctionalValidateFunctionProgrammer.getReturnTypeNode(
+          declaration,
+          async,
+        ),
+        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 } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
+      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/functional/internal/FunctionalGeneralProgrammer.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { TypeFactory } from "../../../factories/TypeFactory";
+
+export namespace FunctionalGeneralProgrammer {
+  export interface IOutput {
+    type: ts.Type;
+    async: boolean;
+  }
+  export const getReturnType =
+    (checker: ts.TypeChecker) =>
+    (declaration: ts.FunctionDeclaration): IOutput => {
+      const signature: ts.Signature | undefined =
+        checker.getSignatureFromDeclaration(declaration);
+      const type: ts.Type =
+        signature?.getReturnType() ??
+        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 };
+    };
+}

package/src/programmers/helpers/AtomicPredicator.ts

@@ -8,7 +8,6 @@ export namespace AtomicPredicator {
   export const constant =
     (meta: Metadata) =>
     (name: Atomic.Literal): boolean =>
-      !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
       !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === name);
 
   export const atomic =
@@ -19,7 +18,7 @@ export namespace AtomicPredicator {
   export const native = (name: string) => LIKE.has(name.toLowerCase());
 
   export const template = (meta: Metadata): boolean =>
-    !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
+    !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === "string");
 }
 
 const LIKE = new Set(["boolean", "bigint", "number", "string"]);

package/src/programmers/helpers/FunctionImporeter.ts

@@ -0,0 +1 @@
+export * from "./FunctionImporter";

package/src/programmers/helpers/FunctionImporter.ts

@@ -2,9 +2,10 @@ 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_: Map<string, boolean> = new Map();
+  private readonly used_: Set<string> = new Set();
   private readonly local_: Set<string> = new Set();
   private readonly unions_: Map<string, [string, ts.ArrowFunction]> = new Map();
   private sequence_: number = 0;
@@ -15,8 +16,8 @@ export class FunctionImporter {
     return this.used_.size === 0;
   }
 
-  public use(name: string, currying: boolean = false): ts.Identifier {
-    this.used_.set(name, !!currying);
+  public use(name: string): ts.Identifier {
+    this.used_.add(name);
     return ts.factory.createIdentifier("$" + name);
   }
 
@@ -29,63 +30,21 @@ export class FunctionImporter {
     return this.local_.has(name);
   }
 
-  public declare(includeUnions: boolean = true): ts.Statement[] {
+  public declare(
+    modulo: ts.LeftHandSideExpression,
+    includeUnions: boolean = true,
+  ): ts.Statement[] {
     return [
-      ...(this.used_.size
-        ? [
-            ts.factory.createExpressionStatement(
-              ts.factory.createIdentifier("// @ts-ignore"),
+      ...[...this.used_].map((name) =>
+        StatementFactory.constant(
+          "$" + name,
+          IdentifierFactory.access(
+            ts.factory.createParenthesizedExpression(
+              ts.factory.createAsExpression(modulo, TypeFactory.keyword("any")),
             ),
-            ts.factory.createVariableStatement(
-              [ts.factory.createToken(ts.SyntaxKind.DeclareKeyword)],
-              ts.factory.createVariableDeclarationList(
-                [
-                  ts.factory.createVariableDeclaration(
-                    ts.factory.createIdentifier("require"),
-                    undefined,
-                    ts.factory.createFunctionTypeNode(
-                      undefined,
-                      [
-                        ts.factory.createParameterDeclaration(
-                          undefined,
-                          undefined,
-                          ts.factory.createIdentifier("lib"),
-                          undefined,
-                          ts.factory.createKeywordTypeNode(
-                            ts.SyntaxKind.StringKeyword,
-                          ),
-                          undefined,
-                        ),
-                      ],
-                      ts.factory.createKeywordTypeNode(
-                        ts.SyntaxKind.AnyKeyword,
-                      ),
-                    ),
-                    undefined,
-                  ),
-                ],
-                ts.NodeFlags.Const,
-              ),
-            ),
-          ]
-        : []),
-      ...[...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,
-        );
-      }),
+          )(name),
+        ),
+      ),
       ...(includeUnions === true
         ? [...this.unions_.values()].map(([key, arrow]) =>
             StatementFactory.constant(key, arrow),

package/src/programmers/helpers/ProtobufUtil.ts

@@ -26,7 +26,7 @@ export namespace ProtobufUtil {
       if (c.type === "boolean") set.add("bool");
       else if (c.type === "bigint") set.add("uint64");
       else if (c.type === "number")
-        set.add(deduce_numeric_type(c.values as number[]));
+        set.add(deduce_numeric_type(c.values.map((v) => v.value) as number[]));
       else if (c.type === "string") set.add("string");
     for (const atomic of meta.atomics)
       if (atomic.type === "boolean") set.add("bool");
@@ -43,7 +43,7 @@ export namespace ProtobufUtil {
     const set: Set<ProtobufAtomic.Numeric> = new Set();
     for (const c of meta.constants)
       if (c.type === "number")
-        set.add(deduce_numeric_type(c.values as number[]));
+        set.add(deduce_numeric_type(c.values.map((v) => v.value) as number[]));
     for (const atomic of meta.atomics)
       if (atomic.type === "number")
         decode_number(atomic.tags).forEach((t) => set.add(t));

package/src/programmers/helpers/PruneJoiner.ts

@@ -4,8 +4,6 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
 import { metadata_to_pattern } from "../internal/metadata_to_pattern";
 import { prune_object_properties } from "../internal/prune_object_properties";
 import { IExpressionEntry } from "./IExpressionEntry";
@@ -20,13 +18,13 @@ export namespace PruneJoiner {
     const regular = entries.filter((entry) => entry.key.isSoleLiteral());
     const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
 
-    const statements: ts.Statement[] = ArrayUtil.flat(
-      regular.map((entry) =>
+    const statements: ts.Statement[] = regular
+      .map((entry) =>
         ts.isBlock(entry.expression)
           ? [...entry.expression.statements]
           : [ts.factory.createExpressionStatement(entry.expression)],
-      ),
-    );
+      )
+      .flat();
     if (dynamic.length)
       statements.push(
         ts.factory.createExpressionStatement(
@@ -52,13 +50,13 @@ export namespace PruneJoiner {
     const entire: ts.ConciseBody[] = [...children];
     if (rest !== null) entire.push(rest);
 
-    const statements: ts.Statement[] = ArrayUtil.flat(
-      entire.map((elem) =>
+    const statements: ts.Statement[] = entire
+      .map((elem) =>
         ts.isBlock(elem)
           ? [...elem.statements]
           : [ts.factory.createExpressionStatement(elem)],
-      ),
-    );
+      )
+      .flat();
     return ts.factory.createBlock(statements, true);
   };
 }

package/src/programmers/helpers/StringifyJoinder.ts

@@ -65,13 +65,14 @@ export namespace StringifyJoiner {
     TemplateFactory.generate([
       ts.factory.createStringLiteral(`[`),
       ts.factory.createCallExpression(
-        IdentifierFactory.access(
+        ts.factory.createPropertyAccessExpression(
           ts.factory.createCallExpression(
             IdentifierFactory.access(input)("map"),
             undefined,
             [arrow],
           ),
-        )("join"),
+          ts.factory.createIdentifier("join"),
+        ),
         undefined,
         [ts.factory.createStringLiteral(`,`)],
       ),

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -9,11 +9,10 @@ export const disable_function_importer_declare = (
 const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
   method: importer.method,
   empty: (): boolean => importer.empty(),
-  use: (name: string, currying?: boolean): ts.Identifier =>
-    importer.use(name, currying),
+  use: (name: string): ts.Identifier => importer.use(name),
   useLocal: (name: string): string => importer.useLocal(name),
   hasLocal: (name: string): boolean => importer.hasLocal(name),
-  declare: (): ts.Statement[] => [],
+  declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
   declareUnions: (): ts.Statement[] => [],
   increment: (): number => importer.increment(),
   emplaceUnion: (
@@ -28,6 +27,6 @@ type MethodOnly<T> = {
   [P in keyof T]: T[P] extends Function
     ? T[P]
     : P extends "method"
-    ? T[P]
-    : never;
+      ? T[P]
+      : never;
 };