typia 9.0.1 → 9.1.0

package/src/misc.ts

@@ -7,6 +7,8 @@
 ==============================================================
     LITERALS
 ----------------------------------------------------------- */
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
+
 import { Atomic } from "./typings/Atomic";
 
 import { IValidation } from "./IValidation";
@@ -51,7 +53,7 @@ export function literals<T extends Atomic.Type | null>(): T[];
  * @internal
  */
 export function literals(): never {
-  halt("literals");
+  NoTransformConfigurationError("misc.literals");
 }
 
 /* -----------------------------------------------------------
@@ -81,7 +83,7 @@ export function clone<T>(input: T): Resolved<T>;
  * @internal
  */
 export function clone(): never {
-  halt("clone");
+  NoTransformConfigurationError("misc.clone");
 }
 
 /**
@@ -134,7 +136,7 @@ export function assertClone<T>(
  * @internal
  */
 export function assertClone(): never {
-  halt("assertClone");
+  NoTransformConfigurationError("misc.assertClone");
 }
 
 /**
@@ -179,7 +181,7 @@ export function isClone<T>(input: unknown): Resolved<T> | null;
  * @internal
  */
 export function isClone(): never {
-  halt("isClone");
+  NoTransformConfigurationError("misc.isClone");
 }
 
 /**
@@ -222,7 +224,7 @@ export function validateClone<T>(input: unknown): IValidation<Resolved<T>>;
  * @internal
  */
 export function validateClone(): never {
-  halt("validateClone");
+  NoTransformConfigurationError("misc.validateClone");
 }
 
 /* -----------------------------------------------------------
@@ -255,7 +257,7 @@ export function prune<T extends object>(input: T): void;
  * @internal
  */
 export function prune(): never {
-  halt("prune");
+  NoTransformConfigurationError("misc.prune");
 }
 
 /**
@@ -308,7 +310,7 @@ export function assertPrune<T>(
  * @internal
  */
 export function assertPrune(): unknown {
-  halt("assertPrune");
+  NoTransformConfigurationError("misc.assertPrune");
 }
 
 /**
@@ -353,7 +355,7 @@ export function isPrune<T>(input: unknown): input is T;
  * @internal
  */
 export function isPrune(): never {
-  halt("isPrune");
+  NoTransformConfigurationError("misc.isPrune");
 }
 
 /**
@@ -400,7 +402,7 @@ export function validatePrune<T>(input: unknown): IValidation<T>;
  * @internal
  */
 export function validatePrune<T>(): IValidation<T> {
-  halt("validatePrune");
+  NoTransformConfigurationError("misc.validatePrune");
 }
 
 /* -----------------------------------------------------------
@@ -431,7 +433,7 @@ export function createClone<T>(): (input: T) => Resolved<T>;
  * @internal
  */
 export function createClone(): never {
-  halt("createClone");
+  NoTransformConfigurationError("misc.createClone");
 }
 
 /**
@@ -465,7 +467,7 @@ export function createAssertClone<T>(
  * @internal
  */
 export function createAssertClone(): never {
-  halt("createAssertClone");
+  NoTransformConfigurationError("misc.createAssertClone");
 }
 
 /**
@@ -493,7 +495,7 @@ export function createIsClone<T>(): (input: unknown) => Resolved<T> | null;
  * @internal
  */
 export function createIsClone(): never {
-  halt("createIsClone");
+  NoTransformConfigurationError("misc.createIsClone");
 }
 
 /**
@@ -523,7 +525,7 @@ export function createValidateClone<T>(): (
  * @internal
  */
 export function createValidateClone(): never {
-  halt("createValidateClone");
+  NoTransformConfigurationError("misc.createValidateClone");
 }
 
 /**
@@ -551,7 +553,7 @@ export function createPrune<T extends object>(): (input: T) => void;
  * @internal
  */
 export function createPrune<T extends object>(): (input: T) => void {
-  halt("createPrune");
+  NoTransformConfigurationError("misc.createPrune");
 }
 
 /**
@@ -585,7 +587,7 @@ export function createAssertPrune<T extends object>(
  * @internal
  */
 export function createAssertPrune<T extends object>(): (input: T) => T {
-  halt("createAssertPrune");
+  NoTransformConfigurationError("misc.createAssertPrune");
 }
 
 /**
@@ -613,7 +615,7 @@ export function createIsPrune<T extends object>(): (input: T) => input is T;
  * @internal
  */
 export function createIsPrune<T extends object>(): (input: T) => input is T {
-  halt("createIsPrune");
+  NoTransformConfigurationError("misc.createIsPrune");
 }
 
 /**
@@ -645,14 +647,5 @@ export function createValidatePrune<T extends object>(): (
 export function createValidatePrune<T extends object>(): (
   input: T,
 ) => IValidation<T> {
-  halt("createValidatePrune");
-}
-
-/**
- * @internal
- */
-function halt(name: string): never {
-  throw new Error(
-    `Error on typia.misc.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`,
-  );
+  NoTransformConfigurationError("misc.createValidatePrune");
 }

