typia 7.0.0-dev.20240918 → 7.0.0-dev.20240920

package/src/programmers/internal/application_v31_object.ts

@@ -16,110 +16,124 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 /**
  * @internal
  */
-export const application_v31_object =
-  (components: OpenApi.IComponents) =>
-  (
-    obj: MetadataObject,
-  ): OpenApi.IJsonSchema.IReference | OpenApi.IJsonSchema.IObject => {
-    if (obj.isLiteral() === true) return create_object_schema(components)(obj);
-
-    const key: string = obj.name;
-    const $ref: string = `#/components/schemas/${key}`;
-    if (components.schemas?.[key] !== undefined) return { $ref };
-
-    const object: OpenApiV3.IJsonSchema = {};
-    components.schemas ??= {};
-    components.schemas[key] = object;
-    Object.assign(object, create_object_schema(components)(obj));
-    return { $ref };
-  };
+export const application_v31_object = (props: {
+  components: OpenApi.IComponents;
+  object: MetadataObject;
+}): OpenApi.IJsonSchema.IReference | OpenApi.IJsonSchema.IObject => {
+  if (props.object.isLiteral() === true) return create_object_schema(props);
+
+  const key: string = props.object.name;
+  const $ref: string = `#/components/schemas/${key}`;
+  if (props.components.schemas?.[key] !== undefined) return { $ref };
+
+  const lazy: OpenApiV3.IJsonSchema = {};
+  props.components.schemas ??= {};
+  props.components.schemas[key] = lazy;
+  Object.assign(lazy, create_object_schema(props));
+  return { $ref };
+};
 
 /**
  * @internal
  */
