typia 5.0.0-dev.2023084 → 5.0.0

package/src/programmers/internal/check_template.ts

@@ -1,22 +1,14 @@
 import ts from "typescript";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_custom } from "./check_custom";
-import { check_string_tags } from "./check_string_tags";
 import { template_to_pattern } from "./template_to_pattern";
 
 /**
  * @internal
  */
 export const check_template =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: IJsDocTagInfo[]) =>
     (templates: Metadata[][]) =>
     (input: ts.Expression): ICheckEntry => {
         // TYPEOF STRING & TAGS
@@ -48,9 +40,22 @@ export const check_template =
             expression: conditions.reduce((x, y) =>
                 ts.factory.createLogicalAnd(x, y),
             ),
-            tags: [
-                ...check_string_tags(importer)(metaTags)(input),
-                ...check_custom("string")(importer)(jsDocTags)(input),
-            ],
+            conditions: [],
+            expected: templates
+                .map(
+                    (tpl) =>
+                        "`" +
+                        tpl
+                            .map((child) =>
+                                child.isConstant() && child.size() === 1
+                                    ? child.constants[0]!.values[0]!
+                                    : `$\{${child.getName()}\}`,
+                            )
+                            .join("")
+                            .split("`")
+                            .join("\\`") +
+                        "`",
+                )
+                .join(" | "),
         };
     };

package/src/programmers/internal/check_union_array_like.ts

@@ -4,8 +4,8 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 
 import { CheckerProgrammer } from "../CheckerProgrammer";
@@ -25,8 +25,6 @@ export const check_union_array_like =
         input: ts.Expression,
         origins: Origin[],
         explore: FeatureProgrammer.IExplore,
-        tags: IMetadataTag[],
-        jsDocTags: ts.JSDocTagInfo[],
     ): ts.ArrowFunction => {
         // ONLY ONE TYPE
         const targets: Array<Category> = origins.map(accessor.transform);
@@ -37,13 +35,7 @@ export const check_union_array_like =
                 parameters,
                 undefined,
                 undefined,
-                props.decoder(
-                    accessor.array(input),
-                    targets[0]!,
-                    explore,
-                    tags,
-                    jsDocTags,
-                ),
+                props.decoder(accessor.array(input), targets[0]!, explore),
             );
 
         const array = ts.factory.createIdentifier("array");
@@ -66,7 +58,7 @@ export const check_union_array_like =
                         [
                             IdentifierFactory.parameter(
                                 "top",
-                                meta instanceof MetadataArray
+                                meta instanceof MetadataArrayType
                                     ? TypeFactory.keyword("any")
                                     : ts.factory.createTypeReferenceNode(
                                           "any[]",
@@ -82,12 +74,10 @@ export const check_union_array_like =
                                 ...explore,
                                 tracable: false,
                                 postfix:
-                                    meta instanceof MetadataArray
+                                    meta instanceof MetadataArrayType
                                         ? `"[0]"`
                                         : "",
                             },
-                            tags,
-                            jsDocTags,
                             array,
                         ),
                     ),
@@ -109,8 +99,6 @@ export const check_union_array_like =
                                 ...explore,
                                 tracable: true,
                             },
-                            tags,
-                            jsDocTags,
                         ),
                     ),
                 ],
@@ -300,8 +288,6 @@ export namespace check_union_array_like {
             front: ts.Expression,
             target: Element,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
             container: ts.Expression,
         ): ts.Expression;
         decoder: UnionExplorer.Decoder<Category>;

package/src/programmers/internal/feature_object_entries.ts

@@ -41,23 +41,17 @@ export const feature_object_entries =
                 input: propInput,
                 key: prop.key,
                 meta: prop.value,
