@typia/utils 12.0.0-dev.20260225

package/src/validators/internal/OpenApiStationValidator.ts

@@ -0,0 +1,115 @@
+import { OpenApi } from "@typia/interface";
+
+import { OpenApiTypeChecker } from "../OpenApiTypeChecker";
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+import { OpenApiArrayValidator } from "./OpenApiArrayValidator";
+import { OpenApiBooleanValidator } from "./OpenApiBooleanValidator";
+import { OpenApiConstantValidator } from "./OpenApiConstantValidator";
+import { OpenApiIntegerValidator } from "./OpenApiIntegerValidator";
+import { OpenApiNumberValidator } from "./OpenApiNumberValidator";
+import { OpenApiObjectValidator } from "./OpenApiObjectValidator";
+import { OpenApiOneOfValidator } from "./OpenApiOneOfValidator";
+import { OpenApiSchemaNamingRule } from "./OpenApiSchemaNamingRule";
+import { OpenApiStringValidator } from "./OpenApiStringValidator";
+import { OpenApiTupleValidator } from "./OpenApiTupleValidator";
+
+export namespace OpenApiStationValidator {
+  export const validate = (
+    ctx: Omit<IOpenApiValidatorContext<OpenApi.IJsonSchema>, "expected">,
+    expected?: string,
+  ): boolean => {
+    // THE TYPE NAME
+    expected ??= (() => {
+      const name = OpenApiSchemaNamingRule.getName(ctx.schema);
+      return ctx.required ? name : `${name} | undefined`;
+    })();
+
+    // COALESCE
+    if (OpenApiTypeChecker.isUnknown(ctx.schema)) return true;
+    else if (ctx.value === undefined)
+      return (
+        ctx.required === false ||
+        ctx.report({
+          ...ctx,
+          expected,
+        })
+      );
+    else if (OpenApiTypeChecker.isNull(ctx.schema))
+      return (
+        ctx.value === null ||
+        ctx.report({
+          ...ctx,
+          expected,
+        })
+      );
+    // NESTED
+    else if (OpenApiTypeChecker.isReference(ctx.schema)) {
+      const schema: OpenApi.IJsonSchema | undefined =
+        ctx.components.schemas?.[ctx.schema.$ref.split("/").pop() ?? ""];
+      if (schema === undefined) return true;
+      return OpenApiStationValidator.validate(
+        {
+          ...ctx,
+          schema,
+        },
+        expected,
+      );
+    } else if (OpenApiTypeChecker.isOneOf(ctx.schema))
+      return OpenApiOneOfValidator.validate({
+        ...ctx,
+        schema: ctx.schema,
+        expected,
+      });
+    // ATOMICS
+    else if (OpenApiTypeChecker.isConstant(ctx.schema))
+      return OpenApiConstantValidator.validate({
+        ...ctx,
+        schema: ctx.schema,
+        expected,
+      });
+    else if (OpenApiTypeChecker.isBoolean(ctx.schema))
+      return OpenApiBooleanValidator.validate({
+        ...ctx,
+        schema: ctx.schema,
+        expected,
+      });
+    else if (OpenApiTypeChecker.isInteger(ctx.schema))
+      return OpenApiIntegerValidator.validate({
+        ...ctx,
+        schema: ctx.schema,
+        expected,
+      });
+    else if (OpenApiTypeChecker.isNumber(ctx.schema))
+      return OpenApiNumberValidator.validate({
+        ...ctx,
+        schema: ctx.schema,
+        expected,
+      });
+    else if (OpenApiTypeChecker.isString(ctx.schema))
+      return OpenApiStringValidator.validate({
+        ...ctx,
+        schema: ctx.schema,
+        expected,
+      });
+    // INSTANCES
+    else if (OpenApiTypeChecker.isArray(ctx.schema))
+      return OpenApiArrayValidator.validate({
+        ...ctx,
+        schema: ctx.schema,
+        expected,
+      });
+    else if (OpenApiTypeChecker.isTuple(ctx.schema))
+      return OpenApiTupleValidator.validate({
+        ...ctx,
+        schema: ctx.schema,
+        expected,
+      });
+    else if (OpenApiTypeChecker.isObject(ctx.schema))
+      return OpenApiObjectValidator.validate({
+        ...ctx,
+        schema: ctx.schema,
+        expected,
+      });
+    return true;
+  };
+}

package/src/validators/internal/OpenApiStringValidator.ts

