typia 9.0.1 → 9.1.0

package/src/protobuf.ts

@@ -1,3 +1,5 @@
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
+
 import { IValidation } from "./IValidation";
 import { Resolved } from "./Resolved";
 import { TypeGuardError } from "./TypeGuardError";
@@ -57,7 +59,7 @@ export function message<T>(): string;
  * @internal
  */
 export function message(): never {
-  halt("message");
+  NoTransformConfigurationError("protobuf.message");
 }
 
 /* -----------------------------------------------------------
@@ -129,7 +131,7 @@ export function decode<T>(input: Uint8Array): Resolved<T>;
  * @internal
  */
 export function decode(): never {
-  halt("decode");
+  NoTransformConfigurationError("protobuf.decode");
 }
 
 /**
@@ -204,7 +206,7 @@ export function assertDecode<T>(
  * @internal
  */
 export function assertDecode(): never {
-  halt("assertDecode");
+  NoTransformConfigurationError("protobuf.assertDecode");
 }
 
 /**
@@ -271,7 +273,7 @@ export function isDecode<T>(input: Uint8Array): Resolved<T> | null;
  * @internal
  */
 export function isDecode(): never {
-  halt("isDecode");
+  NoTransformConfigurationError("protobuf.isDecode");
 }
 
 /**
@@ -340,7 +342,7 @@ export function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;
  * @internal
  */
 export function validateDecode(): never {
-  halt("validateDecode");
+  NoTransformConfigurationError("protobuf.validateDecode");
 }
 
 /* -----------------------------------------------------------
@@ -379,7 +381,7 @@ export function encode<T>(input: T): Uint8Array;
  * @internal
  */
 export function encode(): never {
-  halt("encode");
+  NoTransformConfigurationError("protobuf.encode");
 }
 
 /**
@@ -460,7 +462,7 @@ export function assertEncode<T>(
  * @internal
  */
 export function assertEncode(): never {
-  halt("assertEncode");
+  NoTransformConfigurationError("protobuf.assertEncode");
 }
 
 /**
@@ -533,7 +535,7 @@ export function isEncode<T>(input: unknown): Uint8Array | null;
  * @internal
  */
 export function isEncode(): never {
-  halt("isEncode");
+  NoTransformConfigurationError("protobuf.isEncode");
 }
 
 /**
@@ -608,7 +610,7 @@ export function validateEncode<T>(input: unknown): IValidation<Uint8Array>;
  * @internal
  */
 export function validateEncode(): never {
-  halt("validateEncode");
+  NoTransformConfigurationError("protobuf.validateEncode");
 }
 
 /* -----------------------------------------------------------
@@ -639,7 +641,7 @@ export function createDecode<T>(): (input: Uint8Array) => Resolved<T>;
  * @internal
  */
 export function createDecode<T>(): (input: Uint8Array) => Resolved<T> {
-  halt("createDecode");
+  NoTransformConfigurationError("protobuf.createDecode");
 }
 
 /**
@@ -667,7 +669,7 @@ export function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;
  * @internal
  */
 export function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null {
-  halt("createIsDecode");
+  NoTransformConfigurationError("protobuf.createIsDecode");
 }
 
 /**
@@ -701,7 +703,7 @@ export function createAssertDecode<T>(
  * @internal
  */
 export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