-                expression: config.decoder()(
-                    propInput,
-                    prop.value,
-                    {
-                        tracable: config.path || config.trace,
-                        source: "function",
-                        from,
-                        postfix:
-                            sole !== null
-                                ? IdentifierFactory.postfix(sole)
-                                : (() => {
-                                      importer.use("join");
-                                      return `$join(key)`;
-                                  })(),
-                    },
-                    prop.tags,
-                    prop.jsDocTags,
-                ),
+                expression: config.decoder()(propInput, prop.value, {
+                    tracable: config.path || config.trace,
+                    source: "function",
+                    from,
+                    postfix:
+                        sole !== null
+                            ? IdentifierFactory.postfix(sole)
+                            : (() => {
+                                  importer.use("join");
+                                  return `$join(key)`;
+                              })(),
+                }),
             };
         });

package/src/programmers/internal/metadata_to_pattern.ts

@@ -1,34 +1,34 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-import { PatternUtil } from "../../utils/PatternUtil";
-
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-export const metadata_to_pattern =
-    (top: boolean) =>
-    (meta: Metadata): string => {
-        if (meta.atomics.find((a) => a.type === "string") !== undefined)
-            return "(.*)";
-
-        const values: string[] = ArrayUtil.flat(
-            meta.constants.map((c) => {
-                if (c.type !== "string")
-                    return c.values.map((v) => v.toString());
-                return c.values.map((str) => PatternUtil.escape(str));
-            }),
-        );
-        for (const a of meta.atomics)
-            if (a.type === "number" || a.type === "bigint")
-                values.push(PatternUtil.NUMBER);
-            else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
-        for (const childTpl of meta.templates)
-            values.push("(" + template_to_pattern(false)(childTpl) + ")");
-
-        const pattern: string =
-            values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
-        return top ? PatternUtil.fix(pattern) : pattern;
-    };
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const metadata_to_pattern =
+    (top: boolean) =>
+    (meta: Metadata): string => {
+        if (meta.atomics.find((a) => a.type === "string") !== undefined)
+            return "(.*)";
+
+        const values: string[] = ArrayUtil.flat(
+            meta.constants.map((c) => {
+                if (c.type !== "string")
+                    return c.values.map((v) => v.toString());
+                return c.values.map((str) => PatternUtil.escape(str));
+            }),
+        );
+        for (const a of meta.atomics)
+            if (a.type === "number" || a.type === "bigint")
+                values.push(PatternUtil.NUMBER);
+            else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
+        for (const childTpl of meta.templates)
+            values.push("(" + template_to_pattern(false)(childTpl) + ")");
+
+        const pattern: string =
+            values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
+        return top ? PatternUtil.fix(pattern) : pattern;
+    };

package/src/programmers/internal/random_custom.ts

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { LiteralFactory } from "../../factories/LiteralFactory";
 
-import { ICommentTag } from "../../schemas/metadata/ICommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 
 import { Customizable } from "../../typings/Customizable";
 
@@ -13,7 +13,7 @@ import { Customizable } from "../../typings/Customizable";
 export const random_custom =
     (accessor: (name: string) => ts.Expression) =>
     (type: keyof Customizable) =>