package/src/module.ts

@@ -1,3 +1,5 @@
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
+
 import { AssertionGuard } from "./AssertionGuard";
 import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
@@ -17,6 +19,7 @@ export * as tags from "./tags";
 export * from "./schemas/metadata/IJsDocTagInfo";
 export * from "./schemas/json/IJsonApplication";
 export * from "./schemas/json/IJsonSchemaCollection";
+export * from "./schemas/json/IJsonSchemaUnit";
 export * from "./AssertionGuard";
 export * from "./IRandomGenerator";
 export * from "./IValidation";
@@ -92,7 +95,7 @@ export function assert<T>(
  * @internal
  */
 export function assert(): never {
-  halt("assert");
+  NoTransformConfigurationError("assert");
 }
 
 /**
@@ -159,7 +162,7 @@ export function assertGuard<T>(
  * @internal
  */
 export function assertGuard(): never {
-  halt("assertGuard");
+  NoTransformConfigurationError("assertGuard");
 }
 
 /**
@@ -215,7 +218,7 @@ export function is<T>(input: unknown): input is T;
  * @internal
  */
 export function is(): never {
-  halt("is");
+  NoTransformConfigurationError("is");
 }
 
 /**
@@ -272,7 +275,7 @@ export function validate<T>(input: unknown): IValidation<T>;
  * @internal
  */
 export function validate(): never {
-  halt("validate");
+  NoTransformConfigurationError("validate");
 }
 
 /* -----------------------------------------------------------
@@ -340,7 +343,7 @@ export function assertEquals<T>(
  * @internal
  */
 export function assertEquals(): never {
-  halt("assertEquals");
+  NoTransformConfigurationError("assertEquals");
 }
 
 /**
@@ -413,7 +416,7 @@ export function assertGuardEquals<T>(
  * @internal
  */
 export function assertGuardEquals(): never {
-  halt("assertGuardEquals");
+  NoTransformConfigurationError("assertGuardEquals");
 }
 
 /**
@@ -470,7 +473,7 @@ export function equals<T>(input: unknown): input is T;
  * @internal
  */
 export function equals(): never {
-  halt("equals");
+  NoTransformConfigurationError("equals");
 }
 
 /**
@@ -529,7 +532,7 @@ export function validateEquals<T>(input: unknown): IValidation<T>;
  * @internal
  */
 export function validateEquals(): never {
-  halt("validateEquals");
+  NoTransformConfigurationError("validateEquals");
 }
 
 /* -----------------------------------------------------------
@@ -577,7 +580,7 @@ export function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;
  * @internal
  */
 export function random(): never {
-  halt("random");
+  NoTransformConfigurationError("random");
 }
 
 /* -----------------------------------------------------------
@@ -614,7 +617,7 @@ export function createAssert<T>(
  * @internal
  */
 export function createAssert<T>(): (input: unknown) => T {
-  halt("createAssert");
+  NoTransformConfigurationError("createAssert");
 }
 
 /**
@@ -678,7 +681,7 @@ export function createAssertGuard<T>(
  * @internal
  */
 export function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T> {
-  halt("createAssertGuard");
+  NoTransformConfigurationError("createAssertGuard");
 }
 
 /**
@@ -706,7 +709,7 @@ export function createIs<T>(): (input: unknown) => input is T;
  * @internal
  */
 export function createIs<T>(): (input: unknown) => input is T {
-  halt("createIs");
+  NoTransformConfigurationError("createIs");
 }
 
 /**
@@ -734,7 +737,7 @@ export function createValidate<T>(): (input: unknown) => IValidation<T>;
  * @internal
  */
 export function createValidate(): (input: unknown) => IValidation {
-  halt("createValidate");
+  NoTransformConfigurationError("createValidate");
 }
 
 /**
@@ -768,7 +771,7 @@ export function createAssertEquals<T>(
  * @internal
  */
 export function createAssertEquals<T>(): (input: unknown) => T {
-  halt("createAssertEquals");
+  NoTransformConfigurationError("createAssertEquals");
 }
 
 /**
@@ -834,7 +837,7 @@ export function createAssertGuardEquals<T>(
 export function createAssertGuardEquals<T>(): (
   input: unknown,
 ) => AssertionGuard<T> {
-  halt("createAssertGuardEquals");
+  NoTransformConfigurationError("createAssertGuardEquals");
 }
 
 /**
@@ -862,7 +865,7 @@ export function createEquals<T>(): (input: unknown) => input is T;
  * @internal
  */
 export function createEquals<T>(): (input: unknown) => input is T {
-  halt("createEquals");
+  NoTransformConfigurationError("createEquals");
 }
 
 /**
@@ -890,7 +893,7 @@ export function createValidateEquals<T>(): (input: unknown) => IValidation<T>;
  * @internal
  */
 export function createValidateEquals(): (input: unknown) => IValidation {
-  halt("createValidateEquals");
+  NoTransformConfigurationError("createValidateEquals");
 }
 
 /**
@@ -922,14 +925,5 @@ export function createRandom<T>(
  * @internal
  */
 export function createRandom(): never {
-  halt("createRandom");
-}
-
-/**
- * @internal
- */
-function halt(name: string): never {
-  throw new Error(
-    `Error on typia.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`,
-  );
+  NoTransformConfigurationError("createRandom");
 }

package/src/notations.ts

@@ -1,3 +1,5 @@
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
+
 import { CamelCase } from "./CamelCase";
 import { IValidation } from "./IValidation";
 import { PascalCase } from "./PascalCase";
@@ -38,7 +40,7 @@ export function camel<T>(input: T): CamelCase<T>;
  * @internal
  */
 export function camel(): never {
-  return halt("camel");
+  return NoTransformConfigurationError("notations.camel");
 }
 
 /**
@@ -81,7 +83,7 @@ export function assertCamel<T>(
  * @internal
  */
 export function assertCamel(): never {
-  return halt("assertCamel");
+  return NoTransformConfigurationError("notations.assertCamel");
 }
 
 /**
@@ -116,7 +118,7 @@ export function isCamel<T>(input: unknown): CamelCase<T> | null;
  * @internal
  */
 export function isCamel(): never {
-  return halt("isCamel");
+  return NoTransformConfigurationError("notations.isCamel");
 }
 
 /**
@@ -155,7 +157,7 @@ export function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;
  * @internal
  */
 export function validateCamel(): never {
-  return halt("validateCamel");
+  return NoTransformConfigurationError("notations.validateCamel");
 }
 
 /* -----------------------------------------------------------
@@ -186,7 +188,7 @@ export function pascal<T>(input: T): PascalCase<T>;
  * @internal
  */
 export function pascal(): never {
-  return halt("pascal");
+  return NoTransformConfigurationError("notations.pascal");
 }
 
 /**
@@ -229,7 +231,7 @@ export function assertPascal<T>(
  * @internal
  */
 export function assertPascal(): never {
-  return halt("assertPascal");
+  return NoTransformConfigurationError("notations.assertPascal");
 }
 
 /**
@@ -264,7 +266,7 @@ export function isPascal<T>(input: unknown): PascalCase<T> | null;
  * @internal
  */
 export function isPascal(): never {
-  return halt("isPascal");
+  return NoTransformConfigurationError("notations.isPascal");
 }
 
 /**
@@ -303,7 +305,7 @@ export function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;
  * @internal
  */
 export function validatePascal(): never {
-  return halt("validatePascal");
+  return NoTransformConfigurationError("notations.validatePascal");
 }
 
 /* -----------------------------------------------------------
@@ -334,7 +336,7 @@ export function snake<T>(input: T): SnakeCase<T>;
  * @internal
  */
 export function snake(): never {
-  return halt("snake");
+  return NoTransformConfigurationError("notations.snake");
 }
 
 /**
@@ -377,7 +379,7 @@ export function assertSnake<T>(
  * @internal
  */
 export function assertSnake(): never {
-  return halt("assertSnake");
+  return NoTransformConfigurationError("notations.assertSnake");
 }
 
 /**
@@ -412,7 +414,7 @@ export function isSnake<T>(input: unknown): SnakeCase<T> | null;
  * @internal
  */
 export function isSnake(): never {
-  return halt("isSnake");
+  return NoTransformConfigurationError("notations.isSnake");
 }
 
 /**
@@ -451,7 +453,7 @@ export function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;
  * @internal
  */
 export function validateSnake(): never {
-  return halt("validateSnake");
+  return NoTransformConfigurationError("notations.validateSnake");
 }
 
 /* -----------------------------------------------------------
@@ -482,7 +484,7 @@ export function createCamel<T>(): (input: T) => CamelCase<T>;
  * @internal
  */
 export function createCamel(): never {
-  halt("createCamel");
+  NoTransformConfigurationError("notations.createCamel");
 }
 
 /**
@@ -516,7 +518,7 @@ export function createAssertCamel<T>(
  * @internal
  */
 export function createAssertCamel(): never {
-  halt("createAssertCamel");
+  NoTransformConfigurationError("notations.createAssertCamel");
 }
 
 /**
@@ -544,7 +546,7 @@ export function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
  * @internal
  */
 export function createIsCamel(): never {
-  halt("createIsCamel");
+  NoTransformConfigurationError("notations.createIsCamel");
 }
 
 /**
@@ -574,7 +576,7 @@ export function createValidateCamel<T>(): (
  * @internal
  */
 export function createValidateCamel(): never {
-  halt("createValidateCamel");
+  NoTransformConfigurationError("notations.createValidateCamel");
 }
 
 /**
@@ -602,7 +604,7 @@ export function createPascal<T>(): (input: T) => PascalCase<T>;
  * @internal
  */
 export function createPascal(): never {
-  halt("createPascal");
+  NoTransformConfigurationError("notations.createPascal");
 }
 
 /**
@@ -636,7 +638,7 @@ export function createAssertPascal<T>(
  * @internal
  */
 export function createAssertPascal(): never {
-  halt("createAssertPascal");
+  NoTransformConfigurationError("notations.createAssertPascal");
 }
 
 /**
@@ -664,7 +666,7 @@ export function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
  * @internal
  */
 export function createIsPascal(): never {
-  halt("createIsPascal");
+  NoTransformConfigurationError("notations.createIsPascal");
 }
 
 /**
@@ -694,7 +696,7 @@ export function createValidatePascal<T>(): (
  * @internal
  */
 export function createValidatePascal(): never {
-  halt("createValidatePascal");
+  NoTransformConfigurationError("notations.createValidatePascal");
 }
 
 /**
@@ -722,7 +724,7 @@ export function createSnake<T>(): (input: T) => SnakeCase<T>;
  * @internal
  */
 export function createSnake(): never {
-  halt("createSnake");
+  NoTransformConfigurationError("notations.createSnake");
 }
 
 /**
@@ -756,7 +758,7 @@ export function createAssertSnake<T>(
  * @internal
  */
 export function createAssertSnake(): never {
-  halt("createAssertSnake");
+  NoTransformConfigurationError("notations.createAssertSnake");
 }
 
 /**
@@ -784,7 +786,7 @@ export function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
  * @internal
  */
 export function createIsSnake(): never {
-  halt("createIsSnake");
+  NoTransformConfigurationError("notations.createIsSnake");
 }
 
 /**
@@ -814,14 +816,5 @@ export function createValidateSnake<T>(): (
  * @internal
  */
 export function createValidateSnake(): never {
-  halt("createValidateSnake");
-}
-
-/**
- * @internal
- */
-function halt(name: string): never {
-  throw new Error(
-    `Error on typia.notations.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`,
-  );
+  NoTransformConfigurationError("notations.createValidateSnake");
 }

package/src/programmers/json/JsonSchemaProgrammer.ts

@@ -0,0 +1,26 @@
+import { OpenApi } from "@samchon/openapi";
+
+import { IJsonSchemaUnit } from "../../schemas/json/IJsonSchemaUnit";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { JsonSchemasProgrammer } from "./JsonSchemasProgrammer";
+
+export namespace JsonSchemaProgrammer {
+  export const validate = (metadata: Metadata): string[] =>
+    JsonSchemasProgrammer.validate(metadata);
+
+  export const write = <Version extends "3.0" | "3.1">(props: {
+    version: Version;
+    metadata: Metadata;
+  }): IJsonSchemaUnit<Version> => {
+    const collection = JsonSchemasProgrammer.write({
+      version: props.version,
+      metadatas: [props.metadata],
+    });
+    return {
+      version: collection.version as "3.1",
+      components: collection.components as OpenApi.IComponents,
+      schema: collection.schemas[0] as OpenApi.IJsonSchema,
+    } as IJsonSchemaUnit<Version>;
+  };
+}

package/src/programmers/json/JsonSchemasProgrammer.ts

@@ -81,7 +81,7 @@ export namespace JsonSchemasProgrammer {
         const schema: OpenApi.IJsonSchema | null = generator(meta);
         if (schema === null)
           throw new TransformerError({
-            code: "typia.json.application",
+            code: "typia.json.schemas",
             message: `invalid type on argument - (${meta.getName()}, ${i})`,
           });
         return schema;