typia 3.5.0-dev.20221219 → 3.5.0-dev.20221222

package/src/programmers/internal/application_object.ts

@@ -1,103 +1,103 @@
-import { CommentFactory } from "../../factories/CommentFactory";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-import { MetadataObject } from "../../metadata/MetadataObject";
-import { IJsonComponents } from "../../schemas/IJsonComponents";
-
-import { PatternUtil } from "../../utils/PatternUtil";
-
-import { IJsonSchema } from "../../module";
-import { ApplicationProgrammer } from "../ApplicationProgrammer";
-import { application_schema } from "./application_schema";
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const application_object =
-    (options: ApplicationProgrammer.IOptions) =>
-    (components: IJsonComponents) =>
-    (key: string, obj: MetadataObject, nullable: boolean): void => {
-        // TEMPORARY ASSIGNMENT
-        if (components.schemas[key] !== undefined) return;
-        components.schemas[key] = {} as any;
-
-        // ITERATE PROPERTIES
-        const properties: Record<string, any> = {};
-        const patternProperties: Record<string, any> = {};
-        const additionalProperties: IJsonSchema[] = [];
-        const required: string[] = [];
-
-        for (const property of obj.properties) {
-            if (
-                property.value.functional === true &&
-                property.value.nullable === false &&
-                property.value.required === true &&
-                property.value.size() === 0
-            )
-                continue;
-
-            const key: string | null = property.key.getSoleLiteral();
-            const value: IJsonSchema | null = application_schema(options)(
-                components,
-            )(true)(property.value, {
-                deprecated:
-                    !!property.jsDocTags.find(
-                        (tag) => tag.name === "deprecated",
-                    ) || undefined,
-                title: (() => {
-                    const info: IJsDocTagInfo | undefined =
-                        property.jsDocTags.find((tag) => tag.name === "title");
-                    return info?.text?.length
-                        ? CommentFactory.generate(info.text)
-                        : undefined;
-                })(),
-                description: property.description,
-                "x-typia-metaTags": property.tags.length
-                    ? property.tags
-                    : undefined,
-                "x-typia-jsDocTags": property.jsDocTags.length
-                    ? property.jsDocTags
-                    : undefined,
-                "x-typia-required": property.value.required,
-            });
-
-            if (value === null) continue;
-            else if (key !== null) {
-                properties[key] = value;
-                if (property.value.required === true) required.push(key);
-            } else {
-                const pattern: string = metadata_to_pattern(true)(property.key);
-                if (
-                    options.purpose === "swagger" ||
-                    pattern === PatternUtil.STRING
-                )
-                    additionalProperties.push(value);
-                else patternProperties[pattern] = value;
-            }
-        }
-
-        const schema: IJsonComponents.IObject = {
-            $id:
-                options.purpose === "ajv"
-                    ? options.prefix + "/" + key
-                    : undefined,
-            $recursiveAnchor:
-                (options.purpose === "ajv" && obj.recursive) || undefined,
-            type: "object",
-            properties,
-            patternProperties: Object.keys(patternProperties).length
-                ? patternProperties
-                : undefined,
-            additionalProperties: additionalProperties.length
-                ? additionalProperties.length === 1
-                    ? additionalProperties[0]
-                    : { oneOf: additionalProperties }
-                : undefined,
-            nullable,
-            required: required.length ? required : undefined,
-            description: obj.description,
-            "x-typia_jsDocTags": obj.jsDocTags,
-        };
-        components.schemas[key] = schema;
-    };
+import { CommentFactory } from "../../factories/CommentFactory";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+import { MetadataObject } from "../../metadata/MetadataObject";
+import { IJsonComponents } from "../../schemas/IJsonComponents";
+
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { IJsonSchema } from "../../module";
+import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { application_schema } from "./application_schema";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const application_object =
+    (options: ApplicationProgrammer.IOptions) =>
+    (components: IJsonComponents) =>
+    (id: string, obj: MetadataObject, nullable: boolean): void => {
+        // TEMPORARY ASSIGNMENT
+        if (components.schemas[id] !== undefined) return;
+        components.schemas[id] = {} as any;
+
+        // ITERATE PROPERTIES
+        const properties: Record<string, any> = {};
+        const patternProperties: Record<string, any> = {};
+        const additionalProperties: IJsonSchema[] = [];
+        const required: string[] = [];
+
+        for (const property of obj.properties) {
+            if (
+                property.value.functional === true &&
+                property.value.nullable === false &&
+                property.value.required === true &&
+                property.value.size() === 0
+            )
+                continue;
+
+            const key: string | null = property.key.getSoleLiteral();
+            const value: IJsonSchema | null = application_schema(options)(
+                components,
+            )(true)(property.value, {
+                deprecated:
+                    !!property.jsDocTags.find(
+                        (tag) => tag.name === "deprecated",
+                    ) || undefined,
+                title: (() => {
+                    const info: IJsDocTagInfo | undefined =
+                        property.jsDocTags.find((tag) => tag.name === "title");
+                    return info?.text?.length
+                        ? CommentFactory.generate(info.text)
+                        : undefined;
+                })(),
+                description: property.description,
+                "x-typia-metaTags": property.tags.length
+                    ? property.tags
+                    : undefined,
+                "x-typia-jsDocTags": property.jsDocTags.length
+                    ? property.jsDocTags
+                    : undefined,
+                "x-typia-required": property.value.required,
+            });
+
+            if (value === null) continue;
+            else if (key !== null) {
+                properties[key] = value;
+                if (property.value.required === true) required.push(key);
+            } else {
+                const pattern: string = metadata_to_pattern(true)(property.key);
+                if (
+                    options.purpose === "swagger" ||
+                    pattern === PatternUtil.STRING
+                )
+                    additionalProperties.push(value);
+                else patternProperties[pattern] = value;
+            }
+        }
+
+        const schema: IJsonComponents.IObject = {
+            $id:
+                options.purpose === "ajv"
+                    ? options.prefix + "/" + id
+                    : undefined,
+            $recursiveAnchor:
+                (options.purpose === "ajv" && obj.recursive) || undefined,
+            type: "object",
+            properties,
+            patternProperties: Object.keys(patternProperties).length
+                ? patternProperties
+                : undefined,
+            additionalProperties: additionalProperties.length
+                ? additionalProperties.length === 1
+                    ? additionalProperties[0]
+                    : { oneOf: additionalProperties }
+                : undefined,
+            nullable,
+            required: required.length ? required : undefined,
+            description: obj.description,
+            "x-typia_jsDocTags": obj.jsDocTags,
+        };
+        components.schemas[id] = schema;
+    };