-  halt("createAssertDecode");
+  NoTransformConfigurationError("protobuf.createAssertDecode");
 }
 
 /**
@@ -733,7 +735,7 @@ export function createValidateDecode<T>(): (
 export function createValidateDecode<T>(): (
   input: Uint8Array,
 ) => IValidation<Resolved<T>> {
-  halt("createValidateDecode");
+  NoTransformConfigurationError("protobuf.createValidateDecode");
 }
 
 /**
@@ -761,7 +763,7 @@ export function createEncode<T>(): (input: T) => Uint8Array;
  * @internal
  */
 export function createEncode<T>(): (input: T) => Uint8Array {
-  halt("createEncode");
+  NoTransformConfigurationError("protobuf.createEncode");
 }
 
 /**
@@ -789,7 +791,7 @@ export function createIsEncode<T>(): (input: T) => Uint8Array | null;
  * @internal
  */
 export function createIsEncode<T>(): (input: T) => Uint8Array | null {
-  halt("createIsEncode");
+  NoTransformConfigurationError("protobuf.createIsEncode");
 }
 
 /**
@@ -823,7 +825,7 @@ export function createAssertEncode<T>(
  * @internal
  */
 export function createAssertEncode<T>(): (input: T) => Uint8Array {
-  halt("createAssertEncode");
+  NoTransformConfigurationError("protobuf.createAssertEncode");
 }
 
 /**
@@ -855,14 +857,5 @@ export function createValidateEncode<T>(): (
 export function createValidateEncode<T>(): (
   input: T,
 ) => IValidation<Uint8Array> {
-  halt("createValidateEncode");
-}
-
-/**
- * @internal
- */
-function halt(name: string): never {
-  throw new Error(
-    `Error on typia.protobuf.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`,
-  );
+  NoTransformConfigurationError("protobuf.createValidateEncode");
 }

package/src/reflect.ts

@@ -1,5 +1,7 @@
 import { IMetadataApplication } from "./schemas/metadata/IMetadataApplication";
 
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
+
 /**
  * > You must configure the generic argument `Types`.
  *
@@ -38,20 +40,11 @@ export function metadata<Types extends unknown[]>(): IMetadataApplication;
  * @internal
  */
 export function metadata(): never {
-  halt("metadata");
+  NoTransformConfigurationError("reflect.metadata");
 }
 
 export function name<T, Regular extends boolean = false>(): string;
 export function name(): never;
 export function name(): never {
-  halt("name");
-}
-
-/**
- * @internal
- */
-function halt(name: string): never {
-  throw new Error(
-    `Error on typia.reflect.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`,
-  );
+  NoTransformConfigurationError("reflect.name");
 }

package/src/schemas/json/IJsonSchemaUnit.ts

@@ -0,0 +1,32 @@
+import { OpenApi, OpenApiV3 } from "@samchon/openapi";
+
+/**
+ * Unit of JSON schema.
+ *
+ * `IJsonSchemaUnit` is a type that represents a single JSON schema unit
+ * containing the schema and components.
+ *
+ * @template Version Version of the OpenAPI specification
+ * @template Type Original TypeScript type used in the JSON schema
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type IJsonSchemaUnit<
+  Version extends "3.0" | "3.1" = "3.1",
+  Type = unknown,
+> = Version extends "3.0"
+  ? IJsonSchemaUnit.IV3_0<Type>
+  : IJsonSchemaUnit.IV3_1<Type>;
+export namespace IJsonSchemaUnit {
+  export interface IV3_0<Type> {
+    version: "3.0";
+    schema: OpenApiV3.IJsonSchema;
+    components: OpenApiV3.IComponents;
+    __type?: Type | undefined;
+  }
+  export interface IV3_1<Type> {
+    version: "3.1";
+    schema: OpenApi.IJsonSchema;
+    components: OpenApi.IComponents;
+    __type?: Type | undefined;
+  }
+}

package/src/transformers/CallExpressionTransformer.ts

@@ -62,6 +62,7 @@ import { JsonCreateValidateParseTransformer } from "./features/json/JsonCreateVa
 import { JsonCreateValidateStringifyTransformer } from "./features/json/JsonCreateValidateStringifyProgrammer";
 import { JsonIsParseTransformer } from "./features/json/JsonIsParseTransformer";
 import { JsonIsStringifyTransformer } from "./features/json/JsonIsStringifyTransformer";
+import { JsonSchemaTransformer } from "./features/json/JsonSchemaTransformer";
 import { JsonSchemasTransformer } from "./features/json/JsonSchemasTransformer";
 import { JsonStringifyTransformer } from "./features/json/JsonStringifyTransformer";
 import { JsonValidateParseTransformer } from "./features/json/JsonValidateParseTransformer";
@@ -401,9 +402,8 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
   },
   json: {
     // METADATA
-    // application: () => JsonApplicationTransformer.transform,
-    application: () => JsonSchemasTransformer.transform,
     schemas: () => JsonSchemasTransformer.transform,
+    schema: () => JsonSchemaTransformer.transform,
 
     // PARSER
     isParse: () => JsonIsParseTransformer.transform,

package/src/transformers/NoTransformConfigurationError.ts

@@ -0,0 +1,18 @@
+/**
+ * @internal
+ */
+export function NoTransformConfigurationError(name: string): never {
+  throw new Error(
+    [
+      `Error on typia.${name}(): no transform has been configured.`,
+      "",
+      "Read and follow https://typia.io/docs/setup please.",
+      "",
+      [
+        "If you've already completed the setup, it means there's",
+        "a bug in your code. Run `tsc` command so that check what",
+        "is wrong with your code.",
+      ].join(" "),
+    ].join("\n"),
+  );
+}

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

