typia 5.0.0-dev.20230824 → 5.0.0-dev.20230828

package/src/tags/TagBase.ts

@@ -1,17 +1,22 @@
-export type TagBase<
-    Target extends "bigint" | "number" | "string" | "array",
-    Kind extends string,
-    Value extends boolean | bigint | number | string,
-    Validate extends
-        | string
-        | {
-              [key in Target]?: string;
-          },
-> = {
-    "typia.tag"?: {
+export type TagBase<Props extends TagBase.IProps<any, any, any, any, any>> = {
+    "typia.tag"?: Props;
+};
+export namespace TagBase {
+    export interface IProps<
+        Target extends "bigint" | "number" | "string" | "array",
+        Kind extends string,
+        Value extends boolean | bigint | number | string | undefined,
+        Validate extends
+            | string
+            | {
+                  [key in Target]?: string;
+              },
+        Exclusive extends boolean | string[],
+    > {
         target: Target;
         kind: Kind;
         value: Value;
         validate: Validate;
-    };
-};
+        exclusive?: Exclusive | string[];
+    }
+}

package/src/tags/Type.ts

@@ -1,30 +1,27 @@
+import { TagBase } from "./TagBase";
+
 export type Type<
-    Target extends
-        | "int"
-        | "uint"
-        | "int32"
-        | "uint32"
-        | "int64"
-        | "uint64"
-        | "float",
-> = {
-    "typia.tag"?: {
-        target: Target extends "uint64" ? "bigint" : "number" | "bigint";
-        kind: "type";
-        value: Target;
-        validate: Target extends "int" | "int32"
-            ? `Number.isInteger($input) && -2147483648 <= $input && $input <= 2147483647`
-            : Target extends "uint" | "uint32"
-            ? `Number.isInteger($input) && 0 <= $input && $input <= 4294967295`
-            : Target extends "int64"
-            ? {
-                  number: `Number.isInteger($input) && -9223372036854775808 <= $input && $input <= 9223372036854775807`;
-              }
-            : Target extends "uint64"
-            ? {
-                  number: `Number.isInteger($input) && 0 <= $input && $input <= 18446744073709551615`;
-                  bigint: `BigInt(0) <= $input && $input <= BigInt(18446744073709551615)`;
-              }
-            : `-1.175494351e38 <= $input <= 3.4028235e38`;
-    };
-};
+    Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double",
+> = TagBase<{
+    target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
+    kind: "type";
+    value: Value;
+    validate: Value extends "int32"
+        ? `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`
+        : Value extends "uint32"
+        ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`
+        : Value extends "int64"
+        ? {
+              number: `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`;
+              bigint: `true`;
+          }
+        : Value extends "uint64"
+        ? {
+              number: `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`;
+              bigint: `BigInt(0) <= $input`;
+          }
+        : Value extends "float"
+        ? `-1.175494351e38 <= $input && $input <= 3.4028235e38`
+        : `true`;
+    exclusive: true;
+}>;

package/src/tags/index.ts

@@ -7,6 +7,7 @@ export * from "./MaxLength";
 export * from "./Minimum";
 export * from "./MinItems";
 export * from "./MinLength";
+export * from "./MultipleOf";
 export * from "./Pattern";
 export * from "./TagBase";
 export * from "./Type";

package/src/transform.ts

@@ -1,11 +1,13 @@
 import ts from "typescript";
 
 import { FileTransformer } from "./transformers/FileTransformer";
+import { IProject } from "./transformers/IProject";
 import { ITransformOptions } from "./transformers/ITransformOptions";
 
 export const transform = (
     program: ts.Program,
-    options?: ITransformOptions,
+    options: ITransformOptions | undefined,
+    extras: IProject["extras"],
 ): ts.TransformerFactory<ts.SourceFile> => {
     const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
     const strict: boolean =
@@ -13,15 +15,21 @@ export const transform = (
             ? !!compilerOptions.strictNullChecks
             : !!compilerOptions.strict;
     if (strict === false)
-        throw new Error(
-            `Error on "tsconfig.json": typia requires \`compilerOptions.strictNullChecks\` to be true.`,
-        );
+        extras.addDiagnostic({
+            category: ts.DiagnosticCategory.Error,
+            code: "(typia)" as any,
+            file: undefined,
+            start: undefined,
+            length: undefined,
+            messageText: "strict mode is required.",
+        });
     return FileTransformer.transform({
         program,
         compilerOptions,
         checker: program.getTypeChecker(),
         printer: ts.createPrinter(),
-        options: options || {},
+        options: options ?? {},
+        extras,
     });
 };
 export default transform;