@@ -0,0 +1,88 @@
+import { OpenApi } from "@typia/interface";
+
+import { _isFormatByte } from "../functional/_isFormatByte";
+import { _isFormatDate } from "../functional/_isFormatDate";
+import { _isFormatDateTime } from "../functional/_isFormatDateTime";
+import { _isFormatDuration } from "../functional/_isFormatDuration";
+import { _isFormatEmail } from "../functional/_isFormatEmail";
+import { _isFormatHostname } from "../functional/_isFormatHostname";
+import { _isFormatIdnEmail } from "../functional/_isFormatIdnEmail";
+import { _isFormatIdnHostname } from "../functional/_isFormatIdnHostname";
+import { _isFormatIpv4 } from "../functional/_isFormatIpv4";
+import { _isFormatIpv6 } from "../functional/_isFormatIpv6";
+import { _isFormatIri } from "../functional/_isFormatIri";
+import { _isFormatIriReference } from "../functional/_isFormatIriReference";
+import { _isFormatJsonPointer } from "../functional/_isFormatJsonPointer";
+import { _isFormatRegex } from "../functional/_isFormatRegex";
+import { _isFormatRelativeJsonPointer } from "../functional/_isFormatRelativeJsonPointer";
+import { _isFormatTime } from "../functional/_isFormatTime";
+import { _isFormatUri } from "../functional/_isFormatUri";
+import { _isFormatUriReference } from "../functional/_isFormatUriReference";
+import { _isFormatUriTemplate } from "../functional/_isFormatUriTemplate";
+import { _isFormatUrl } from "../functional/_isFormatUrl";
+import { _isFormatUuid } from "../functional/_isFormatUuid";
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+
+export namespace OpenApiStringValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IString>,
+  ): boolean => {
+    if (typeof ctx.value !== "string") return ctx.report(ctx);
+    return (
+      [
+        ctx.schema.minLength !== undefined
+          ? ctx.value.length >= ctx.schema.minLength ||
+            ctx.report({
+              ...ctx,
+              expected: `string & MinLength<${ctx.schema.minLength}>`,
+            })
+          : true,
+        ctx.schema.maxLength !== undefined
+          ? ctx.value.length <= ctx.schema.maxLength ||
+            ctx.report({
+              ...ctx,
+              expected: `string & MaxLength<${ctx.schema.maxLength}>`,
+            })
+          : true,
+        ctx.schema.pattern !== undefined
+          ? new RegExp(ctx.schema.pattern).test(ctx.value) ||
+            ctx.report({
+              ...ctx,
+              expected: `string & Pattern<${JSON.stringify(ctx.schema.pattern)}>`,
+            })
+          : true,
+        ctx.schema.format && FORMAT[ctx.schema.format as "uuid"]
+          ? FORMAT[ctx.schema.format as "uuid"](ctx.value) ||
+            ctx.report({
+              ...ctx,
+              expected: `string & Format<${JSON.stringify(ctx.schema.format)}>`,
+            })
+          : true,
+      ].every((v) => v) || ctx.report(ctx)
+    );
+  };
+}
+
+const FORMAT = {
+  byte: _isFormatByte,
+  regex: _isFormatRegex,
+  uuid: _isFormatUuid,
+  email: _isFormatEmail,
+  hostname: _isFormatHostname,
+  "idn-email": _isFormatIdnEmail,
+  "idn-hostname": _isFormatIdnHostname,
+  iri: _isFormatIri,
+  "iri-reference": _isFormatIriReference,
+  ipv4: _isFormatIpv4,
+  ipv6: _isFormatIpv6,
+  uri: _isFormatUri,
+  "uri-reference": _isFormatUriReference,
+  "uri-template": _isFormatUriTemplate,
+  url: _isFormatUrl,
+  "date-time": _isFormatDateTime,
+  date: _isFormatDate,
+  time: _isFormatTime,
+  duration: _isFormatDuration,
+  "json-pointer": _isFormatJsonPointer,
+  "relative-json-pointer": _isFormatRelativeJsonPointer,
+};

package/src/validators/internal/OpenApiTupleValidator.ts

@@ -0,0 +1,55 @@
+import { OpenApi } from "@typia/interface";
+
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+import { OpenApiStationValidator } from "./OpenApiStationValidator";
+
+export namespace OpenApiTupleValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.ITuple>,
+  ): boolean => {
+    if (!Array.isArray(ctx.value)) return ctx.report(ctx);
+    else if (!!ctx.schema.additionalItems === false) {
+      if (ctx.value.length !== ctx.schema.prefixItems.length)
+        return ctx.report(ctx);
+      return ctx.value
+        .map((v, i) =>
+          OpenApiStationValidator.validate({
+            ...ctx,
+            schema: ctx.schema.prefixItems[i]!,
+            value: v,
+            path: `${ctx.path}[${i}]`,
+          }),
+        )
+        .every((v) => v);
+    }
+
+    if (ctx.value.length < ctx.schema.prefixItems.length)
+      return ctx.report(ctx);
+    const next =
+      typeof ctx.schema.additionalItems === "object" &&
+      ctx.schema.additionalItems !== null
+        ? (v: unknown, i: number) =>
+            OpenApiStationValidator.validate({
+              ...ctx,
+              schema: ctx.schema.additionalItems as OpenApi.IJsonSchema,
+              value: v,
+              path: `${ctx.path}[${i}]`,
+            })
+        : () => true;
+    return (
+      ctx.value.length >= ctx.schema.prefixItems.length &&
+      ctx.value
+        .map((v, i) =>
+          i < ctx.schema.prefixItems.length
+            ? OpenApiStationValidator.validate({
+                ...ctx,
+                schema: ctx.schema.prefixItems[i]!,
+                value: v,
+                path: `${ctx.path}[${i}]`,
+              })
+            : next(v, i),
+        )
+        .every((v) => v)
+    );
+  };
+}