@@ -0,0 +1,135 @@
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { JsonSchemaProgrammer } from "../../../programmers/json/JsonSchemaProgrammer";
+import { JsonSchemasProgrammer } from "../../../programmers/json/JsonSchemasProgrammer";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { IJsonSchemaUnit } from "../../../module";
+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): Metadata => {
+      const results: ValidationPipe<Metadata, 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,
+          },
+          collection: new MetadataCollection({
+            replace: MetadataCollection.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/transformers/features/json/JsonSchemasTransformer.ts

@@ -20,7 +20,7 @@ export namespace JsonSchemasTransformer {
   ): ts.Expression => {
     if (!props.expression.typeArguments?.length)
       throw new TransformerError({
-        code: "typia.json.application",
+        code: "typia.json.schemas",
         message: "no generic argument.",
       });
 
@@ -39,12 +39,12 @@ export namespace JsonSchemasTransformer {
     );
     if (types.some((t) => t.isTypeParameter()))
       throw new TransformerError({
-        code: "typia.json.application",
+        code: "typia.json.schemas",
         message: "non-specified generic argument(s).",
       });
 
     // ADDITIONAL PARAMETERS
-    const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
+    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",
@@ -83,7 +83,7 @@ export namespace JsonSchemasTransformer {
       }
       if (errors.length)
         throw TransformerError.from({
-          code: "typia.json.application",
+          code: "typia.json.schemas",
           errors,
         });
       return metadatas;
@@ -91,12 +91,12 @@ export namespace JsonSchemasTransformer {
     analyze(true);
 
     // APPLICATION
-    const app: IJsonSchemaCollection<any> = JsonSchemasProgrammer.write({
+    const collection: IJsonSchemaCollection<any> = JsonSchemasProgrammer.write({
       version,
       metadatas: analyze(false),
     });
     return ts.factory.createAsExpression(
-      LiteralFactory.write(app),
+      LiteralFactory.write(collection),
       props.context.importer.type({
         file: "typia",
         name: "IJsonSchemaCollection",
@@ -109,7 +109,7 @@ export namespace JsonSchemasTransformer {
     );
   };
 
-  const get_parameter =
+  const getParameter =
     <Value>(props: {
       checker: ts.TypeChecker;
       name: string;
@@ -127,7 +127,7 @@ export namespace JsonSchemasTransformer {
         (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
       )
         throw new TransformerError({
-          code: "typia.json.application",
+          code: "typia.json.schemas",
           message: `generic argument "${props.name}" must be constant.`,
         });
 
@@ -137,7 +137,7 @@ export namespace JsonSchemasTransformer {
         : props.checker.typeToString(type);
       if (typeof value !== "string" || props.is(value) === false)
         throw new TransformerError({
-          code: "typia.json.application",
+          code: "typia.json.schemas",
           message: `invalid value on generic argument "${props.name}".`,
         });
       return props.cast(value);