@typia/utils 12.0.0-dev.20260309 → 12.0.0-dev.20260311

package/src/validators/internal/OpenApiOneOfValidator.ts

@@ -1,309 +1,309 @@
-import { OpenApi } from "@typia/interface";
-
-import { MapUtil } from "../../utils";
-import { OpenApiTypeChecker } from "../OpenApiTypeChecker";
-import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
-import { OpenApiStationValidator } from "./OpenApiStationValidator";
-
-export namespace OpenApiOneOfValidator {
-  export const validate = (
-    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
-  ): boolean => {
-    const discriminator: IDiscriminator = getDiscriminator(ctx);
-    for (const item of discriminator.branches)
-      if (item.predicator(ctx.value))
-        return OpenApiStationValidator.validate({
-          ...ctx,
-          schema: item.schema,
-        });
-    if (discriminator.branches.length !== 0)
-      return validate({
-        ...ctx,
-        schema: {
-          oneOf: discriminator.remainders,
-        },
-      });
-    const matched: OpenApi.IJsonSchema | undefined =
-      discriminator.remainders.find(
-        (schema) =>
-          OpenApiStationValidator.validate({
-            ...ctx,
-            schema,
-            exceptionable: false,
-            equals: false,
-          }) === true,
-      );
-    if (matched === undefined) return ctx.report(ctx);
-    return ctx.equals === true
-      ? OpenApiStationValidator.validate({
-          ...ctx,
-          schema: matched,
-        })
-      : true;
-  };
-
-  const getDiscriminator = (
-    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
-  ): IDiscriminator => {
-    const resolvedList: IFlatSchema[] = ctx.schema.oneOf.map((schema) =>
-      getFlattened({
-        components: ctx.components,
-        schema,
-        visited: new Set(),
-      }),
-    );
-
-    // FIND ANY TYPE
-    const anything: IFlatSchema | undefined = resolvedList.find((resolved) =>
-      OpenApiTypeChecker.isUnknown(resolved.escaped),
-    );
-    if (anything)
-      return {
-        branches: [],
-        remainders: [anything.schema],
-      };
-
-    // CHECK NULLABLES
-    const nullables: IFlatSchema<OpenApi.IJsonSchema.INull>[] =
-      resolvedList.filter(
-        (resolved): resolved is IFlatSchema<OpenApi.IJsonSchema.INull> =>
-          OpenApiTypeChecker.isNull(resolved.schema),
-      );
-    const significant: IFlatSchema<OpenApi.IJsonSchema>[] = resolvedList.filter(
-      (resolved) => false === OpenApiTypeChecker.isNull(resolved.escaped),
-    );
-    if (significant.length === 1)
-      return {
-        branches: [
-          {
-            schema: significant[0]!.schema,
-            predicator: (value) => value !== null,
-          },
-        ],
-        remainders: nullables.map((nullable) => nullable.schema),
-      };
-
-    // DISCRIMINATIONS
-    const tuples = significant.filter((flat) =>
-      OpenApiTypeChecker.isTuple(flat.escaped),
-    );
-    const arrays = significant.filter(
-      (flat): flat is IFlatSchema<OpenApi.IJsonSchema.IArray> =>
-        OpenApiTypeChecker.isArray(flat.escaped),
-    );
-    const branches: IDiscriminatorBranch[] = [
-      ...(tuples.length === 0 && arrays.length !== 0
-        ? discriminateArrays(
-            ctx,
-            significant.filter(
-              (flat): flat is IFlatSchema<OpenApi.IJsonSchema.IArray> =>
-                OpenApiTypeChecker.isArray(flat.schema),
-            ),
-          )
-        : []),
-      ...discriminateObjects(
-        ctx,
-        significant.filter(
-          (flat): flat is IFlatSchema<OpenApi.IJsonSchema.IObject> =>
-            OpenApiTypeChecker.isObject(flat.escaped),
-        ),
-        tuples.length + arrays.length === 0,
-      ),
-    ];
-    return {
-      branches,
-      remainders: ctx.schema.oneOf.filter(
-        (x) => branches.some((y) => y.schema === x) === false,
-      ),
-    };
-  };
-
-  const discriminateArrays = (
-    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
-    arraySchemas: IFlatSchema<OpenApi.IJsonSchema.IArray>[],
-  ): IDiscriminatorBranch[] => {
-    if (arraySchemas.length === 1)
-      return [
-        {
-          schema: arraySchemas[0]!.schema,
-          predicator: (value) => Array.isArray(value),
-        },
-      ];
-    return arraySchemas
-      .filter((flat, i, array) =>
-        array.every(
-          (item, j) =>
-            i === j ||
-            OpenApiTypeChecker.covers({
-              components: ctx.components,
-              x: item.escaped.items,
-              y: flat.escaped.items,
-            }) === false,
-        ),
-      )
-      .map(
-        (flat) =>
-          ({
-            schema: flat.schema,
-            predicator: (value) =>
-              Array.isArray(value) &&
-              (value.length === 0 ||
-                OpenApiStationValidator.validate({
-                  ...ctx,
-                  schema: (flat.escaped as OpenApi.IJsonSchema.IArray).items,
-                  value: value[0]!,
-                  path: `${ctx.path}[0]`,
-                  exceptionable: false,
-                  equals: false,
-                })),
-          }) satisfies IDiscriminatorBranch,
-      );
-  };
-
-  const discriminateObjects = (
-    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
-    objectSchemas: IFlatSchema<OpenApi.IJsonSchema.IObject>[],
-    noArray: boolean,
-  ): IDiscriminatorBranch[] => {
-    if (objectSchemas.length === 1)
-      return [
-        {
-          schema: objectSchemas[0]!.schema,
-          predicator: noArray
-            ? (value) => typeof value === "object" && value !== null
-            : (value) =>
-                typeof value === "object" &&
-                value !== null &&
-                Array.isArray(value) === false,
-        },
-      ];
-
-    // KEEP ONLY REQUIRED PROPERTIES
-    objectSchemas = objectSchemas
-      .filter(
-        (flat) =>
-          flat.escaped.properties !== undefined &&
-          flat.escaped.required !== undefined,
-      )
-      .map(
-        (flat) =>
-          ({
-            ...flat,
-            escaped: {
-              ...flat.escaped,
-              properties: Object.fromEntries(
-                Object.entries(flat.escaped.properties ?? {}).map(
-                  ([key, value]) => [
-                    key,
-                    getFlattened({
-                      components: ctx.components,
-                      schema: value,
-                      visited: new Set(),
-                    }).escaped,
-                  ],
-                ),
-              ),
-            },
-          }) satisfies IFlatSchema<OpenApi.IJsonSchema.IObject>,
-      );
-
-    // PROPERTY MATRIX
-    const matrix: Map<string, Array<OpenApi.IJsonSchema | null>> = new Map();
-    objectSchemas.forEach((obj, i) => {
-      for (const [key, value] of Object.entries(obj.escaped.properties ?? {})) {
-        if (!!obj.escaped.required?.includes(key) === false) continue;
-        MapUtil.take(matrix, key, () =>
-          new Array(objectSchemas.length).fill(null),
-        )[i] = value;
-      }
-    });
-
-    // THE BRANCHES
-    return objectSchemas
-      .map((obj, i) => {
-        const candidates: string[] = [];
-        for (const [key, value] of Object.entries(
-          obj.escaped.properties ?? {},
-        )) {
-          if (!!obj.escaped.required?.includes(key) === false) continue;
-
-          const neighbors: OpenApi.IJsonSchema[] = matrix
-            .get(key)!
-            .filter((_oppo, j) => i !== j)
-            .filter((oppo) => oppo !== null);
-          const unique: boolean = OpenApiTypeChecker.isConstant(value)
-            ? neighbors.every(
-                (oppo) =>
-                  OpenApiTypeChecker.isConstant(oppo) &&
-                  value.const !== oppo.const,
-              )
-            : neighbors.length === 0;
-          if (unique) candidates.push(key);
-        }
-        if (candidates.length === 0) return null;
-        const top: string =
-          candidates.find((key) =>
-            OpenApiTypeChecker.isConstant(obj.escaped.properties![key]!),
-          ) ?? candidates[0]!;
-        const target: OpenApi.IJsonSchema = obj.escaped.properties![top]!;
-        return {
-          schema: obj.schema,
-          predicator: OpenApiTypeChecker.isConstant(target)
-            ? (value) =>
-                typeof value === "object" &&
-                value !== null &&
-                (value as any)[top] === target.const
-            : (value) =>
-                typeof value === "object" &&
-                value !== null &&
-                (value as any)[top] !== undefined,
-        } satisfies IDiscriminatorBranch;
-      })
-      .filter((b) => b !== null);
-  };
-}
-
-const getFlattened = (props: {
-  components: OpenApi.IComponents;
-  schema: OpenApi.IJsonSchema;
-  visited: Set<string>;
-}): IFlatSchema => {
-  if (OpenApiTypeChecker.isReference(props.schema)) {
-    const key: string = props.schema.$ref.split("/").pop() ?? "";
-    if (props.visited.has(key))
-      return {
-        schema: props.schema,
-        escaped: {},
-      };
-    props.visited.add(key);
-    return {
-      ...getFlattened({
-        components: props.components,
-        schema: props.components.schemas?.[key] ?? {},
-        visited: props.visited,
-      }),
-      schema: props.schema,
-    };
-  }
-  return {
-    schema: props.schema,
-    escaped: props.schema,
-  };
-};
-
-interface IDiscriminator {
-  branches: IDiscriminatorBranch[];
-  remainders: OpenApi.IJsonSchema[];
-}
-
-interface IDiscriminatorBranch {
-  schema: OpenApi.IJsonSchema;
-  predicator: (value: unknown) => boolean;
-}
-
-interface IFlatSchema<
-  Schema extends OpenApi.IJsonSchema = OpenApi.IJsonSchema,
-> {
-  schema: OpenApi.IJsonSchema;
-  escaped: Schema;
-}
+import { OpenApi } from "@typia/interface";
+
+import { MapUtil } from "../../utils";
+import { OpenApiTypeChecker } from "../OpenApiTypeChecker";
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+import { OpenApiStationValidator } from "./OpenApiStationValidator";
+
+export namespace OpenApiOneOfValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
+  ): boolean => {
+    const discriminator: IDiscriminator = getDiscriminator(ctx);
+    for (const item of discriminator.branches)
+      if (item.predicator(ctx.value))
+        return OpenApiStationValidator.validate({
+          ...ctx,
+          schema: item.schema,
+        });
+    if (discriminator.branches.length !== 0)
+      return validate({
+        ...ctx,
+        schema: {
+          oneOf: discriminator.remainders,
+        },
+      });
+    const matched: OpenApi.IJsonSchema | undefined =
+      discriminator.remainders.find(
+        (schema) =>
+          OpenApiStationValidator.validate({
+            ...ctx,
+            schema,
+            exceptionable: false,
+            equals: false,
+          }) === true,
+      );
+    if (matched === undefined) return ctx.report(ctx);
+    return ctx.equals === true
+      ? OpenApiStationValidator.validate({
+          ...ctx,
+          schema: matched,
+        })
+      : true;
+  };
+
+  const getDiscriminator = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
+  ): IDiscriminator => {
+    const resolvedList: IFlatSchema[] = ctx.schema.oneOf.map((schema) =>
+      getFlattened({
+        components: ctx.components,
+        schema,
+        visited: new Set(),
+      }),
+    );
+
+    // FIND ANY TYPE
+    const anything: IFlatSchema | undefined = resolvedList.find((resolved) =>
+      OpenApiTypeChecker.isUnknown(resolved.escaped),
+    );
+    if (anything)
+      return {
+        branches: [],
+        remainders: [anything.schema],
+      };
+
+    // CHECK NULLABLES
+    const nullables: IFlatSchema<OpenApi.IJsonSchema.INull>[] =
+      resolvedList.filter(
+        (resolved): resolved is IFlatSchema<OpenApi.IJsonSchema.INull> =>
+          OpenApiTypeChecker.isNull(resolved.schema),
+      );
+    const significant: IFlatSchema<OpenApi.IJsonSchema>[] = resolvedList.filter(
+      (resolved) => false === OpenApiTypeChecker.isNull(resolved.escaped),
+    );
+    if (significant.length === 1)
+      return {
+        branches: [
+          {
+            schema: significant[0]!.schema,
+            predicator: (value) => value !== null,
+          },
+        ],
+        remainders: nullables.map((nullable) => nullable.schema),
+      };
+
+    // DISCRIMINATIONS
+    const tuples = significant.filter((flat) =>
+      OpenApiTypeChecker.isTuple(flat.escaped),
+    );
+    const arrays = significant.filter(
+      (flat): flat is IFlatSchema<OpenApi.IJsonSchema.IArray> =>
+        OpenApiTypeChecker.isArray(flat.escaped),
+    );
+    const branches: IDiscriminatorBranch[] = [
+      ...(tuples.length === 0 && arrays.length !== 0
+        ? discriminateArrays(
+            ctx,
+            significant.filter(
+              (flat): flat is IFlatSchema<OpenApi.IJsonSchema.IArray> =>
+                OpenApiTypeChecker.isArray(flat.schema),
+            ),
+          )
+        : []),
+      ...discriminateObjects(
+        ctx,
+        significant.filter(
+          (flat): flat is IFlatSchema<OpenApi.IJsonSchema.IObject> =>
+            OpenApiTypeChecker.isObject(flat.escaped),
+        ),
+        tuples.length + arrays.length === 0,
+      ),
+    ];
+    return {
+      branches,
+      remainders: ctx.schema.oneOf.filter(
+        (x) => branches.some((y) => y.schema === x) === false,
+      ),
+    };
+  };
+
+  const discriminateArrays = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
+    arraySchemas: IFlatSchema<OpenApi.IJsonSchema.IArray>[],
+  ): IDiscriminatorBranch[] => {
+    if (arraySchemas.length === 1)
+      return [
+        {
+          schema: arraySchemas[0]!.schema,
+          predicator: (value) => Array.isArray(value),
+        },
+      ];
+    return arraySchemas
+      .filter((flat, i, array) =>
+        array.every(
+          (item, j) =>
+            i === j ||
+            OpenApiTypeChecker.covers({
+              components: ctx.components,
+              x: item.escaped.items,
+              y: flat.escaped.items,
+            }) === false,
+        ),
+      )
+      .map(
+        (flat) =>
+          ({
+            schema: flat.schema,
+            predicator: (value) =>
+              Array.isArray(value) &&
+              (value.length === 0 ||
+                OpenApiStationValidator.validate({
+                  ...ctx,
+                  schema: (flat.escaped as OpenApi.IJsonSchema.IArray).items,
+                  value: value[0]!,
+                  path: `${ctx.path}[0]`,
+                  exceptionable: false,
+                  equals: false,
+                })),
+          }) satisfies IDiscriminatorBranch,
+      );
+  };
+
+  const discriminateObjects = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
+    objectSchemas: IFlatSchema<OpenApi.IJsonSchema.IObject>[],
+    noArray: boolean,
+  ): IDiscriminatorBranch[] => {
+    if (objectSchemas.length === 1)
+      return [
+        {
+          schema: objectSchemas[0]!.schema,
+          predicator: noArray
+            ? (value) => typeof value === "object" && value !== null
+            : (value) =>
+                typeof value === "object" &&
+                value !== null &&
+                Array.isArray(value) === false,
+        },
+      ];
+
+    // KEEP ONLY REQUIRED PROPERTIES
+    objectSchemas = objectSchemas
+      .filter(
+        (flat) =>
+          flat.escaped.properties !== undefined &&
+          flat.escaped.required !== undefined,
+      )
+      .map(
+        (flat) =>
+          ({
+            ...flat,
+            escaped: {
+              ...flat.escaped,
+              properties: Object.fromEntries(
+                Object.entries(flat.escaped.properties ?? {}).map(
+                  ([key, value]) => [
+                    key,
+                    getFlattened({
+                      components: ctx.components,
+                      schema: value,
+                      visited: new Set(),
+                    }).escaped,
+                  ],
+                ),
+              ),
+            },
+          }) satisfies IFlatSchema<OpenApi.IJsonSchema.IObject>,
+      );
+
+    // PROPERTY MATRIX
+    const matrix: Map<string, Array<OpenApi.IJsonSchema | null>> = new Map();
+    objectSchemas.forEach((obj, i) => {
+      for (const [key, value] of Object.entries(obj.escaped.properties ?? {})) {
+        if (!!obj.escaped.required?.includes(key) === false) continue;
+        MapUtil.take(matrix, key, () =>
+          new Array(objectSchemas.length).fill(null),
+        )[i] = value;
+      }
+    });
+
+    // THE BRANCHES
+    return objectSchemas
+      .map((obj, i) => {
+        const candidates: string[] = [];
+        for (const [key, value] of Object.entries(
+          obj.escaped.properties ?? {},
+        )) {
+          if (!!obj.escaped.required?.includes(key) === false) continue;
+
+          const neighbors: OpenApi.IJsonSchema[] = matrix
+            .get(key)!
+            .filter((_oppo, j) => i !== j)
+            .filter((oppo) => oppo !== null);
+          const unique: boolean = OpenApiTypeChecker.isConstant(value)
+            ? neighbors.every(
+                (oppo) =>
+                  OpenApiTypeChecker.isConstant(oppo) &&
+                  value.const !== oppo.const,
+              )
+            : neighbors.length === 0;
+          if (unique) candidates.push(key);
+        }
+        if (candidates.length === 0) return null;
+        const top: string =
+          candidates.find((key) =>
+            OpenApiTypeChecker.isConstant(obj.escaped.properties![key]!),
+          ) ?? candidates[0]!;
+        const target: OpenApi.IJsonSchema = obj.escaped.properties![top]!;
+        return {
+          schema: obj.schema,
+          predicator: OpenApiTypeChecker.isConstant(target)
+            ? (value) =>
+                typeof value === "object" &&
+                value !== null &&
+                (value as any)[top] === target.const
+            : (value) =>
+                typeof value === "object" &&
+                value !== null &&
+                (value as any)[top] !== undefined,
+        } satisfies IDiscriminatorBranch;
+      })
+      .filter((b) => b !== null);
+  };
+}
+
+const getFlattened = (props: {
+  components: OpenApi.IComponents;
+  schema: OpenApi.IJsonSchema;
+  visited: Set<string>;
+}): IFlatSchema => {
+  if (OpenApiTypeChecker.isReference(props.schema)) {
+    const key: string = props.schema.$ref.split("/").pop() ?? "";
+    if (props.visited.has(key))
+      return {
+        schema: props.schema,
+        escaped: {},
+      };
+    props.visited.add(key);
+    return {
+      ...getFlattened({
+        components: props.components,
+        schema: props.components.schemas?.[key] ?? {},
+        visited: props.visited,
+      }),
+      schema: props.schema,
+    };
+  }
+  return {
+    schema: props.schema,
+    escaped: props.schema,
+  };
+};
+
+interface IDiscriminator {
+  branches: IDiscriminatorBranch[];
+  remainders: OpenApi.IJsonSchema[];
+}
+
+interface IDiscriminatorBranch {
+  schema: OpenApi.IJsonSchema;
+  predicator: (value: unknown) => boolean;
+}
+
+interface IFlatSchema<
+  Schema extends OpenApi.IJsonSchema = OpenApi.IJsonSchema,
+> {
+  schema: OpenApi.IJsonSchema;
+  escaped: Schema;
+}