package/src/programmers/internal/application_schema.ts

@@ -4,6 +4,7 @@ import { IJsonComponents } from "../../schemas/IJsonComponents";
 import { IJsonSchema } from "../../schemas/IJsonSchema";
 
 import { ArrayUtil } from "../../utils/ArrayUtil";
+import { NameEncoder } from "../../utils/NameEncoder";
 
 import { ApplicationProgrammer } from "../ApplicationProgrammer";
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
@@ -50,13 +51,18 @@ export const application_schema =
         if (meta.templates.length && AtomicPredicator.template(meta))
             union.push(application_templates(meta, attribute));
         for (const constant of meta.constants) {
-            if (constant.type === "string" && meta.templates.length) continue;
-            else if (!AtomicPredicator.constant(meta)(constant.type)) continue;
+            if (constant.type === "bigint") throw new Error(NO_BIGINT);
+            else if (
+                (constant.type === "string" && meta.templates.length) ||
+                AtomicPredicator.constant(meta)(constant.type) === false
+            )
+                continue;
             union.push(
                 application_constant(constant, meta.nullable, attribute),
             );
         }
         for (const type of meta.atomics) {
+            if (type === "bigint") throw new Error(NO_BIGINT);
             union.push(
                 type === "string"
                     ? application_string(meta, attribute)
@@ -128,12 +134,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),
             );
         }
 
@@ -219,3 +227,5 @@ function merge_metadata(x: Metadata, y: Metadata): Metadata {
 
     return output;
 }
+
+const NO_BIGINT = "Error on typia.application(): does not allow bigint type.";

package/src/programmers/internal/application_string.ts