-    (comments: ICommentTag[]) =>
+    (tags: IMetadataTypeTag[]) =>
     (expression: ts.Expression) =>
         ExpressionFactory.coalesce(
             ts.factory.createCallChain(
@@ -24,6 +24,14 @@ export const random_custom =
                 ),
                 ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
                 undefined,
-                [LiteralFactory.generate(comments)],
+                [
+                    LiteralFactory.generate(
+                        tags.map((t) => ({
+                            name: t.name,
+                            kind: t.kind,
+                            value: t.value,
+                        })),
+                    ),
+                ],
             ),
         )(expression);

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -1,171 +1,171 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { TemplateFactory } from "../../factories/TemplateFactory";
-
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const stringify_dynamic_properties = (
-    dynamic: IExpressionEntry<ts.Expression>[],
-    regular: string[],
-): ts.Expression => {
-    // BASIC STATMEMENT, CHECK UNDEFINED
-    const statements: ts.Statement[] = [
-        ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("undefined"),
-                ts.factory.createIdentifier("value"),
-            ),
-            ts.factory.createReturnStatement(
-                ts.factory.createStringLiteral(""),
-            ),
-        ),
-    ];
-
-    // PREPARE RETURN FUNCTION
-    const output = () => {
-        const mapped = ts.factory.createCallExpression(
-            IdentifierFactory.access(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Object.entries"),
-                    undefined,
-                    [ts.factory.createIdentifier("input")],
-                ),
-            )("map"),
-            undefined,
-            [
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [
-                        IdentifierFactory.parameter(
-                            ts.factory.createArrayBindingPattern([
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    "key",
-                                ),
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    "value",
-                                ),
-                            ]),
-                            ts.factory.createTypeReferenceNode("[string, any]"),
-                        ),
-                    ],
-                    undefined,
-                    undefined,
-                    ts.factory.createBlock(statements),
-                ),
-            ],
-        );
-        const filtered = ts.factory.createCallExpression(
-            IdentifierFactory.access(mapped)("filter"),
-            undefined,
-            [
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [IdentifierFactory.parameter("str")],
-                    undefined,
-                    undefined,
-                    ts.factory.createStrictInequality(
-                        ts.factory.createStringLiteral(""),
-                        ts.factory.createIdentifier("str"),
-                    ),
-                ),
-            ],
-        );
-        return ts.factory.createCallExpression(
-            IdentifierFactory.access(filtered)("join"),
-            undefined,
-            [ts.factory.createStringLiteral(",")],
-        );
-    };
-
-    // WHEN REGULAR PROPERTY EXISTS
-    if (regular.length)
-        statements.push(
-            ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                        ts.factory.createArrayLiteralExpression(
-                            regular.map((key) =>
-                                ts.factory.createStringLiteral(key),
-                            ),
-                        ),
-                    )("some"),
-                    undefined,
-                    [
-                        ts.factory.createArrowFunction(
-                            undefined,
-                            undefined,
-                            [IdentifierFactory.parameter("regular")],
-                            undefined,
-                            undefined,
-                            ts.factory.createStrictEquality(
-                                ts.factory.createIdentifier("regular"),
-                                ts.factory.createIdentifier("key"),
-                            ),
-                        ),
-                    ],
-                ),
-                ts.factory.createReturnStatement(
-                    ts.factory.createStringLiteral(""),
-                ),
-            ),
-        );
-
-    // ONLY STRING TYPED KEY EXISTS
-    const simple: boolean =
-        dynamic.length === 1 &&
-        dynamic[0]!.key.size() === 1 &&
-        dynamic[0]!.key.atomics[0]?.type === "string";
-    if (simple === true) {
-        statements.push(stringify(dynamic[0]!));
-        return output();
-    }
-
-    // COMPOSITE TEMPLATE LITERAL TYPES
-    for (const entry of dynamic) {
-        const condition: ts.IfStatement = ts.factory.createIfStatement(
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
-                    `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
-                ),
-                undefined,
-                [ts.factory.createIdentifier("key")],
-            ),
-            stringify(entry),
-        );
-        statements.push(condition);
-    }
-    statements.push(
-        ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
-    );
-
-    return output();
-};
-
-/**
- * @internal
- */
-const stringify = (
-    entry: IExpressionEntry<ts.Expression>,
-): ts.ReturnStatement =>
-    ts.factory.createReturnStatement(
-        TemplateFactory.generate([
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier("JSON.stringify"),
-                [],
-                [ts.factory.createIdentifier("key")],
-            ),
-            ts.factory.createStringLiteral(":"),
-            entry.expression,
-        ]),
-    );
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TemplateFactory } from "../../factories/TemplateFactory";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const stringify_dynamic_properties = (
+    dynamic: IExpressionEntry<ts.Expression>[],
+    regular: string[],
+): ts.Expression => {
+    // BASIC STATMEMENT, CHECK UNDEFINED
+    const statements: ts.Statement[] = [
+        ts.factory.createIfStatement(
+            ts.factory.createStrictEquality(
+                ts.factory.createIdentifier("undefined"),
+                ts.factory.createIdentifier("value"),
+            ),
+            ts.factory.createReturnStatement(
+                ts.factory.createStringLiteral(""),
+            ),
+        ),
+    ];
+
+    // PREPARE RETURN FUNCTION
+    const output = () => {
+        const mapped = ts.factory.createCallExpression(
+            IdentifierFactory.access(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("Object.entries"),
+                    undefined,
+                    [ts.factory.createIdentifier("input")],
+                ),
+            )("map"),
+            undefined,
+            [
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [
+                        IdentifierFactory.parameter(
+                            ts.factory.createArrayBindingPattern([
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    "key",
+                                ),
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    "value",
+                                ),
+                            ]),
+                            ts.factory.createTypeReferenceNode("[string, any]"),
+                        ),
+                    ],
+                    undefined,
+                    undefined,
+                    ts.factory.createBlock(statements),
+                ),
+            ],
+        );
+        const filtered = ts.factory.createCallExpression(
+            IdentifierFactory.access(mapped)("filter"),
+            undefined,
+            [
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [IdentifierFactory.parameter("str")],
+                    undefined,
+                    undefined,
+                    ts.factory.createStrictInequality(
+                        ts.factory.createStringLiteral(""),
+                        ts.factory.createIdentifier("str"),
+                    ),
+                ),
+            ],
+        );
+        return ts.factory.createCallExpression(
+            IdentifierFactory.access(filtered)("join"),
+            undefined,
+            [ts.factory.createStringLiteral(",")],
+        );
+    };
+
+    // WHEN REGULAR PROPERTY EXISTS
+    if (regular.length)
+        statements.push(
+            ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.access(
+                        ts.factory.createArrayLiteralExpression(
+                            regular.map((key) =>
+                                ts.factory.createStringLiteral(key),
+                            ),
+                        ),
+                    )("some"),
+                    undefined,
+                    [
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            [IdentifierFactory.parameter("regular")],
+                            undefined,
+                            undefined,
+                            ts.factory.createStrictEquality(
+                                ts.factory.createIdentifier("regular"),
+                                ts.factory.createIdentifier("key"),
+                            ),
+                        ),
+                    ],
+                ),
+                ts.factory.createReturnStatement(
+                    ts.factory.createStringLiteral(""),
+                ),
+            ),
+        );
+
+    // ONLY STRING TYPED KEY EXISTS
+    const simple: boolean =
+        dynamic.length === 1 &&
+        dynamic[0]!.key.size() === 1 &&
+        dynamic[0]!.key.atomics[0]?.type === "string";
+    if (simple === true) {
+        statements.push(stringify(dynamic[0]!));
+        return output();
+    }
+
+    // COMPOSITE TEMPLATE LITERAL TYPES
+    for (const entry of dynamic) {
+        const condition: ts.IfStatement = ts.factory.createIfStatement(
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                    `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+                ),
+                undefined,
+                [ts.factory.createIdentifier("key")],
+            ),
+            stringify(entry),
+        );
+        statements.push(condition);
+    }
+    statements.push(
+        ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
+    );
+
+    return output();
+};
+
+/**
+ * @internal
+ */
+const stringify = (
+    entry: IExpressionEntry<ts.Expression>,
+): ts.ReturnStatement =>
+    ts.factory.createReturnStatement(
+        TemplateFactory.generate([
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("JSON.stringify"),
+                [],
+                [ts.factory.createIdentifier("key")],
+            ),
+            ts.factory.createStringLiteral(":"),
+            entry.expression,
+        ]),
+    );

package/src/programmers/internal/wrap_metadata_rest_tuple.ts

@@ -1,15 +1,19 @@
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 
 export const wrap_metadata_rest_tuple = (rest: Metadata) => {
     const wrapper: Metadata = Metadata.initialize();
     wrapper.arrays.push(
         MetadataArray.create({
-            name: `...${rest.getName()}`,
-            value: rest,
-            nullables: [],
-            recursive: false,
-            index: null,
+            type: MetadataArrayType.create({
+                name: `...${rest.getName()}`,
+                value: rest,
+                nullables: [],
+                recursive: false,
+                index: null,
+            }),
+            tags: [],
         }),
     );
     return wrapper;

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,