-const create_object_schema =
-  (components: OpenApi.IComponents) =>
-  (obj: MetadataObject): OpenApi.IJsonSchema.IObject => {
-    // ITERATE PROPERTIES
-    const properties: Record<string, any> = {};
-    const extraMeta: ISuperfluous = {
-      patternProperties: {},
-      additionalProperties: undefined,
-    };
-    const required: string[] = [];
-
-    for (const property of obj.properties) {
-      if (
-        // FUNCTIONAL TYPE
-        property.value.functions.length &&
-        property.value.nullable === false &&
-        property.value.isRequired() === true &&
-        property.value.size() === 0
-      )
-        continue;
-      else if (property.jsDocTags.find((tag) => tag.name === "hidden"))
-        continue; // THE HIDDEN TAG
-
-      const key: string | null = property.key.getSoleLiteral();
-      const schema: OpenApi.IJsonSchema | null = application_v31_schema(true)(
-        components,
-      )({
+const create_object_schema = (props: {
+  components: OpenApi.IComponents;
+  object: MetadataObject;
+}): OpenApi.IJsonSchema.IObject => {
+  // ITERATE PROPERTIES
+  const properties: Record<string, any> = {};
+  const extraMeta: ISuperfluous = {
+    patternProperties: {},
+    additionalProperties: undefined,
+  };
+  const required: string[] = [];
+
+  for (const property of props.object.properties) {
+    if (
+      // FUNCTIONAL TYPE
+      property.value.functions.length &&
+      property.value.nullable === false &&
+      property.value.isRequired() === true &&
+      property.value.size() === 0
+    )
+      continue;
+    else if (property.jsDocTags.find((tag) => tag.name === "hidden")) continue; // THE HIDDEN TAG
+
+    const key: string | null = property.key.getSoleLiteral();
+    const schema: OpenApi.IJsonSchema | null = application_v31_schema({
+      blockNever: true,
+      components: props.components,
+      attribute: {
         deprecated:
           property.jsDocTags.some((tag) => tag.name === "deprecated") ||
           undefined,
         title: application_title(property),
         description: application_description(property),
-      })(property.value);
-
-      if (schema === null) continue;
-      if (key !== null) {
-        properties[key] = schema;
-        if (property.value.isRequired() === true) required.push(key);
-      } else {
-        const pattern: string = metadata_to_pattern(true)(property.key);
-        if (pattern === PatternUtil.STRING)
-          extraMeta.additionalProperties = [property.value, schema];
-        else extraMeta.patternProperties[pattern] = [property.value, schema];
-      }
+      },
+      metadata: property.value,
+    });
+
+    if (schema === null) continue;
+    if (key !== null) {
+      properties[key] = schema;
+      if (property.value.isRequired() === true) required.push(key);
+    } else {
+      const pattern: string = metadata_to_pattern(true)(property.key);
+      if (pattern === PatternUtil.STRING)
+        extraMeta.additionalProperties = [property.value, schema];
+      else extraMeta.patternProperties[pattern] = [property.value, schema];
     }
-
-    return {
-      type: "object",
-      properties,
-      required: required.length ? required : undefined,
-      title: (() => {
-        const info: IJsDocTagInfo | undefined = obj.jsDocTags.find(
-          (tag) => tag.name === "title",
-        );
-        return info?.text?.length ? CommentFactory.merge(info.text) : undefined;
-      })(),
-      description: application_description(obj),
-      additionalProperties: join(components)(extraMeta),
-    };
+  }
+
+  return {
+    type: "object",
+    properties,
+    required: required.length ? required : undefined,
+    title: (() => {
+      const info: IJsDocTagInfo | undefined = props.object.jsDocTags.find(
+        (tag) => tag.name === "title",
+      );
+      return info?.text?.length ? CommentFactory.merge(info.text) : undefined;
+    })(),
+    description: application_description(props.object),
+    additionalProperties: join({
+      components: props.components,
+      extra: extraMeta,
+    }),
   };
+};
 
 /**
  * @internal
  */
-const join =
-  (components: OpenApi.IComponents) =>
-  (extra: ISuperfluous): OpenApi.IJsonSchema | undefined => {
-    // LIST UP METADATA
-    const elements: [Metadata, OpenApi.IJsonSchema][] = Object.values(
-      extra.patternProperties || {},
-    );
-    if (extra.additionalProperties) elements.push(extra.additionalProperties);
-
-    // SHORT RETURN
-    if (elements.length === 0) return undefined;
-    else if (elements.length === 1) return elements[0]![1]!;
-
-    // MERGE METADATA AND GENERATE VULNERABLE SCHEMA
-    const meta: Metadata = elements
-      .map((tuple) => tuple[0])
-      .reduce((x, y) => Metadata.merge(x, y));
-    return application_v31_schema(true)(components)({})(meta) ?? undefined;
-  };
+const join = (props: {
+  components: OpenApi.IComponents;
+  extra: ISuperfluous;
+}): OpenApi.IJsonSchema | undefined => {
+  // LIST UP METADATA
+  const elements: [Metadata, OpenApi.IJsonSchema][] = Object.values(
+    props.extra.patternProperties || {},
+  );
+  if (props.extra.additionalProperties)
+    elements.push(props.extra.additionalProperties);
+
+  // SHORT RETURN
+  if (elements.length === 0) return undefined;
+  else if (elements.length === 1) return elements[0]![1]!;
+
+  // MERGE METADATA AND GENERATE VULNERABLE SCHEMA
+  const metadata: Metadata = elements
+    .map((tuple) => tuple[0])
+    .reduce((x, y) => Metadata.merge(x, y));
+  return (
+    application_v31_schema({
+      blockNever: true,
+      components: props.components,
+      attribute: {},
+      metadata,
+    }) ?? undefined
+  );
+};
 
 /**
  * @internal

package/src/programmers/internal/application_v31_schema.ts

@@ -21,139 +21,195 @@ import { application_v31_tuple } from "./application_v31_tuple";
 /**
  * @internal
  */
-export const application_v31_schema =
-  <BlockNever extends boolean>(blockNever: BlockNever) =>
-  (components: OpenApi.IComponents) =>
-  (attribute: OpenApi.IJsonSchema.__IAttribute) =>
-  (
-    meta: Metadata,
-  ): BlockNever extends true
-    ? OpenApi.IJsonSchema | null
-    : OpenApi.IJsonSchema => {
-    if (meta.any === true)
-      return {
-        ...attribute,
-        type: undefined,
-      };
+export const application_v31_schema = <BlockNever extends boolean>(props: {
+  blockNever: BlockNever;
+  components: OpenApi.IComponents;
+  attribute: OpenApi.IJsonSchema.__IAttribute;
+  metadata: Metadata;
+}): BlockNever extends true
+  ? OpenApi.IJsonSchema | null
+  : OpenApi.IJsonSchema => {
+  if (props.metadata.any === true)
+    return {
+      ...props.attribute,
+      type: undefined,
+    };
+
+  //----
+  // GATHER UNION SCHEMAS
+  //----
+  const union: OpenApi.IJsonSchema[] = [];
+  const insert = (schema: OpenApi.IJsonSchema) => union.push(schema);
 
-    //----
-    // GATHER UNION SCHEMAS
-    //----
-    const union: OpenApi.IJsonSchema[] = [];
-    const insert = (schema: OpenApi.IJsonSchema) => union.push(schema);
+  // NULLABLE
+  if (props.metadata.nullable === true)
+    insert({
+      type: "null",
+    });
 
-    // NULLABLE
-    if (meta.nullable === true)
-      insert({
-        type: "null",
-      });
+  // toJSON() METHOD
+  if (props.metadata.escaped !== null)
+    application_escaped({
+      generator: (metadata) =>
+        application_v31_schema({
+          blockNever: false as const,
+          components: props.components,
+          attribute: {},
+          metadata,
+        }),
+      escaped: props.metadata.escaped,
+    }).forEach(insert as any);
 
-    // toJSON() METHOD
-    if (meta.escaped !== null)
-      application_escaped(application_v31_schema(false)(components)({}))(
-        meta.escaped,
-      ).forEach(insert as any);
+  // ATOMIC TYPES
+  if (
+    props.metadata.templates.length &&
+    AtomicPredicator.template(props.metadata)
+  )
+    application_templates(props.metadata).map(insert as any);
+  for (const constant of props.metadata.constants)
+    if (
+      AtomicPredicator.constant({
+        metadata: props.metadata,
+        name: constant.type,
+      }) === false
+    )
+      continue;
+    else application_v31_constant(constant).map(insert);
+  for (const a of props.metadata.atomics)
+    if (a.type === "boolean") application_boolean(a).forEach(insert as any);
+    else if (a.type === "bigint") application_bigint(a).forEach(insert as any);
+    else if (a.type === "number") application_number(a).forEach(insert as any);
+    else if (a.type === "string") application_string(a).forEach(insert as any);
 
-    // ATOMIC TYPES
-    if (meta.templates.length && AtomicPredicator.template(meta))
-      application_templates(meta).map(insert as any);
-    for (const constant of meta.constants)
-      if (AtomicPredicator.constant(meta)(constant.type) === false) continue;
-      else application_v31_constant(constant).map(insert);
-    for (const a of meta.atomics)
-      if (a.type === "boolean") application_boolean(a).forEach(insert as any);
-      else if (a.type === "bigint")
-        application_bigint(a).forEach(insert as any);
-      else if (a.type === "number")
-        application_number(a).forEach(insert as any);
-      else if (a.type === "string")
-        application_string(a).forEach(insert as any);
+  // ARRAY
+  for (const array of props.metadata.arrays)
+    application_array({
+      generator: (metadata) =>
+        application_v31_schema({
+          blockNever: false as const,
+          components: props.components,
+          attribute: {},
+          metadata,
+        }),
+      components: props.components,
+      array,
+    }).forEach(insert as any);
 
-    // ARRAY
-    for (const array of meta.arrays)
-      application_array(application_v31_schema(false)(components)({}))(
-        components,
-      )(array).forEach(insert as any);
+  // TUPLE
+  for (const tuple of props.metadata.tuples)
+    insert(
+      application_v31_tuple({
+        generator: (metadata) =>
+          application_v31_schema({
+            blockNever: false as const,
+            components: props.components,
+            attribute: {},
+            metadata,
+          }),
+        tuple,
+      }),
+    );
 
-    // TUPLE
-    for (const tuple of meta.tuples)
+  // NATIVES
+  for (const native of props.metadata.natives)
+    if (AtomicPredicator.native(native)) {
+      const type: string = native.toLowerCase();
+      if (props.metadata.atomics.some((a) => a.type === type)) continue;
+      else if (type === "boolean")
+        insert(
+          application_boolean(
+            MetadataAtomic.create({
+              type: "boolean",
+              tags: [],
+            }),
+          )[0]! as any,
+        );
+      else if (type === "bigint")
+        insert(
+          application_bigint(
+            MetadataAtomic.create({
+              type: "bigint",
+              tags: [],
+            }),
+          )[0]! as any,
+        );
+      else if (type === "number")
+        insert(
+          application_number(
+            MetadataAtomic.create({
+              type: "number",
+              tags: [],
+            }),
+          )[0]! as any,
+        );
+      else if (type === "string")
+        insert(
+          application_string(
+            MetadataAtomic.create({
+              type: "string",
+              tags: [],
+            }),
+          )[0]! as any,
+        );
+    } else
       insert(
-        application_v31_tuple(application_v31_schema(false)(components)({}))(
-          tuple,
-        ),
+        application_v31_native({
+          components: props.components,
+          name: native,
+        }),
       );
+  if (props.metadata.sets.length)
+    insert(
+      application_v31_native({
+        name: "Set",
+        components: props.components,
+      }),
+    );
+  if (props.metadata.maps.length)
+    insert(
+      application_v31_native({
+        name: "Map",
+        components: props.components,
+      }),
+    );
 
-    // NATIVES
-    for (const native of meta.natives)
-      if (AtomicPredicator.native(native)) {
-        const type: string = native.toLowerCase();
-        if (meta.atomics.some((a) => a.type === type)) continue;
-        else if (type === "boolean")
-          insert(
-            application_boolean(
-              MetadataAtomic.create({
-                type: "boolean",
-                tags: [],
-              }),
-            )[0]! as any,
-          );
-        else if (type === "bigint")
-          insert(
-            application_bigint(
-              MetadataAtomic.create({
-                type: "bigint",
-                tags: [],
-              }),
-            )[0]! as any,
-          );
-        else if (type === "number")
-          insert(
-            application_number(
-              MetadataAtomic.create({
-                type: "number",
-                tags: [],
-              }),
-            )[0]! as any,
-          );
-        else if (type === "string")
-          insert(
-            application_string(
-              MetadataAtomic.create({
-                type: "string",
-                tags: [],
-              }),
-            )[0]! as any,
-          );
-      } else insert(application_v31_native(components)(native));
-    if (meta.sets.length) insert(application_v31_native(components)(`Set`));
-    if (meta.maps.length) insert(application_v31_native(components)(`Map`));
+  // OBJECT
+  for (const object of props.metadata.objects)
+    insert(
+      application_v31_object({
+        components: props.components,
+        object,
+      }),
+    );
 
-    // OBJECT
-    for (const obj of meta.objects)
-      insert(application_v31_object(components)(obj));
+  // ALIASES
+  for (const alias of props.metadata.aliases)
+    insert(
+      application_v31_alias({
+        alias,
+        blockNever: props.blockNever,
+        components: props.components,
+      }),
+    );
 
-    // ALIASES
-    for (const alias of meta.aliases)
-      insert(application_v31_alias(blockNever)(components)(alias));
-
-    //----
-    // RETURNS
-    //----
-    if (union.length === 0 && blockNever === true) return null!;
-    const schema: OpenApi.IJsonSchema =
-      union.length === 0
-        ? { type: undefined }
-        : union.length === 1
-          ? union[0]!
-          : {
-              oneOf: union,
-              discriminator: application_union_discriminator(meta),
-            };
-    return {
-      ...schema,
-      ...attribute,
-      title: attribute.title ?? schema.title,
-      description: attribute.description ?? schema.description,
-      deprecated: attribute.deprecated ?? schema.deprecated,
-    };
+  //----
+  // RETURNS
+  //----
+  if (union.length === 0 && props.blockNever === true) return null!;
+  const schema: OpenApi.IJsonSchema =
+    union.length === 0
+      ? { type: undefined }
+      : union.length === 1
+        ? union[0]!
+        : {
+            oneOf: union,
+            discriminator: application_union_discriminator(props.metadata),
+          };
+  return {
+    ...schema,
+    ...props.attribute,
+    title: props.attribute.title ?? schema.title,
+    description: props.attribute.description ?? schema.description,
+    deprecated: props.attribute.deprecated ?? schema.deprecated,
   };
+};

package/src/programmers/internal/application_v31_tuple.ts

@@ -6,16 +6,17 @@ import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 /**
  * @internal
  */
-export const application_v31_tuple =
-  (generator: (meta: Metadata) => OpenApi.IJsonSchema) =>
-  (tuple: MetadataTuple): OpenApi.IJsonSchema.ITuple => {
-    const tail: Metadata | null = tuple.type.elements.at(-1)?.rest ?? null;
-    const prefixItems: Metadata[] = tuple.type.isRest()
-      ? tuple.type.elements.slice(0, -1)
-      : tuple.type.elements;
-    return {
-      type: "array",
-      prefixItems: prefixItems.map(generator),
-      additionalItems: tail ? generator(tail) : false,
-    };
+export const application_v31_tuple = (props: {
+  generator: (meta: Metadata) => OpenApi.IJsonSchema;
+  tuple: MetadataTuple;
+}): OpenApi.IJsonSchema.ITuple => {
+  const tail: Metadata | null = props.tuple.type.elements.at(-1)?.rest ?? null;
+  const prefixItems: Metadata[] = props.tuple.type.isRest()
+    ? props.tuple.type.elements.slice(0, -1)
+    : props.tuple.type.elements;
+  return {
+    type: "array",
+    prefixItems: prefixItems.map(props.generator),
+    additionalItems: tail ? props.generator(tail) : false,
   };
+};

package/src/programmers/internal/check_array_length.ts

@@ -1,45 +1,45 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_array_length =
-  (project: ITypiaContext) =>
-  (array: MetadataArray) =>
-  (input: ts.Expression): ICheckEntry => {
-    const conditions: ICheckEntry.ICondition[][] = check_string_type_tags(
-      project,
-    )(array.tags)(input);
-
-    return {
-      expected: array.getName(),
-      expression: null,
-      conditions,
-    };
-  };
-
-const check_string_type_tags =
-  (project: ITypiaContext) =>
-  (matrix: IMetadataTypeTag[][]) =>
-  (input: ts.Expression): ICheckEntry.ICondition[][] =>
-    matrix
-      .map((row) => row.filter((tag) => !!tag.validate))
-      .filter((row) => !!row.length)
-      .map((row) =>
-        row.map((tag) => ({
-          expected: `Array<> & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.transformer)(tag.validate!)
-          )(input),
-        })),
-      );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_array_length =
+  (project: ITypiaContext) =>
+  (array: MetadataArray) =>
+  (input: ts.Expression): ICheckEntry => {
+    const conditions: ICheckEntry.ICondition[][] = check_string_type_tags(
+      project,
+    )(array.tags)(input);
+
+    return {
+      expected: array.getName(),
+      expression: null,
+      conditions,
+    };
+  };
+
+const check_string_type_tags =
+  (project: ITypiaContext) =>
+  (matrix: IMetadataTypeTag[][]) =>
+  (input: ts.Expression): ICheckEntry.ICondition[][] =>
+    matrix
+      .map((row) => row.filter((tag) => !!tag.validate))
+      .filter((row) => !!row.length)
+      .map((row) =>
+        row.map((tag) => ({
+          expected: `Array<> & ${tag.name}`,
+          expression: (
+            tag.predicate ??
+            ExpressionFactory.transpile(project.transformer)(tag.validate!)
+          )(input),
+        })),
+      );