typia 5.2.6 → 5.3.0-dev.20231112

package/src/factories/MetadataFactory.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataAlias } from "../schemas/metadata/MetadataAlias";
 import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
+import { MetadataConstant } from "../schemas/metadata/MetadataConstant";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
 import { explore_metadata } from "./internal/metadata/explore_metadata";
@@ -11,6 +12,7 @@ import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort
 
 import { ValidationPipe } from "../typings/ValidationPipe";
 
+import { ExpressionFactory } from "./ExpressionFactory";
 import { MetadataCollection } from "./MetadataCollection";
 
 export namespace MetadataFactory {
@@ -40,7 +42,7 @@ export namespace MetadataFactory {
     }
 
     export const analyze =
-        (checker: ts.TypeChecker) =>
+        (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (collection: MetadataCollection) =>
         (type: ts.Type | null): ValidationPipe<Metadata, IError> => {
@@ -59,7 +61,9 @@ export namespace MetadataFactory {
             iterate_metadata_sort(collection)(meta);
 
             if (options.validate)
-                errors.push(...validate(options)(options.validate)(meta));
+                errors.push(
+                    ...validate(context)(options)(options.validate)(meta),
+                );
             return errors.length
                 ? {
                       success: false,
@@ -76,14 +80,17 @@ export namespace MetadataFactory {
      */
     export const soleLiteral = (value: string): Metadata => {
         const meta: Metadata = Metadata.initialize();
-        meta.constants.push({
-            values: [value],
-            type: "string",
-        });
+        meta.constants.push(
+            MetadataConstant.from({
+                values: [value],
+                type: "string",
+            }),
+        );
         return meta;
     };
 
     const validate =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (functor: Validator) =>
         (meta: Metadata): IError[] => {
@@ -95,7 +102,7 @@ export namespace MetadataFactory {
                 tuples: new Set(),
                 aliases: new Set(),
             };
-            validateMeta(options)(visitor)(meta, {
+            validateMeta(context)(options)(visitor)(meta, {
                 object: null,
                 property: null,
                 nested: null,
@@ -107,47 +114,70 @@ export namespace MetadataFactory {
         };
 
     const validateMeta =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (meta: Metadata, explore: IExplore) => {
-            const result: Set<string> = new Set(visitor.functor(meta, explore));
-            if (result.size)
+            const result: string[] = [];
+            if (context !== undefined)
+                for (const atomic of meta.atomics)
+                    for (const row of atomic.tags)
+                        for (const tag of row.filter(
+                            (t) =>
+                                t.validate !== undefined &&
+                                t.predicate === undefined,
+                        ))
+                            try {
+                                tag.predicate = ExpressionFactory.transpile(
+                                    context,
+                                )(tag.validate!);
+                            } catch {
+                                result.push(
+                                    `Unable to transpile type tag script: ${JSON.stringify(
+                                        tag.validate,
+                                    )}`,
+                                );
+                                tag.predicate = () => ts.factory.createTrue();
+                            }
+            result.push(...visitor.functor(meta, explore));
+            if (result.length)
                 visitor.errors.push({
                     name: meta.getName(),
                     explore: { ...explore },
-                    messages: [...result],
+                    messages: [...new Set(result)],
                 });
 
             for (const alias of meta.aliases)
-                validateAlias(options)(visitor)(alias, explore);
+                validateAlias(context)(options)(visitor)(alias, explore);
             for (const array of meta.arrays)
-                validateArray(options)(visitor)(array.type, explore);
+                validateArray(context)(options)(visitor)(array.type, explore);
             for (const tuple of meta.tuples)
-                validateTuple(options)(visitor)(tuple.type, explore);
+                validateTuple(context)(options)(visitor)(tuple.type, explore);
             for (const obj of meta.objects)
-                validateObject(options)(visitor)(obj);
+                validateObject(context)(options)(visitor)(obj);
             for (const set of meta.sets)
-                validateMeta(options)(visitor)(set, explore);
+                validateMeta(context)(options)(visitor)(set, explore);
             for (const map of meta.maps) {
-                validateMeta(options)(visitor)(map.key, explore);
-                validateMeta(options)(visitor)(map.value, explore);
+                validateMeta(context)(options)(visitor)(map.key, explore);
+                validateMeta(context)(options)(visitor)(map.value, explore);
             }
 
             if (options.escape === true && meta.escaped !== null)
-                validateMeta(options)(visitor)(meta.escaped.returns, {
+                validateMeta(context)(options)(visitor)(meta.escaped.returns, {
                     ...explore,
                     escaped: true,
                 });
         };
 
     const validateAlias =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (alias: MetadataAlias, explore: IExplore) => {
             if (visitor.aliases.has(alias)) return;
             visitor.aliases.add(alias);
 
-            validateMeta(options)(visitor)(alias.value, {
+            validateMeta(context)(options)(visitor)(alias.value, {
                 ...explore,
                 nested: alias,
                 aliased: true,
@@ -155,13 +185,14 @@ export namespace MetadataFactory {
         };
 
     const validateArray =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (array: MetadataArrayType, explore: IExplore) => {
             if (visitor.arrays.has(array)) return;
             visitor.arrays.add(array);
 
-            validateMeta(options)(visitor)(array.value, {
+            validateMeta(context)(options)(visitor)(array.value, {
                 ...explore,
                 nested: array,
                 top: false,
@@ -169,6 +200,7 @@ export namespace MetadataFactory {
         };
 
     const validateTuple =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (tuple: MetadataTupleType, explore: IExplore) => {
@@ -176,7 +208,7 @@ export namespace MetadataFactory {
             visitor.tuples.add(tuple);
 
             for (const elem of tuple.elements)
-                validateMeta(options)(visitor)(elem, {
+                validateMeta(context)(options)(visitor)(elem, {
                     ...explore,
                     nested: tuple,
                     top: false,
@@ -184,6 +216,7 @@ export namespace MetadataFactory {
         };
 
     const validateObject =
+        (context?: ts.TransformationContext) =>
         (options: IOptions) =>
         (visitor: IValidationVisitor) =>
         (object: MetadataObject) => {
@@ -215,7 +248,7 @@ export namespace MetadataFactory {
             }
 
             for (const property of object.properties)
-                validateMeta(options)(visitor)(property.value, {
+                validateMeta(context)(options)(visitor)(property.value, {
                     object,
                     property: property.key.isSoleLiteral()
                         ? property.key.getSoleLiteral()!

package/src/factories/NumericRangeFactory.ts

@@ -6,28 +6,67 @@ import { ExpressionFactory } from "./ExpressionFactory";
 
 export namespace NumericRangeFactory {
     export const number =
-        (context: ts.TransformationContext) =>
         (type: ProtobufAtomic.Numeric) =>
         (input: ts.Expression): ts.Expression =>
-            ExpressionFactory.transpile(context)(NUMBER_TEXT[type])(input);
+            NumberPredicator[type](input);
 
     export const bigint =
-        (context: ts.TransformationContext) =>
         (type: ProtobufAtomic.BigNumeric) =>
         (input: ts.Expression): ts.Expression =>
-            ExpressionFactory.transpile(context)(BIGINT_TEXT[type])(input);
+            BigIntPredicator[type](input);
 }
 
-const NUMBER_TEXT = {
-    int32: `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`,
-    uint32: `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`,
-    int64: `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`,
-    uint64: `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`,
-    float: `-1.175494351e38 <= $input && $input <= 3.4028235e38`,
-    double: `true`,
-};
-
-const BIGINT_TEXT = {
-    int64: `true`,
-    uint64: `BigInt(0) <= $input`,
-};
+namespace NumberPredicator {
+    export const int32 = (input: ts.Expression) =>
+        ts.factory.createLogicalAnd(
+            integer(input),
+            between("-2147483648", "2147483647")(input),
+        );
+    export const uint32 = (input: ts.Expression) =>
+        ts.factory.createLogicalAnd(
+            integer(input),
+            between("0", "4294967295")(input),
+        );
+    export const int64 = (input: ts.Expression) =>
+        ts.factory.createLogicalAnd(
+            integer(input),
+            between("-9223372036854775808", "9223372036854775807")(input),
+        );
+    export const uint64 = (input: ts.Expression) =>
+        ts.factory.createLogicalAnd(
+            integer(input),
+            between("0", "18446744073709551615")(input),
+        );
+    export const float = (input: ts.Expression) =>
+        between("-1.175494351e38", "3.4028235e38")(input);
+    export const double = () => ts.factory.createTrue();
+}
+
+namespace BigIntPredicator {
+    export const int64 = () => ts.factory.createTrue();
+    export const uint64 = (input: ts.Expression) =>
+        ts.factory.createLessThanEquals(
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("BigInt"),
+                undefined,
+                [ExpressionFactory.number(0)],
+            ),
+            input,
+        );
+}
+
+const integer = (input: ts.Expression) =>
+    ts.factory.createStrictEquality(
+        ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Math.floor"),
+            undefined,
+            [input],
+        ),
+        input,
+    );
+
+const between = (x: string, y: string) => (input: ts.Expression) =>
+    ts.factory.createLogicalAnd(
+        ts.factory.createLessThanEquals(ts.factory.createIdentifier(x), input),
+        ts.factory.createLessThanEquals(input, ts.factory.createIdentifier(y)),
+    );

package/src/factories/ProtobufFactory.ts

@@ -17,12 +17,15 @@ import { MetadataFactory } from "./MetadataFactory";
 export namespace ProtobufFactory {
     export const metadata =
         (method: string) =>
-        (checker: ts.TypeChecker) =>
+        (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
         (collection: MetadataCollection) =>
         (type: ts.Type): Metadata => {
             // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
             const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-                MetadataFactory.analyze(checker)({
+                MetadataFactory.analyze(
+                    checker,
+                    context,
+                )({
                     escape: false,
                     constant: true,
                     absorb: true,

package/src/factories/internal/metadata/MetadataHelper.ts

@@ -1,12 +1,15 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
 
 export namespace MetadataHelper {
     export const literal_to_metadata = (key: string): Metadata => {
         const metadata: Metadata = Metadata.initialize();
-        metadata.constants.push({
-            type: "string",
-            values: [key],
-        });
+        metadata.constants.push(
+            MetadataConstant.create({
+                type: "string",
+                values: [key],
+            }),
+        );
         return metadata;
     };
 }