typia 3.6.6 → 3.7.0-dev.20230310

package/src/programmers/internal/application_number.ts

@@ -23,10 +23,13 @@ export const application_number = (
         // RANGE TAG
         else if (tag.kind === "minimum") output.minimum = tag.value;
         else if (tag.kind === "maximum") output.maximum = tag.value;
-        else if (tag.kind === "exclusiveMinimum")
-            output.exclusiveMinimum = tag.value;
-        else if (tag.kind === "exclusiveMaximum")
-            output.exclusiveMaximum = tag.value;
+        else if (tag.kind === "exclusiveMinimum") {
+            output.minimum = tag.value;
+            output.exclusiveMinimum = true;
+        } else if (tag.kind === "exclusiveMaximum") {
+            output.maximum = tag.value;
+            output.exclusiveMaximum = true;
+        }
         // MULTIPLE-OF
         else if (tag.kind === "multipleOf") output.multipleOf = tag.value;
     }
@@ -38,14 +41,14 @@ export const application_number = (
             (tag) => tag.kind === "type" && tag.value === "uint",
         )
     )
-        if (output.minimum === undefined || output.minimum < 0)
+        if (
+            output.minimum === undefined ||
+            (output.exclusiveMaximum !== true && output.minimum < 0)
+        )
             output.minimum = 0;
-        else if (
-            output.exclusiveMinimum !== undefined &&
-            output.exclusiveMinimum < 0
-        ) {
-            delete output.exclusiveMinimum;
+        else if (output.exclusiveMinimum === true && output.minimum < -1) {
             output.maximum = 0;
+            delete output.exclusiveMinimum;
         }
 
     // DEFAULT CONFIGURATION
@@ -53,13 +56,13 @@ export const application_number = (
         const value: number = Number(str);
         const conditions: boolean[] = [!Number.isNaN(value)];
         if (output.minimum !== undefined)
-            conditions.push(value >= output.minimum);
+            if (output.exclusiveMinimum === true)
+                conditions.push(value > output.minimum);
+            else conditions.push(value >= output.minimum);
         if (output.maximum !== undefined)
-            conditions.push(value <= output.maximum);
-        if (output.exclusiveMinimum !== undefined)
-            conditions.push(value > output.exclusiveMinimum);
-        if (output.exclusiveMaximum !== undefined)
-            conditions.push(value < output.exclusiveMaximum);
+            if (output.exclusiveMaximum === true)
+                conditions.push(value < output.maximum);
+            else conditions.push(value <= output.maximum);
         if (output.multipleOf !== undefined)
             conditions.push(value % output.multipleOf === 0);
         return conditions.every((cond) => cond);

package/src/programmers/internal/application_object.ts

@@ -18,10 +18,10 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 export const application_object =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
-    (key: string, obj: MetadataObject, nullable: boolean): void => {
+    (id: string, obj: MetadataObject, nullable: boolean): void => {
         // TEMPORARY ASSIGNMENT
-        if (components.schemas[key] !== undefined) return;
-        components.schemas[key] = {} as any;
+        if (components.schemas[id] !== undefined) return;
+        components.schemas[id] = {} as any;
 
         // ITERATE PROPERTIES
         const properties: Record<string, any> = {};
@@ -97,7 +97,7 @@ export const application_object =
         const schema: IJsonComponents.IObject = {
             $id:
                 options.purpose === "ajv"
-                    ? options.prefix + "/" + key
+                    ? options.prefix + "/" + id
                     : undefined,
             $recursiveAnchor:
                 (options.purpose === "ajv" && obj.recursive) || undefined,
@@ -118,7 +118,7 @@ export const application_object =
                           join(options)(components)(extraMeta),
                   }),
         };
-        components.schemas[key] = schema;
+        components.schemas[id] = schema;
     };
 
 const join =

package/src/programmers/internal/application_schema.ts

@@ -2,6 +2,8 @@ import { Metadata } from "../../metadata/Metadata";
 import { IJsonComponents } from "../../schemas/IJsonComponents";
 import { IJsonSchema } from "../../schemas/IJsonSchema";
 
+import { NameEncoder } from "../../utils/NameEncoder";
+
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
 import { application_array } from "./application_array";
@@ -142,12 +144,14 @@ export const application_schema =
 
         // OBJECT
         for (const obj of meta.objects) {
-            const key: string = obj.name + (meta.nullable ? ".Nullable" : "");
-            application_object(options)(components)(key, obj, meta.nullable);
+            const id: string =
+                NameEncoder.encode(obj.name) +
+                (meta.nullable ? ".Nullable" : "");
+            application_object(options)(components)(id, obj, meta.nullable);
             union.push(
                 (options.purpose === "ajv" && obj.recursive
                     ? recursive
-                    : reference)(`${options.prefix}/${key}`, attribute),
+                    : reference)(`${options.prefix}/${id}`, attribute),
             );
         }
 

package/src/schemas/IJsonSchema.ts

