@typia/transform 12.0.0-dev.20260225

package/src/features/json/JsonApplicationTransformer.ts

@@ -0,0 +1,102 @@
+import {
+  JsonApplicationProgrammer,
+  LiteralFactory,
+  MetadataFactory,
+  MetadataSchema,
+  MetadataStorage,
+} from "@typia/core";
+import { IJsonSchemaApplication, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace JsonApplicationTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.json.application",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
+      checker: props.context.checker,
+      name: "Version",
+      is: (str) => str === "3.0" || str === "3.1",
+      cast: (str) => str as "3.0" | "3.1",
+      default: () => "3.1",
+    })(props.expression.typeArguments[1]);
+
+    // GET TYPE
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+    const collection: MetadataStorage = new MetadataStorage({
+      replace: MetadataStorage.replace,
+    });
+    const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+      MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: true,
+          constant: true,
+          absorb: false,
+          functional: true,
+          validate: JsonApplicationProgrammer.validate,
+        },
+        components: collection,
+        type,
+      });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: "typia.json.application",
+        errors: result.errors,
+      });
+
+    // GENERATE LLM APPLICATION
+    const app: IJsonSchemaApplication<"3.0" | "3.1"> =
+      JsonApplicationProgrammer.write({
+        version,
+        metadata: result.data,
+      });
+    const literal: ts.Expression = LiteralFactory.write(app);
+    return literal;
+  };
+
+  const get_parameter =
+    <Value>(props: {
+      checker: ts.TypeChecker;
+      name: string;
+      is: (value: string) => boolean;
+      cast: (value: string) => Value;
+      default: () => Value;
+    }) =>
+    (node: ts.TypeNode | undefined): Value => {
+      if (!node) return props.default();
+
+      // CHECK LITERAL TYPE
+      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
+      if (
+        !type.isLiteral() &&
+        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+      )
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `generic argument "${props.name}" must be constant.`,
+        });
+
+      // GET VALUE AND VALIDATE IT
+      const value = type.isLiteral()
+        ? type.value
+        : props.checker.typeToString(type);
+      if (typeof value !== "string" || props.is(value) === false)
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
+}

package/src/features/json/JsonAssertParseTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonAssertParseProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonAssertParseTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.assertParse",
+      write: JsonAssertParseProgrammer.write,
+    });
+}

package/src/features/json/JsonAssertStringifyTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonAssertStringifyProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonAssertStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.assertStringify",
+      write: JsonAssertStringifyProgrammer.write,
+    });
+}

package/src/features/json/JsonCreateAssertParseTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonAssertParseProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateAssertParseTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createAssertParse",
+      write: JsonAssertParseProgrammer.write,
+    });
+}

package/src/features/json/JsonCreateAssertStringifyTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonAssertStringifyProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateAssertStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createAssertStringify",
+      write: JsonAssertStringifyProgrammer.write,
+    });
+}

package/src/features/json/JsonCreateIsParseTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonIsParseProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateIsParseTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createIsParse",
+      write: JsonIsParseProgrammer.write,
+    });
+}

package/src/features/json/JsonCreateIsStringifyTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonIsStringifyProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateIsStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.stringify",
+      write: JsonIsStringifyProgrammer.write,
+    });
+}

package/src/features/json/JsonCreateStringifyTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonStringifyProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createStringify",
+      write: JsonStringifyProgrammer.write,
+    });
+}

package/src/features/json/JsonCreateValidateParseTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonValidateParseProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateValidateParseTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createValidateParse",
+      write: JsonValidateParseProgrammer.write,
+    });
+}

package/src/features/json/JsonCreateValidateStringifyProgrammer.ts

@@ -0,0 +1,13 @@
+import { JsonValidateStringifyProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateValidateStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createValidateStringify",
+      write: JsonValidateStringifyProgrammer.write,
+    });
+}

package/src/features/json/JsonIsParseTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonIsParseProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonIsParseTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.isParse",
+      write: JsonIsParseProgrammer.write,
+    });
+}

package/src/features/json/JsonIsStringifyTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonIsStringifyProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonIsStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.isStringify",
+      write: JsonIsStringifyProgrammer.write,
+    });
+}

package/src/features/json/JsonSchemaTransformer.ts

