typia 5.2.6 → 5.2.7-dev.20231109

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -16,27 +16,27 @@ import { NameEncoder } from "../../utils/NameEncoder";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
 
 export namespace ProtobufMessageProgrammer {
-    export const write =
-        ({ checker }: IProject) =>
-        (type: ts.Type) => {
-            // PARSE TARGET TYPE
-            const collection: MetadataCollection = new MetadataCollection();
-            ProtobufFactory.metadata("message")(checker)(collection)(type);
-
-            // STRINGIFY
-            const hierarchies: Map<string, Hierarchy> = new Map();
-            for (const obj of collection.objects())
-                if (is_dynamic_object(obj) === false) emplace(hierarchies)(obj);
-
-            const content: string =
-                `syntax = "proto3";\n\n` +
-                [...hierarchies.values()]
-                    .map((hier) => write_hierarchy(hier))
-                    .join("\n\n");
-
-            // RETURNS
-            return ts.factory.createStringLiteral(content);
-        };
+    export const write = (project: IProject) => (type: ts.Type) => {
+        // PARSE TARGET TYPE
+        const collection: MetadataCollection = new MetadataCollection();
+        ProtobufFactory.metadata("message")(project.checker, project.context)(
+            collection,
+        )(type);
+
+        // STRINGIFY
+        const hierarchies: Map<string, Hierarchy> = new Map();
+        for (const obj of collection.objects())
+            if (is_dynamic_object(obj) === false) emplace(hierarchies)(obj);
+
+        const content: string =
+            `syntax = "proto3";\n\n` +
+            [...hierarchies.values()]
+                .map((hier) => write_hierarchy(hier))
+                .join("\n\n");
+
+        // RETURNS
+        return ts.factory.createStringLiteral(content);
+    };
 
     const emplace = (dict: Map<string, Hierarchy>) => (obj: MetadataObject) => {
         const accessors: string[] = obj.name.split(".");

package/src/schemas/json/IJsonSchema.ts

@@ -72,6 +72,7 @@ export namespace IJsonSchema {
         minItems?: undefined | (number & Type<"uint32">);
         maxItems?: undefined | (number & Type<"uint32">);
         "x-typia-tuple"?: undefined | ITuple;
+        "x-typia-typeTags"?: undefined | IMetadataTypeTag[];
     }
     export interface ITuple extends ISignificant<"array"> {
         items: IJsonSchema[];

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -1,3 +1,5 @@
+import type ts from "typescript";
+
 export interface IMetadataTypeTag {
     target: "boolean" | "bigint" | "number" | "string" | "array";
     name: string;
@@ -5,4 +7,9 @@ export interface IMetadataTypeTag {
     value: any;
     validate: string | undefined;
     exclusive: boolean | string[];
+
+    /**
+     * @internal
+     */
+    predicate?: (input: ts.Expression) => ts.Expression;
 }

package/src/schemas/metadata/Metadata.ts

@@ -119,12 +119,7 @@ export class Metadata {
             nullable: this.nullable,
             functional: this.functional,
 
-            atomics: this.atomics.map((a) =>
-                MetadataAtomic.create({
-                    type: a.type,
-                    tags: a.tags.map((r) => r.slice()),
-                }),
-            ),
+            atomics: this.atomics.map((a) => a.toJSON()),
             constants: this.constants.map((c) => ({
                 type: c.type,
                 values: c.values.slice() as any,

package/src/schemas/metadata/MetadataAtomic.ts

@@ -1,5 +1,6 @@
 import { ClassProperties } from "../../typings/ClassProperties";
 
+import { IMetadataAtomic } from "./IMetadataAtomic";
 import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export class MetadataAtomic {
@@ -39,4 +40,20 @@ export class MetadataAtomic {
             return `(${this.type} & (${rows.join(" | ")}))`;
         })());
     }
+
+    public toJSON(): IMetadataAtomic {
+        return {
+            type: this.type,
+            tags: this.tags.map((row) =>
+                row.map((tag) => ({
+                    target: tag.target,
+                    name: tag.name,
+                    kind: tag.kind,
+                    value: tag.value,
+                    validate: tag.validate,
+                    exclusive: tag.exclusive,
+                })),
+            ),
+        };
+    }
 }

package/src/transform.ts

@@ -1,35 +1,35 @@
-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 | undefined,
-    extras: IProject["extras"],
-): ts.TransformerFactory<ts.SourceFile> => {
-    const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
-    const strict: boolean =
-        compilerOptions.strictNullChecks !== undefined
-            ? !!compilerOptions.strictNullChecks
-            : !!compilerOptions.strict;
-    if (strict === false)
-        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 ?? {},
-        extras,
-    });
-};
-export default transform;
+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 | undefined,
+    extras: IProject["extras"],
+): ts.TransformerFactory<ts.SourceFile> => {
+    const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
+    const strict: boolean =
+        compilerOptions.strictNullChecks !== undefined
+            ? !!compilerOptions.strictNullChecks
+            : !!compilerOptions.strict;
+    if (strict === false)
+        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 ?? {},
+        extras,
+    });
+};
+export default transform;

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

@@ -17,7 +17,7 @@ import { TransformerError } from "../../TransformerError";
 
 export namespace JsonApplicationTransformer {
     export const transform =
-        ({ checker }: IProject) =>
+        (project: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
                 throw new TransformerError({
@@ -36,7 +36,7 @@ export namespace JsonApplicationTransformer {
 
             // GET TYPES
             const types: ts.Type[] = top.elements.map((child) =>
-                checker.getTypeFromTypeNode(child as ts.TypeNode),
+                project.checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
             if (types.some((t) => t.isTypeParameter()))
                 throw new TransformerError({
@@ -46,7 +46,7 @@ export namespace JsonApplicationTransformer {
 
             // ADDITIONAL PARAMETERS
             const purpose: "swagger" | "ajv" = get_parameter(
-                checker,
+                project.checker,
                 "Purpose",
                 expression.typeArguments[1],
                 (str) => str === "swagger" || str === "ajv",
@@ -62,7 +62,10 @@ export namespace JsonApplicationTransformer {
             });
             const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
                 types.map((type) =>
-                    MetadataFactory.analyze(checker)({
+                    MetadataFactory.analyze(
+                        project.checker,
+                        project.context,
+                    )({
                         escape: true,
                         constant: true,
                         absorb: false,

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

@@ -12,7 +12,7 @@ import { TransformerError } from "../../TransformerError";
 
 export namespace MetadataTransformer {
     export const transform =
-        ({ checker }: IProject) =>
+        (project: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
                 throw new TransformerError({
@@ -28,7 +28,7 @@ export namespace MetadataTransformer {
 
             // GET TYPES
             const types: ts.Type[] = top.elements.map((child) =>
-                checker.getTypeFromTypeNode(child as ts.TypeNode),
+                project.checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
             if (types.some((t) => t.isTypeParameter()))
                 throw new TransformerError({
@@ -39,7 +39,10 @@ export namespace MetadataTransformer {
             // METADATA
             const collection: MetadataCollection = new MetadataCollection();
             const metadatas: Array<Metadata> = types.map((type) => {
-                const result = MetadataFactory.analyze(checker)({
+                const result = MetadataFactory.analyze(
+                    project.checker,
+                    project.context,
+                )({
                     escape: true,
                     constant: true,
                     absorb: true,