@@ -47,8 +47,8 @@ export namespace IJsonSchema {
     export interface INumber extends IAtomic<"number"> {
         minimum?: number;
         maximum?: number;
-        exclusiveMinimum?: number;
-        exclusiveMaximum?: number;
+        exclusiveMinimum?: boolean;
+        exclusiveMaximum?: boolean;
         multipleOf?: number;
     }
     export interface IInteger extends IAtomic<"integer"> {
@@ -60,14 +60,8 @@ export namespace IJsonSchema {
          * @type int
          */
         maximum?: number;
-        /**
-         * @type int
-         */
-        exclusiveMinimum?: number;
-        /**
-         * @type int
-         */
-        exclusiveMaximum?: number;
+        exclusiveMinimum?: boolean;
+        exclusiveMaximum?: boolean;
         /**
          * @type int
          */

package/src/transformers/CallExpressionTransformer.ts

@@ -28,6 +28,7 @@ import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransf
 import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
 import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
 import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
+import { MessageTransformer } from "./features/protocols/MessageTransformer";
 import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
 import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
 import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
@@ -94,7 +95,7 @@ const CLI_PATH = path.resolve(
 
 const FUNCTORS: Record<string, () => Task> = {
     //----
-    // SINGLE FUNCTIONS
+    // VALIDATORS
     //----
     // BASIC VALIDATORS
     assert: () => AssertTransformer.transform(false),
@@ -107,13 +108,23 @@ const FUNCTORS: Record<string, () => Task> = {
     equals: () => IsTransformer.transform(true),
     validateEquals: () => ValidateTransformer.transform(true),
 
-    // PARSE FUNCTIONS
+    //----
+    // PROTOCOL BUFFER
+    //----
+    message: () => MessageTransformer.transform,
+
+    //----
+    // JSON FUNCTIONS
+    //----
+    // SCHEMA DEFINITION
+    application: () => ApplicationTransformer.transform,
+
+    // PARSER FUNCTIONS
     isParse: () => IsParseTransformer.transform,
     assertParse: () => AssertParseTransformer.transform,
     validateParse: () => ValidateParseTransformer.transform,
 
     // STRINGIFY FUNCTIONS
-    application: () => ApplicationTransformer.transform,
     stringify: () => StringifyTransformer.transform,
     assertStringify: () => AssertStringifyTransformer.transform,
     isStringify: () => IsStringifyTransformer.transform,
@@ -136,23 +147,19 @@ const FUNCTORS: Record<string, () => Task> = {
     //----
     // FACTORY FUNCTIONS
     //----
-    // BASIC VALIDATORS
+    // VALIDATORS
     createAssert: () => CreateAssertTransformer.transform(false),
     createAssertType: () => CreateAssertTransformer.transform(false),
     createIs: () => CreateIsTransformer.transform(false),
     createValidate: () => CreateValidateTransformer.transform(false),
-
-    // STRICT VALIDATORS
     createAssertEquals: () => CreateAssertTransformer.transform(true),
     createEquals: () => CreateIsTransformer.transform(true),
     createValidateEquals: () => CreateValidateTransformer.transform(true),
 
-    // PARSE FUNCTIONS
+    // JSON FUNCTIONS
     createIsParse: () => CreateIsParseTransformer.transform,
     createAssertParse: () => CreateAssertParseTransformer.transform,
     createValidateParse: () => CreateValidateParseTransformer.transform,
-
-    // STRINGIFY FUNCTIONS
     createStringify: () => CreateStringifyTransformer.transform,
     createAssertStringify: () => CreateAssertStringifyTransformer.transform,
     createIsStringify: () => CreateIsStringifyTransformer.transform,

package/src/transformers/features/miscellaneous/ApplicationTransformer.ts

@@ -59,9 +59,7 @@ export namespace ApplicationTransformer {
         // GENERATORS
         //----
         // METADATA
-        const collection: MetadataCollection = new MetadataCollection({
-            replace: MetadataCollection.replace,
-        });
+        const collection: MetadataCollection = new MetadataCollection();
         const metadatas: Array<Metadata> = types.map((type) =>
             MetadataFactory.generate(checker, collection, type, {
                 resolve: true,

package/src/transformers/features/protocols/MessageTransformer.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { MessageProgrammer } from "../../../programmers/MessageProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace MessageTransformer {
+    export function transform(
+        project: IProject,
+        _modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments || !expression.typeArguments[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return MessageProgrammer.generate(project)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.message(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.message(): non-specified generic argument.",
+}

package/src/utils/NameEncoder.ts

@@ -0,0 +1,32 @@
+export namespace NameEncoder {
+    export function encode(str: string): string {
+        for (const [before, after] of REPLACERS)
+            str = str.split(before).join(after);
+        return str;
+    }
+
+    export function decode(str: string): string {
+        for (const [before, after] of REPLACERS)
+            if (after !== "") str = str.split(after).join(before);
+        return str;
+    }
+}
+
+const REPLACERS: [string, string][] = [
+    ["$", "_dollar_"],
+    ["&", "_and_"],
+    ["|", "_or_"],
+    ["{", "_blt_"],
+    ["}", "_bgt_"],
+    ["<", "_lt_"],
+    [">", "_gt_"],
+    ["(", "_lp_"],
+    [")", "_rp_"],
+    ["[", "_alt_"],
+    ["]", "_agt_"],
+    [",", "_comma_"],
+    ["`", "_backquote_"],
+    ["'", "_singlequote_"],
+    ['"', "_doublequote_"],
+    [" ", "_space_"],
+];