@@ -0,0 +1,132 @@
+import {
+  JsonSchemaProgrammer,
+  JsonSchemasProgrammer,
+  LiteralFactory,
+  MetadataFactory,
+  MetadataSchema,
+  MetadataStorage,
+} from "@typia/core";
+import { IJsonSchemaUnit, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace JsonSchemaTransformer {
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.json.schema",
+        message: "no generic argument.",
+      });
+
+    //----
+    // GET ARGUMENTS
+    //----
+    // VALIDATE TUPLE ARGUMENTS
+    const top: ts.Node | undefined = props.expression.typeArguments[0];
+    if (top === undefined || ts.isTypeNode(top) === false)
+      return props.expression;
+
+    // GET TYPES
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: "typia.json.schema",
+        message: "non-specified generic argument.",
+      });
+
+    // ADDITIONAL PARAMETERS
+    const version: "3.0" | "3.1" = getParameter<"3.0" | "3.1">({
+      checker: props.context.checker,
+      name: "Version",
+      is: (str) => str === "3.0" || str === "3.1",
+      cast: (str) => str as "3.0" | "3.1",
+      default: () => "3.1",
+    })(props.expression.typeArguments[1]);
+
+    //----
+    // GENERATORS
+    //----
+    // METADATA
+    const analyze = (validate: boolean): MetadataSchema => {
+      const results: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            constant: true,
+            escape: true,
+            validate:
+              validate === true ? JsonSchemasProgrammer.validate : undefined,
+          },
+          components: new MetadataStorage({
+            replace: MetadataStorage.replace,
+          }),
+          type,
+        });
+      if (results.success === false)
+        throw TransformerError.from({
+          code: "typia.json.schema",
+          errors: results.errors,
+        });
+      return results.data;
+    };
+    analyze(true);
+
+    // APPLICATION
+    const app: IJsonSchemaUnit<any> = JsonSchemaProgrammer.write({
+      version,
+      metadata: analyze(false),
+    });
+    return ts.factory.createAsExpression(
+      LiteralFactory.write(app),
+      props.context.importer.type({
+        file: "typia",
+        name: "IJsonSchemaUnit",
+        arguments: [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral(version),
+          ),
+        ],
+      }),
+    );
+  };
+
+  const getParameter =
+    <Value>(props: {
+      checker: ts.TypeChecker;
+      name: string;
+      is: (value: string) => boolean;
+      cast: (value: string) => Value;
+      default: () => Value;
+    }) =>
+    (node: ts.TypeNode | undefined): Value => {
+      if (!node) return props.default();
+
+      // CHECK LITERAL TYPE
+      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
+      if (
+        !type.isLiteral() &&
+        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+      )
+        throw new TransformerError({
+          code: "typia.json.schema",
+          message: `generic argument "${props.name}" must be constant.`,
+        });
+
+      // GET VALUE AND VALIDATE IT
+      const value = type.isLiteral()
+        ? type.value
+        : props.checker.typeToString(type);
+      if (typeof value !== "string" || props.is(value) === false)
+        throw new TransformerError({
+          code: "typia.json.schema",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
+}

package/src/features/json/JsonSchemasTransformer.ts

@@ -0,0 +1,142 @@
+import {
+  JsonSchemasProgrammer,
+  LiteralFactory,
+  MetadataFactory,
+  MetadataSchema,
+  MetadataStorage,
+} from "@typia/core";
+import { IJsonSchemaCollection, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace JsonSchemasTransformer {
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.json.schemas",
+        message: "no generic argument.",
+      });
+
+    //----
+    // GET ARGUMENTS
+    //----
+    // VALIDATE TUPLE ARGUMENTS
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (!ts.isTupleTypeNode(top)) return props.expression;
+    else if (top.elements.some((child) => !ts.isTypeNode(child)))
+      return props.expression;
+
+    // GET TYPES
+    const types: ts.Type[] = top.elements.map((child) =>
+      props.context.checker.getTypeFromTypeNode(child as ts.TypeNode),
+    );
+    if (types.some((t) => t.isTypeParameter()))
+      throw new TransformerError({
+        code: "typia.json.schemas",
+        message: "non-specified generic argument(s).",
+      });
+
+    // ADDITIONAL PARAMETERS
+    const version: "3.0" | "3.1" = getParameter<"3.0" | "3.1">({
+      checker: props.context.checker,
+      name: "Version",
+      is: (str) => str === "3.0" || str === "3.1",
+      cast: (str) => str as "3.0" | "3.1",
+      default: () => "3.1",
+    })(props.expression.typeArguments[1]);
+
+    //----
+    // GENERATORS
+    //----
+    // METADATA
+    const analyze = (validate: boolean): MetadataSchema[] => {
+      const results: ValidationPipe<MetadataSchema, MetadataFactory.IError>[] =
+        types.map((type) =>
+          MetadataFactory.analyze({
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            options: {
+              absorb: validate,
+              constant: true,
+              escape: true,
+              validate:
+                validate === true ? JsonSchemasProgrammer.validate : undefined,
+            },
+            components: new MetadataStorage({
+              replace: MetadataStorage.replace,
+            }),
+            type,
+          }),
+        );
+      const metadatas: MetadataSchema[] = [];
+      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({
+          code: "typia.json.schemas",
+          errors,
+        });
+      return metadatas;
+    };
+    analyze(true);
+
+    // APPLICATION
+    const collection: IJsonSchemaCollection<any> = JsonSchemasProgrammer.write({
+      version,
+      metadatas: analyze(false),
+    });
+    return ts.factory.createAsExpression(
+      LiteralFactory.write(collection),
+      props.context.importer.type({
+        file: "typia",
+        name: "IJsonSchemaCollection",
+        arguments: [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral(version),
+          ),
+        ],
+      }),
+    );
+  };
+
+  const getParameter =
+    <Value>(props: {
+      checker: ts.TypeChecker;
+      name: string;
+      is: (value: string) => boolean;
+      cast: (value: string) => Value;
+      default: () => Value;
+    }) =>
+    (node: ts.TypeNode | undefined): Value => {
+      if (!node) return props.default();
+
+      // CHECK LITERAL TYPE
+      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
+      if (
+        !type.isLiteral() &&
+        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+      )
+        throw new TransformerError({
+          code: "typia.json.schemas",
+          message: `generic argument "${props.name}" must be constant.`,
+        });
+
+      // GET VALUE AND VALIDATE IT
+      const value = type.isLiteral()
+        ? type.value
+        : props.checker.typeToString(type);
+      if (typeof value !== "string" || props.is(value) === false)
+        throw new TransformerError({
+          code: "typia.json.schemas",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
+}

package/src/features/json/JsonStringifyTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonStringifyProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.stringify",
+      write: JsonStringifyProgrammer.write,
+    });
+}

package/src/features/json/JsonValidateParseTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonValidateParseProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonValidateParseTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.validateParse",
+      write: JsonValidateParseProgrammer.write,
+    });
+}

package/src/features/json/JsonValidateStringifyTransformer.ts

@@ -0,0 +1,13 @@
+import { JsonValidateStringifyProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonValidateStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.validateStringify",
+      write: JsonValidateStringifyProgrammer.write,
+    });
+}