typia 5.0.0-dev.20230827 → 5.0.0-dev.20230829

package/src/programmers/internal/{application_resolved.ts → application_escaped.ts}

@@ -5,7 +5,7 @@ import { IJsonComponents, IJsonSchema } from "../../module";
 import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
 import { application_schema } from "./application_schema";
 
-export const application_resolved =
+export const application_escaped =
     (options: JsonApplicationProgrammer.IOptions) =>
     <BlockNever extends boolean>(blockNever: BlockNever) =>
     (components: IJsonComponents) =>

package/src/programmers/internal/application_schema.ts

@@ -9,10 +9,10 @@ import { application_alias } from "./application_alias";
 import { application_array } from "./application_array";
 import { application_boolean } from "./application_boolean";
 import { application_constant } from "./application_constant";
+import { application_escaped } from "./application_escaped";
 import { application_native } from "./application_native";
 import { application_number } from "./application_number";
 import { application_object } from "./application_object";
-import { application_resolved } from "./application_resolved";
 import { application_string } from "./application_string";
 import { application_templates } from "./application_templates";
 import { application_tuple } from "./application_tuple";
@@ -61,7 +61,7 @@ export const application_schema =
         // toJSON() METHOD
         if (meta.escaped !== null)
             union.push(
-                ...application_resolved(options)(blockNever)(components)(
+                ...application_escaped(options)(blockNever)(components)(
                     meta.escaped,
                 )(attribute),
             );
@@ -70,7 +70,7 @@ export const application_schema =
         if (meta.templates.length && AtomicPredicator.template(meta))
             insert(application_templates(meta)(attribute));
         for (const constant of meta.constants)
-            if (constant.type === "bigint") throw new Error(NO_BIGINT);
+            if (constant.type === "bigint") throw new TypeError(NO_BIGINT);
             else if (
                 (constant.type === "string" && meta.templates.length) ||
                 AtomicPredicator.constant(meta)(constant.type) === false
@@ -78,7 +78,7 @@ export const application_schema =
                 continue;
             else insert(application_constant(constant)(attribute));
         for (const a of meta.atomics)
-            if (a.type === "bigint") throw new Error(NO_BIGINT);
+            if (a.type === "bigint") throw new TypeError(NO_BIGINT);
             else if (a.type === "boolean")
                 insert(application_boolean(attribute));
             else if (a.type === "number")
@@ -103,7 +103,7 @@ export const application_schema =
             if (AtomicPredicator.native(native)) {
                 const type: string = native.toLowerCase();
                 if (meta.atomics.some((a) => a.type === type)) continue;
-                else if (type === "bigint") throw new Error(NO_BIGINT);
+                else if (type === "bigint") throw new TypeError(NO_BIGINT);
                 else if (type === "boolean")
                     insert(application_boolean(attribute));
                 else if (type === "number")

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -3,6 +3,8 @@ import { IJsonComponents } from "../../schemas/json/IJsonComponents";
 import { IJsonSchema } from "../../schemas/json/IJsonSchema";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
+import { TransformerError } from "../../transformers/TransformerError";
+
 import { application_schema } from "../internal/application_schema";
 
 export namespace JsonApplicationProgrammer {
@@ -35,9 +37,10 @@ export namespace JsonApplicationProgrammer {
                 schemas: metadatas.map((meta, i) => {
                     const schema: IJsonSchema | null = generator(meta)({});
                     if (schema === null)
-                        throw new Error(
-                            `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
-                        );
+                        throw new TransformerError({
+                            code: "typia.json.application",
+                            message: `invalid type on argument - (${meta.getName()}, ${i})`,
+                        });
                     return schema;
                 }),
                 components,

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -12,8 +13,11 @@ export namespace JsonAssertParseProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+                project.checker,
+            )(type);
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
@@ -63,4 +67,5 @@ export namespace JsonAssertParseProgrammer {
                     ),
                 ]),
             );
+        };
 }

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -12,8 +13,11 @@ export namespace JsonIsParseProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+                project.checker,
+            )(type);
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
@@ -69,4 +73,5 @@ export namespace JsonIsParseProgrammer {
                     ),
                 ]),
             );
+        };
 }

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -2,8 +2,8 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 import { ValueFactory } from "../../factories/ValueFactory";
@@ -315,12 +315,7 @@ export namespace JsonStringifyProgrammer {
                     });
 
             // TUPLES
-            for (const tuple of meta.tuples) {
-                for (const child of tuple.type.elements)
-                    if (StringifyPredicator.undefindable(meta))
-                        throw new Error(
-                            `Error on typia.json.stringify(): tuple cannot contain undefined value - (${child.getName()}).`,
-                        );
+            for (const tuple of meta.tuples)
                 unions.push({
                     type: "tuple",
                     is: () =>
@@ -340,15 +335,9 @@ export namespace JsonStringifyProgrammer {
                             explore,
                         ),
                 });
-            }
 
             // ARRAYS
             if (meta.arrays.length) {
-                for (const child of meta.arrays)
-                    if (StringifyPredicator.undefindable(child.type.value))
-                        throw new Error(
-                            `Error on typia.json.stringify(): array cannot contain undefined value (${child.type.value.getName()}).`,
-                        );
                 const value: () => ts.Expression =
                     meta.arrays.length === 1
                         ? () =>
@@ -935,25 +924,11 @@ export namespace JsonStringifyProgrammer {
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
-        (type) => {
-            const collection: MetadataCollection = new MetadataCollection();
-            const meta: Metadata = MetadataFactory.analyze(checker)({
-                escape: true,
-                constant: true,
-                absorb: true,
-                validate: (meta) => {
-                    if (meta.atomics.find((a) => a.type === "bigint"))
-                        throw new Error(NO_BIGINT);
-                    else if (
-                        meta.arrays.some(
-                            (array) => array.type.value.isRequired() === false,
-                        )
-                    )
-                        throw new Error(NO_UNDEFINED_IN_ARRAY);
-                },
-            })(collection)(type);
-            return [collection, meta];
-        };
+        (importer) =>
+        (type) =>
+            JsonMetadataFactory.analyze(`typia.json.${importer.method}`)(
+                checker,
+            )(type);
 
     const create_throw_error =
         (importer: FunctionImporter) =>
@@ -987,8 +962,3 @@ interface IUnion {
     is: () => ts.Expression;
     value: () => ts.Expression;
 }
-
-const NO_BIGINT =
-    "Error on typia.json.stringify(): does not allow bigint type.";
-const NO_UNDEFINED_IN_ARRAY =
-    "Error on typia.json.stringify(): does not allow undefined type in array.";

package/src/programmers/json/JsonValidateParseProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -12,8 +13,11 @@ export namespace JsonValidateParseProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+                project.checker,
+            )(type);
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
@@ -60,4 +64,5 @@ export namespace JsonValidateParseProgrammer {
                     ),
                 ]),
             );
+        };
 }

package/src/programmers/json/JsonValidateStringifyProgrammer.ts

@@ -13,7 +13,7 @@ export namespace JsonValidateStringifyProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -13,6 +13,7 @@ import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
@@ -696,7 +697,7 @@ export namespace MiscCloneProgrammer {
                 prefix: PREFIX,
                 trace: false,
                 path: false,
-                initializer: initializer(importer.method),
+                initializer,
                 decoder: () => decode(project)(config)(importer),
                 objector: {
                     checker: () => IsProgrammer.decode(project)(importer),
@@ -720,27 +721,29 @@ export namespace MiscCloneProgrammer {
             return config;
         };
 
-    const initializer =
-        (method: string): FeatureProgrammer.IConfig["initializer"] =>
+    const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
+        (importer) =>
         (type) => {
             const collection = new MetadataCollection();
-            const meta = MetadataFactory.analyze(checker)({
+            const result = MetadataFactory.analyze(checker)({
                 escape: false,
                 constant: true,
                 absorb: true,
                 validate: (meta) => {
+                    const output: string[] = [];
                     if (meta.natives.some((n) => n === "WeakSet"))
-                        throw new Error(
-                            `Error on ${method}(): WeakSet is not supported.`,
-                        );
+                        output.push("unable to clone WeakSet");
                     else if (meta.natives.some((n) => n === "WeakMap"))
-                        throw new Error(
-                            `Error on ${method}(): WeakMap is not supported.`,
-                        );
+                        output.push("unable to clone WeakMap");
+                    return output;
                 },
             })(collection)(type);
-            return [collection, meta];
+            if (result.success === false)
+                throw TransformerError.from(`typia.misc.${importer.method}`)(
+                    result.errors,
+                );
+            return [collection, result.data];
         };
 
     const create_throw_error =

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -7,6 +7,7 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
 import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
 
 import { Atomic } from "../../typings/Atomic";
 
@@ -14,7 +15,7 @@ import { ArrayUtil } from "../../utils/ArrayUtil";
 
 export namespace MiscLiteralsProgrammer {
     export const write = (project: IProject) => (type: ts.Type) => {
-        const meta: Metadata = MetadataFactory.analyze(project.checker)({
+        const result = MetadataFactory.analyze(project.checker)({
             escape: true,
             constant: true,
             absorb: true,
@@ -24,11 +25,15 @@ export namespace MiscLiteralsProgrammer {
                         .map((c) => c.values.length)
                         .reduce((a, b) => a + b, 0) +
                     meta.atomics.filter((a) => a.type === "boolean").length;
-                if (0 === length) throw new Error(ErrorMessages.NO);
-                else if (meta.size() !== length)
-                    throw new Error(ErrorMessages.ONLY);
+                if (0 === length) return [ErrorMessages.NO];
+                else if (meta.size() !== length) return [ErrorMessages.ONLY];
+                return [];
             },
         })(new MetadataCollection())(type);
+        if (result.success === false)
+            throw TransformerError.from(`typia.misc.literals`)(result.errors);
+
+        const meta: Metadata = result.data;
         const values: Set<Atomic.Type | null> = new Set([
             ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
             ...(meta.atomics.filter((a) => a.type === "boolean").length
@@ -59,6 +64,6 @@ export namespace MiscLiteralsProgrammer {
 }
 
 enum ErrorMessages {
-    NO = "Error on typia.literals(): no literal type found.",
-    ONLY = "Error on typia.literals(): only literal type allowed.",
+    NO = "no constant literal type found.",
+    ONLY = "only constant literal types are allowed.",
 }

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -13,6 +13,7 @@ import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
@@ -506,14 +507,19 @@ export namespace MiscPruneProgrammer {
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
+        (importer) =>
         (type) => {
             const collection = new MetadataCollection();
-            const meta = MetadataFactory.analyze(checker)({
+            const result = MetadataFactory.analyze(checker)({
                 escape: false,
                 constant: true,
                 absorb: true,
             })(collection)(type);
-            return [collection, meta];
+            if (result.success === false)
+                throw TransformerError.from(`typia.misc.${importer.method}`)(
+                    result.errors,
+                );
+            return [collection, result.data];
         };
 
     const create_throw_error =

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -10,6 +10,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
@@ -529,7 +530,22 @@ export namespace ProtobufDecodeProgrammer {
                         ts.factory.createToken(ts.SyntaxKind.EqualsToken),
                         ts.factory.createIdentifier("entry.value"),
                     ),
-            })(top, required);
+            })(
+                MetadataProperty.create({
+                    ...top,
+                    key: (() => {
+                        const key: Metadata = Metadata.initialize();
+                        key.atomics.push(
+                            MetadataAtomic.create({
+                                type: "string",
+                                tags: [],
+                            }),
+                        );
+                        return key;
+                    })(),
+                }),
+                required,
+            );
         };
 
     const decode_map =

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -10,6 +10,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
@@ -364,6 +365,7 @@ export namespace ProtobufEncodeProgrammer {
                 });
 
             // RETURNS
+            // if (unions.length === 0) console.log(meta.getName());
             if (unions.length === 1) return wrapper(unions[0]!.value(index));
             else
                 return wrapper(
@@ -471,7 +473,19 @@ export namespace ProtobufEncodeProgrammer {
                         [],
                         [input],
                     ),
-                    top,
+                    MetadataProperty.create({
+                        ...top,
+                        key: (() => {
+                            const key: Metadata = Metadata.initialize();
+                            key.atomics.push(
+                                MetadataAtomic.create({
+                                    type: "string",
+                                    tags: [],
+                                }),
+                            );
+                            return key;
+                        })(),
+                    }),
                     explore,
                 );
             return ts.factory.createBlock(

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -4,7 +4,9 @@ import { MetadataCollection } from "../../factories/MetadataCollection";
 import { ProtobufFactory } from "../../factories/ProtobufFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -111,7 +113,22 @@ export namespace ProtobufMessageProgrammer {
             for (const obj of meta.objects)
                 elements.add(
                     is_dynamic_object(obj)
-                        ? decode_map(ptr)(obj.properties[0]!)
+                        ? decode_map(ptr)(
+                              MetadataProperty.create({
+                                  ...obj.properties[0]!,
+                                  key: (() => {
+                                      const key: Metadata =
+                                          Metadata.initialize();
+                                      key.atomics.push(
+                                          MetadataAtomic.create({
+                                              type: "string",
+                                              tags: [],
+                                          }),
+                                      );
+                                      return key;
+                                  })(),
+                              }),
+                          )
                         : NameEncoder.encode(obj.name),
                 );
             for (const map of meta.maps) elements.add(decode_map(ptr)(map));

package/src/schemas/metadata/Metadata.ts

@@ -236,7 +236,7 @@ export class Metadata {
             arrays: meta.arrays.map((ref) => {
                 const type = dict.arrays.get(ref.name);
                 if (type === undefined)
-                    throw new Error(
+                    throw new RangeError(
                         `Error on Metadata.from(): failed to find array "${ref.name}".`,
                     );
                 return MetadataArray.create({
@@ -247,7 +247,7 @@ export class Metadata {
             tuples: meta.tuples.map((t) => {
                 const type = dict.tuples.get(t.name);
                 if (type === undefined)
-                    throw new Error(
+                    throw new RangeError(
                         `Error on Metadata.from(): failed to find tuple "${t.name}".`,
                     );
                 return MetadataTuple.create({
@@ -258,7 +258,7 @@ export class Metadata {
             objects: meta.objects.map((name) => {
                 const found = dict.objects.get(name);
                 if (found === undefined)
-                    throw new Error(
+                    throw new RangeError(
                         `Error on Metadata.from(): failed to find object "${name}".`,
                     );
                 return found;
@@ -266,7 +266,7 @@ export class Metadata {
             aliases: meta.aliases.map((alias) => {
                 const found = dict.aliases.get(alias);
                 if (found === undefined)
-                    throw new Error(
+                    throw new RangeError(
                         `Error on Metadata.from(): failed to find alias "${alias}".`,
                     );
                 return found;

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: {