package/src/transformers/CallExpressionTransformer.ts

@@ -64,7 +64,7 @@ import { ProtobufValidateEncodeTransformer } from "./features/protobuf/ProtobufV
 export namespace CallExpressionTransformer {
     export const transform =
         (project: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
+        (expression: ts.CallExpression): ts.Expression | null => {
             //----
             // VALIDATIONS
             //----
@@ -95,7 +95,10 @@ export namespace CallExpressionTransformer {
             if (functor === undefined) return expression;
 
             // RETURNS WITH TRANSFORMATION
-            return functor()(project)(expression.expression)(expression);
+            const result: ts.Expression | null = functor()(project)(
+                expression.expression,
+            )(expression);
+            return result ?? expression;
         };
 
     const isTarget = (location: string): boolean => {
@@ -126,7 +129,7 @@ type Task = (
     project: IProject,
 ) => (
     modulo: ts.LeftHandSideExpression,
-) => (expression: ts.CallExpression) => ts.Expression;
+) => (expression: ts.CallExpression) => ts.Expression | null;
 
 const FUNCTORS: Record<string, Record<string, () => Task>> = {
     module: {

package/src/transformers/FileTransformer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { NodeTransformer } from "./NodeTransformer";
+import { TransformerError } from "./TransformerError";
 
 export namespace FileTransformer {
     export const transform =
@@ -19,29 +20,40 @@ export namespace FileTransformer {
     const iterate_node =
         (project: IProject) =>
         (context: ts.TransformationContext) =>
-        (node: ts.Node): ts.Node =>
-            ts.visitEachChild(
-                try_transform_node(project)(node),
+        (node: ts.Node): ts.Node => {
+            const changed: ts.Node | null = try_transform_node(project)(node);
+            return ts.visitEachChild(
+                changed ?? node,
                 (child) => iterate_node(project)(context)(child),
                 context,
             );
+        };
 
     const try_transform_node =
         (project: IProject) =>
-        (node: ts.Node): ts.Node => {
+        (node: ts.Node): ts.Node | null => {
             try {
                 return NodeTransformer.transform(project)(node);
             } catch (exp) {
-                if (!(exp instanceof Error)) throw exp;
+                // ONLY ACCEPT TRANSFORMER-ERROR
+                if (!isTransformerError(exp)) throw exp;
 
-                const file: ts.SourceFile = node.getSourceFile();
-                const { line, character } = file.getLineAndCharacterOfPosition(
-                    node.pos,
-                );
-                exp.message += ` - ${file.fileName}:${line + 1}:${
-                    character + 1
-                }`;
-                throw exp;
+                // REPORT DIAGNOSTIC
+                const diagnostic = ts.createDiagnosticForNode(node, {
+                    key: exp.code,
+                    category: ts.DiagnosticCategory.Error,
+                    message: exp.message,
+                    code: `(${exp.code})` as any,
+                });
+                project.extras.addDiagnostic(diagnostic);
+                return null;
             }
         };
 }
+
+const isTransformerError = (error: any): error is TransformerError =>
+    typeof error === "object" &&
+    error !== null &&
+    error.constructor.name === "TransformerError" &&
+    typeof error.code === "string" &&
+    typeof error.message === "string";

package/src/transformers/IProject.ts

@@ -9,4 +9,7 @@ export interface IProject {
     printer: ts.Printer;
     options: ITransformOptions;
     context: ts.TransformationContext;
+    extras: {
+        addDiagnostic: (diag: ts.Diagnostic) => number;
+    };
 }

package/src/transformers/NodeTransformer.ts

@@ -6,7 +6,7 @@ import { IProject } from "./IProject";
 export namespace NodeTransformer {
     export const transform =
         (project: IProject) =>
-        (expression: ts.Node): ts.Node =>
+        (expression: ts.Node): ts.Node | null =>
             ts.isCallExpression(expression)
                 ? CallExpressionTransformer.transform(project)(expression)
                 : expression;

package/src/transformers/TransformerError.ts

@@ -0,0 +1,55 @@
+import { MetadataFactory } from "../factories/MetadataFactory";
+
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+
+import { Escaper } from "../utils/Escaper";
+
+export class TransformerError extends Error {
+    public readonly code: string;
+
+    public constructor(props: TransformerError.IProps) {
+        super(props.message);
+        this.code = props.code;
+
+        // INHERITANCE POLYFILL
+        const proto = new.target.prototype;
+        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+        else (this as any).__proto__ = proto;
+    }
+}
+export namespace TransformerError {
+    export interface IProps {
+        code: string;
+        message: string;
+    }
+
+    export const from =
+        (method: string) =>
+        (errors: MetadataFactory.IError[]): TransformerError => {
+            const body: string = errors
+                .map((e) => {
+                    const subject: string =
+                        e.explore.object === null
+                            ? ""
+                            : join(e.explore.object)(e.explore.property);
+                    const type: string = `${
+                        subject.length ? `${subject}: ` : ""
+                    }${e.name}`;
+                    return `- ${type}\n${e.messages
+                        .map((msg) => `  - ${msg}`)
+                        .join("\n")}`;
+                })
+                .join("\n\n");
+            return new TransformerError({
+                code: method,
+                message: `unsupported type detected\n\n${body}`,
+            });
+        };
+
+    const join = (object: MetadataObject) => (key: string | object | null) => {
+        if (key === null) return object.name;
+        else if (typeof key === "object") return `${object.name}[key]`;
+        else if (Escaper.variable(key)) return `${object.name}.${key}`;
+        return `${object.name}[${JSON.stringify(key)}]`;
+    };
+}

package/src/transformers/features/CreateRandomTransformer.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
 import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
 
 export namespace CreateRandomTransformer {
     export const transform =
@@ -10,13 +11,21 @@ export namespace CreateRandomTransformer {
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: "typia.createRandom",
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: "typia.createRandom",
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return RandomProgrammer.write({
@@ -32,8 +41,3 @@ export namespace CreateRandomTransformer {
             );
         };
 }
-
-const NOT_SPECIFIED =
-    "Error on typia.createRandom(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.createRandom(): non-specified generic argument.";

package/src/transformers/features/RandomTransformer.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
 import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
 
 export namespace RandomTransformer {
     export const transform =
@@ -10,13 +11,21 @@ export namespace RandomTransformer {
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: `typia.${modulo.getText()}`,
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: `typia.${modulo.getText()}`,
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return ts.factory.createCallExpression(
@@ -35,8 +44,3 @@ export namespace RandomTransformer {
             );
         };
 }
-
-const NOT_SPECIFIED =
-    "Error on typia.random(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.random(): non-specified generic argument.";

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { JsonMetadataFactory } from "../../../factories/JsonMetadataFactory";
 import { LiteralFactory } from "../../../factories/LiteralFactory";
 import { MetadataCollection } from "../../../factories/MetadataCollection";
 import { MetadataFactory } from "../../../factories/MetadataFactory";
@@ -9,14 +10,20 @@ import { Metadata } from "../../../schemas/metadata/Metadata";
 
 import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
 
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
 import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
 
 export namespace JsonApplicationTransformer {
     export const transform =
         ({ checker }: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "typia.json.application",
+                    message: "no generic argument.",
+                });
 
             //----
             // GET ARGUMENTS
@@ -32,7 +39,10 @@ export namespace JsonApplicationTransformer {
                 checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
             if (types.some((t) => t.isTypeParameter()))
-                throw new Error(GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "typia.json.application",
+                    message: "non-specified generic argument(s).",
+                });
 
             // ADDITIONAL PARAMETERS
             const purpose: "swagger" | "ajv" = get_parameter(
@@ -48,24 +58,25 @@ export namespace JsonApplicationTransformer {
             //----
             // METADATA
             const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
-                    escape: true,
-                    constant: true,
-                    absorb: false,
-                    validate: (meta) => {
-                        if (meta.atomics.find((atom) => atom.type === "bigint"))
-                            throw new Error(NO_BIGIT);
-                        else if (
-                            meta.arrays.some(
-                                (array) =>
-                                    array.type.value.isRequired() === false,
-                            )
-                        )
-                            throw new Error(NO_UNDEFINED_IN_ARRAY);
-                    },
-                })(collection)(type),
-            );
+            const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
+                types.map((type) =>
+                    MetadataFactory.analyze(checker)({
+                        escape: true,
+                        constant: true,
+                        absorb: false,
+                        validate: JsonMetadataFactory.validate,
+                    })(collection)(type),
+                );
+
+            // REPORT BUG IF REQUIRED
+            const metadatas: Metadata[] = [];
+            const errors: MetadataFactory.IError[] = [];
+            for (const r of results) {
+                if (r.success === false) errors.push(...r.errors);
+                else metadatas.push(r.data);
+            }
+            if (errors.length)
+                throw TransformerError.from("typia.json.application")(errors);
 
             // APPLICATION
             const app: IJsonApplication = JsonApplicationProgrammer.write({
@@ -88,25 +99,18 @@ export namespace JsonApplicationTransformer {
         // CHECK LITERAL TYPE
         const type: ts.Type = checker.getTypeFromTypeNode(node);
         if (!type.isLiteral())
-            throw new Error(
-                `Error on typia.application(): generic argument "${name}" must be constant.`,
-            );
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: `generic argument "${name}" must be constant.`,
+            });
 
         // GET VALUE AND VALIDATE IT
         const value = type.value;
         if (typeof value !== "string" || predicator(value) === false)
-            throw new Error(
-                `Error on typia.application(): invalid value on generic argument "${name}".`,
-            );
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: `invalid value on generic argument "${name}".`,
+            });
         return value as T;
     };
 }
-
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.json.application(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.json.application(): non-specified generic argument(s).";
-const NO_BIGIT =
-    "Error on typia.json.application(): does not allow bigint type.";
-const NO_UNDEFINED_IN_ARRAY =
-    "Error on typia.json.application(): does not allow undefined type in array.";

package/src/transformers/features/misc/MetadataTransformer.ts

@@ -8,13 +8,17 @@ import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplica
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
 import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
 
 export namespace MetadataTransformer {
     export const transform =
         ({ checker }: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "typia.metadata",
+                    message: "no generic argument.",
+                });
 
             // VALIDATE TUPLE ARGUMENTS
             const top: ts.Node = expression.typeArguments[0]!;
@@ -27,17 +31,25 @@ export namespace MetadataTransformer {
                 checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
             if (types.some((t) => t.isTypeParameter()))
-                throw new Error(GENERIC_ARGUMENT);
+                throw new TransformerError({
+                    code: "typia.metadata",
+                    message: "non-specified generic argument(s).",
+                });
 
             // METADATA
             const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
+            const metadatas: Array<Metadata> = types.map((type) => {
+                const result = MetadataFactory.analyze(checker)({
                     escape: true,
                     constant: true,
                     absorb: true,
-                })(collection)(type),
-            );
+                })(collection)(type);
+                if (result.success === false)
+                    throw TransformerError.from("typia.metadata")(
+                        result.errors,
+                    );
+                return result.data;
+            });
 
             // CONVERT TO PRIMITIVE TYPE
             const app: IMetadataApplication = {
@@ -47,7 +59,3 @@ export namespace MetadataTransformer {
             return LiteralFactory.generate(app);
         };
 }
-
-const NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.metadata(): non-specified generic argument(s).";

package/src/transformers/features/misc/MiscCreateIsPruneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
+import { MiscIsPruneProgrammer } from "../../../programmers/misc/MiscIsPruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscCreateIsPruneTransformer {
     export const transform = GenericTransformer.factory("createIsPrune")(
-        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscIsPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscIsPruneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
+import { MiscIsPruneProgrammer } from "../../../programmers/misc/MiscIsPruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscIsPruneTransformer {
     export const transform = GenericTransformer.scalar("isPrune")(
-        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscIsPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/misc/MiscLiteralsTransformer.ts

@@ -3,26 +3,30 @@ import ts from "typescript";
 import { MiscLiteralsProgrammer } from "../../../programmers/misc/MiscLiteralsProgrammer";
 
 import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
 
 export namespace MiscLiteralsTransformer {
     export const transform =
         (project: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: "typia.misc.literals",
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: "typia.misc.literals",
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return MiscLiteralsProgrammer.write(project)(type);
         };
 }
-
-const NOT_SPECIFIED =
-    "Error on typia.literals(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.literals(): non-specified generic argument.";