@@ -1,49 +1,49 @@
-import { Metadata } from "../../metadata/Metadata";
-import { IJsonSchema } from "../../schemas/IJsonSchema";
-
-import { application_default_string } from "./application_default_string";
-
-/**
- * @internal
- */
-export const application_string = (
-    meta: Metadata,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IString => {
-    const output: IJsonSchema.IString = {
-        type: "string",
-        nullable: meta.nullable,
-        ...attribute,
-    };
-
-    // FORMAT TAG OF METADATA
-    const formatJsdocTag = attribute["x-typia-jsDocTags"]?.find(
-        (tag) => tag.name === "format",
-    );
-    if (formatJsdocTag?.text?.length)
-        output.format = formatJsdocTag?.text.map((t) => t.text).join(" ");
-
-    // REGULAR TAGS COMPATIBLE WITH JSON-SCHEMA
-    for (const tag of attribute["x-typia-metaTags"] || []) {
-        // RANGE
-        if (tag.kind === "minLength") output.minLength = tag.value;
-        else if (tag.kind === "maxLength") output.maxLength = tag.value;
-        else if (tag.kind === "length") {
-            if (tag.minimum !== undefined)
-                output.minLength =
-                    tag.minimum.value + (tag.minimum.include ? 0 : 1);
-            if (tag.maximum !== undefined)
-                output.maxLength =
-                    tag.maximum.value - (tag.maximum.include ? 0 : 1);
-        }
-        // FORMAT AND PATTERN
-        else if (tag.kind === "format") output.format = tag.value;
-        else if (tag.kind === "pattern") output.pattern = tag.value;
-    }
-
-    // DEFAULT CONFIGURATION
-    output.default = application_default_string(meta, attribute)(output);
-
-    // RETURNS
-    return output;
-};
+import { Metadata } from "../../metadata/Metadata";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
+
+import { application_default_string } from "./application_default_string";
+
+/**
+ * @internal
+ */
+export const application_string = (
+    meta: Metadata,
+    attribute: IJsonSchema.IAttribute,
+): IJsonSchema.IString => {
+    const output: IJsonSchema.IString = {
+        type: "string",
+        nullable: meta.nullable,
+        ...attribute,
+    };
+
+    // FORMAT TAG OF METADATA
+    const formatJsdocTag = attribute["x-typia-jsDocTags"]?.find(
+        (tag) => tag.name === "format",
+    );
+    if (formatJsdocTag?.text?.length)
+        output.format = formatJsdocTag?.text.map((t) => t.text).join(" ");
+
+    // REGULAR TAGS COMPATIBLE WITH JSON-SCHEMA
+    for (const tag of attribute["x-typia-metaTags"] || []) {
+        // RANGE
+        if (tag.kind === "minLength") output.minLength = tag.value;
+        else if (tag.kind === "maxLength") output.maxLength = tag.value;
+        else if (tag.kind === "length") {
+            if (tag.minimum !== undefined)
+                output.minLength =
+                    tag.minimum.value + (tag.minimum.include ? 0 : 1);
+            if (tag.maximum !== undefined)
+                output.maxLength =
+                    tag.maximum.value - (tag.maximum.include ? 0 : 1);
+        }
+        // FORMAT AND PATTERN
+        else if (tag.kind === "format") output.format = tag.value;
+        else if (tag.kind === "pattern") output.pattern = tag.value;
+    }
+
+    // DEFAULT CONFIGURATION
+    output.default = application_default_string(meta, attribute)(output);
+
+    // RETURNS
+    return output;
+};

package/src/programmers/internal/application_templates.ts

@@ -1,27 +1,27 @@
-import { Metadata } from "../../metadata/Metadata";
-import { IJsonSchema } from "../../schemas/IJsonSchema";
-
-import { application_default_string } from "./application_default_string";
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const application_templates = (
-    meta: Metadata,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IString => {
-    // CONSTRUCT PATTERN
-    const output: IJsonSchema.IString = {
-        type: "string",
-        nullable: meta.nullable,
-        ...attribute,
-    };
-    output.pattern = metadata_to_pattern(true)(meta);
-
-    // DEFAULT VALUE
-    output.default = application_default_string(meta, attribute)(output);
-
-    // RETURNS
-    return output;
-};
+import { Metadata } from "../../metadata/Metadata";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
+
+import { application_default_string } from "./application_default_string";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const application_templates = (
+    meta: Metadata,
+    attribute: IJsonSchema.IAttribute,
+): IJsonSchema.IString => {
+    // CONSTRUCT PATTERN
+    const output: IJsonSchema.IString = {
+        type: "string",
+        nullable: meta.nullable,
+        ...attribute,
+    };
+    output.pattern = metadata_to_pattern(true)(meta);
+
+    // DEFAULT VALUE
+    output.default = application_default_string(meta, attribute)(output);
+
+    // RETURNS
+    return output;
+};

package/src/programmers/internal/application_tuple.ts

@@ -1,25 +1,25 @@
-import { Metadata } from "../../metadata/Metadata";
-import { IJsonComponents } from "../../schemas/IJsonComponents";
-import { IJsonSchema } from "../../schemas/IJsonSchema";
-
-import { ApplicationProgrammer } from "../ApplicationProgrammer";
-import { application_schema } from "./application_schema";
-
-/**
- * @internal
- */
-export const application_tuple =
-    (options: ApplicationProgrammer.IOptions) =>
-    (components: IJsonComponents) =>
-    (
-        items: Array<Metadata>,
-        nullable: boolean,
-        attribute: IJsonSchema.IAttribute,
-    ): IJsonSchema.ITuple => ({
-        type: "array",
-        items: items.map((meta) =>
-            application_schema(options)(components)(false)(meta, attribute),
-        ),
-        nullable,
-        ...attribute,
-    });
+import { Metadata } from "../../metadata/Metadata";
+import { IJsonComponents } from "../../schemas/IJsonComponents";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
+
+import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { application_schema } from "./application_schema";
+
+/**
+ * @internal
+ */
+export const application_tuple =
+    (options: ApplicationProgrammer.IOptions) =>
+    (components: IJsonComponents) =>
+    (
+        items: Array<Metadata>,
+        nullable: boolean,
+        attribute: IJsonSchema.IAttribute,
+    ): IJsonSchema.ITuple => ({
+        type: "array",
+        items: items.map((meta) =>
+            application_schema(options)(components)(false)(meta, attribute),
+        ),
+        nullable,
+        ...attribute,
+    });

package/src/programmers/internal/check_array.ts

@@ -1,44 +1,44 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { check_length } from "./check_length";
-
-/**
- * @internal
- */
-export function check_array(
-    input: ts.Expression,
-    tagList: IMetadataTag[],
-): ts.Expression {
-    const conditions: ts.Expression[] = [ExpressionFactory.isArray(input)];
-
-    // CHECK TAGS
-    for (const tag of tagList)
-        if (tag.kind === "minItems")
-            conditions.push(
-                ts.factory.createLessThanEquals(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-        else if (tag.kind === "maxItems")
-            conditions.push(
-                ts.factory.createGreaterThanEquals(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-        else if (tag.kind === "items")
-            check_length(
-                conditions,
-                IdentifierFactory.join(input, "length"),
-                tag,
-            );
-
-    // COMBINATION
-    return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { check_length } from "./check_length";
+
+/**
+ * @internal
+ */
+export function check_array(
+    input: ts.Expression,
+    tagList: IMetadataTag[],
+): ts.Expression {
+    const conditions: ts.Expression[] = [ExpressionFactory.isArray(input)];
+
+    // CHECK TAGS
+    for (const tag of tagList)
+        if (tag.kind === "minItems")
+            conditions.push(
+                ts.factory.createLessThanEquals(
+                    ts.factory.createNumericLiteral(tag.value),
+                    IdentifierFactory.join(input, "length"),
+                ),
+            );
+        else if (tag.kind === "maxItems")
+            conditions.push(
+                ts.factory.createGreaterThanEquals(
+                    ts.factory.createNumericLiteral(tag.value),
+                    IdentifierFactory.join(input, "length"),
+                ),
+            );
+        else if (tag.kind === "items")
+            check_length(
+                conditions,
+                IdentifierFactory.join(input, "length"),
+                tag,
+            );
+
+    // COMBINATION
+    return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+}

package/src/programmers/internal/check_bigint.ts

@@ -0,0 +1,85 @@
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+export function check_bigint(input: ts.Expression, tagList: IMetadataTag[]) {
+    const caster = (value: number) =>
+        ts.factory.createIdentifier(`${Math.floor(value)}n`);
+
+    // TYPEOF STATEMENT
+    const conditions: ts.Expression[] = [
+        ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("bigint"),
+            ts.factory.createTypeOfExpression(input),
+        ),
+    ];
+
+    // TAG (RANGE)
+    for (const tag of tagList)
+        if (tag.kind === "multipleOf")
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    caster(0),
+                    ts.factory.createModulo(input, caster(tag.value)),
+                ),
+            );
+        else if (tag.kind === "step") {
+            const modulo = () =>
+                ts.factory.createModulo(input, caster(tag.value));
+            const minimum = (() => {
+                for (const tag of tagList)
+                    if (tag.kind === "minimum") return tag.value;
+                    else if (tag.kind === "exclusiveMinimum") return tag.value;
+                    else if (tag.kind === "range" && tag.minimum !== undefined)
+                        return tag.minimum.value;
+                return undefined;
+            })();
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    caster(0),
+                    minimum !== undefined
+                        ? ts.factory.createSubtract(modulo(), caster(minimum))
+                        : modulo(),
+                ),
+            );
+        } else if (tag.kind === "range") {
+            if (tag.minimum !== undefined)
+                conditions.push(
+                    (tag.minimum.include
+                        ? ts.factory.createLessThanEquals
+                        : ts.factory.createLessThan)(
+                        caster(tag.minimum.value),
+                        input,
+                    ),
+                );
+            if (tag.maximum !== undefined)
+                conditions.push(
+                    (tag.maximum.include
+                        ? ts.factory.createLessThanEquals
+                        : ts.factory.createLessThan)(
+                        input,
+                        caster(tag.maximum.value),
+                    ),
+                );
+        } else if (tag.kind === "minimum")
+            conditions.push(
+                ts.factory.createLessThanEquals(caster(tag.value), input),
+            );
+        else if (tag.kind === "maximum")
+            conditions.push(
+                ts.factory.createGreaterThanEquals(caster(tag.value), input),
+            );
+        else if (tag.kind === "exclusiveMinimum")
+            conditions.push(
+                ts.factory.createLessThan(caster(tag.value), input),
+            );
+        else if (tag.kind === "exclusiveMaximum")
+            conditions.push(
+                ts.factory.createGreaterThan(caster(tag.value), input),
+            );
+
+    // COMBINATION
+    return conditions.length === 1
+        ? conditions[0]!
+        : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+}