typia 5.0.0-dev.2023084 → 5.0.0

package/src/tags/MinItems.ts

@@ -1,8 +1,9 @@
-export type MinItems<Size extends number> = {
-    "typia.tag"?: {
-        targeet: "array";
-        kind: "minItems";
-        value: Size;
-        validate: `${Size} <= $input.length`;
-    };
-};
+import { TagBase } from "./TagBase";
+
+export type MinItems<Value extends number> = TagBase<{
+    target: "array";
+    kind: "minItems";
+    value: Value;
+    validate: `${Value} <= $input.length`;
+    exclusive: true;
+}>;

package/src/tags/MinLength.ts

@@ -1,8 +1,9 @@
-export type MinLength<Fixed extends number> = {
-    "typia.tag"?: {
-        target: "array";
-        kind: "minLength";
-        value: number;
-        validate: `${Fixed} <= $input.length`;
-    };
-};
+import { TagBase } from "./TagBase";
+
+export type MinLength<Value extends number> = TagBase<{
+    target: "string";
+    kind: "minLength";
+    value: Value;
+    validate: `${Value} <= $input.length`;
+    exclusive: true;
+}>;

package/src/tags/Minimum.ts

@@ -1,8 +1,13 @@
-export type Minimum<Fixed extends number | bigint> = {
-    "typia.tag"?: {
-        target: Fixed extends number ? "number" : "bigint";
-        kind: "minimum";
-        value: Fixed;
-        validate?: `${Fixed} <= $input`;
-    };
-};
+import { TagBase } from "./TagBase";
+
+export type Minimum<Value extends number | bigint> = TagBase<{
+    target: Value extends number ? "number" : "bigint";
+    kind: "minimum";
+    value: Value;
+    validate: `${Numeric<Value>} <= $input`;
+    exclusive: ["minimum", "exclusiveMinimum"];
+}>;
+
+type Numeric<Value extends number | bigint> = Value extends number
+    ? Value
+    : `BigInt(${Value})`;

package/src/tags/MultipleOf.ts

@@ -1,10 +1,15 @@
-export type MultipleOf<Fixed extends number | bigint> = {
-    "typia.tag"?: {
-        target: Fixed extends bigint ? "bigint" : "number";
-        kind: "multipleOf";
-        value: Fixed;
-        validate: `$input % ${Fixed} === ${Fixed extends bigint
-            ? "bigint"
-            : "number"}`;
-    };
-};
+import { TagBase } from "./TagBase";
+
+export type MultipleOf<Value extends number | bigint> = TagBase<{
+    target: Value extends bigint ? "bigint" : "number";
+    kind: "multipleOf";
+    value: Value;
+    validate: `$input % ${Numeric<Value>} === ${Value extends bigint
+        ? Numeric<0n>
+        : 0}`;
+    exclusive: true;
+}>;
+
+type Numeric<Value extends number | bigint> = Value extends number
+    ? Value
+    : `BigInt(${Value})`;

package/src/tags/Pattern.ts

@@ -1,8 +1,8 @@
-export type Pattern<Value extends string> = {
-    "typia.tag"?: {
-        target: "string";
-        kind: "pattern";
-        value: Value;
-        validate: `RegExp(/${Value}/).test($input)`;
-    };
-};
+import { TagBase } from "./TagBase";
+
+export type Pattern<Value extends string> = TagBase<{
+    target: "string";
+    kind: "pattern";
+    value: Value;
+    validate: `/${Value}/.test($input)`;
+}>;

package/src/tags/TagBase.ts

@@ -1,17 +1,68 @@
-export type TagBase<
-    Target extends "bigint" | "number" | "string" | "array",
-    Kind extends string,
-    Value,
-    Validate extends
-        | string
-        | {
-              [key in Target]?: string;
-          },
-> = {
-    "typia.tag"?: {
+export type TagBase<Props extends TagBase.IProps<any, any, any, any, any>> = {
+    /**
+     * This is a dummy property for compilation.
+     *
+     * It does not mean anything in runtime.
+     */
+    "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 type.
+         *
+         * If user tries to adapt this tag to a different type, it would be a compile
+         * error.
+         *
+         * For example, you've configured target type as `string`, but user adapted it
+         * onto a `number` type (`number & YourCustomTag<Value>`), then it would be
+         * blocked by TypeScript compiler.
+         */
         target: Target;
+
+        /**
+         * What kind of tag is this?
+         */
         kind: Kind;
+
+        /**
+         * Value to be configured by user.
+         */
         value: Value;
+
+        /**
+         * Validation script.
+         *
+         * This script would be inserted into the generated validation function.
+         * In here script, target variable name must be `$input`. The variable name
+         * `$input` would be transformed to the suitable when compilation.
+         *
+         * Also, If you've take a mistake on this script, compile error would be
+         * occured. So, define it with confidence. Compiler will block all your
+         * mistakes.
+         */
         validate: Validate;
-    };
-};
+
+        /**
+         * Exclusive option.
+         *
+         * If this property configured as `true`, same {@link kind} tag cannot be
+         * duplicated in the target type. Otherwise, if you've configured this
+         * property as string array, all of the {@link kind} value assigned
+         * tags cannot be compatible in the target type.
+         *
+         * @default false
+         */
+        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,16 +2,17 @@ import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { NodeTransformer } from "./NodeTransformer";
+import { TransformerError } from "./TransformerError";
 
 export namespace FileTransformer {
     export const transform =
-        (project: IProject) =>
+        (project: Omit<IProject, "context">) =>
         (context: ts.TransformationContext) =>
         (file: ts.SourceFile): ts.SourceFile => {
             if (file.isDeclarationFile) return file;
             return ts.visitEachChild(
                 file,
-                (node) => iterate_node(project)(context)(node),
+                (node) => iterate_node({ ...project, context })(context)(node),
                 context,
             );
         };
@@ -21,27 +22,36 @@ export namespace FileTransformer {
         (context: ts.TransformationContext) =>
         (node: ts.Node): ts.Node =>
             ts.visitEachChild(
-                try_transform_node(project)(node),
+                try_transform_node(project)(node) ?? 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

@@ -8,4 +8,8 @@ export interface IProject {
     checker: ts.TypeChecker;
     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.";