anyvali 0.3.1

package/src/index.ts

@@ -0,0 +1,285 @@
+// ---- Re-export types ----
+export type {
+  SchemaNode,
+  SchemaKind,
+  ParseResult,
+  ValidationIssue,
+  AnyValiDocument,
+  ExportMode,
+  UnknownKeyMode,
+  CoercionConfig,
+  StringFormat,
+  ParseContext,
+  MetadataOptions,
+  DescribeOptions,
+} from "./types.js";
+
+export { ISSUE_CODES } from "./issue-codes.js";
+export type { IssueCode } from "./issue-codes.js";
+
+export type { SchemaAny, Infer, InferInput } from "./infer.js";
+
+export { ValidationError } from "./errors.js";
+
+// ---- Re-export schema classes ----
+export {
+  BaseSchema,
+  ABSENT,
+  StringSchema,
+  NumberSchema,
+  Float32Schema,
+  Float64Schema,
+  IntSchema,
+  Int8Schema,
+  Int16Schema,
+  Int32Schema,
+  Int64Schema,
+  Uint8Schema,
+  Uint16Schema,
+  Uint32Schema,
+  Uint64Schema,
+  BoolSchema,
+  NullSchema,
+  AnySchema,
+  UnknownSchema,
+  NeverSchema,
+  LiteralSchema,
+  EnumSchema,
+  ArraySchema,
+  TupleSchema,
+  ObjectSchema,
+  RecordSchema,
+  UnionSchema,
+  IntersectionSchema,
+  OptionalSchema,
+  NullableSchema,
+  RefSchema,
+} from "./schemas/index.js";
+
+// ---- Builder functions ----
+
+import { StringSchema } from "./schemas/string.js";
+import { NumberSchema, Float32Schema, Float64Schema } from "./schemas/number.js";
+import {
+  IntSchema,
+  Int8Schema,
+  Int16Schema,
+  Int32Schema,
+  Int64Schema,
+  Uint8Schema,
+  Uint16Schema,
+  Uint32Schema,
+  Uint64Schema,
+} from "./schemas/int.js";
+import { BoolSchema } from "./schemas/bool.js";
+import { NullSchema } from "./schemas/null.js";
+import { AnySchema } from "./schemas/any.js";
+import { UnknownSchema } from "./schemas/unknown.js";
+import { NeverSchema } from "./schemas/never.js";
+import { LiteralSchema } from "./schemas/literal.js";
+import { EnumSchema } from "./schemas/enum.js";
+import { ArraySchema } from "./schemas/array.js";
+import { TupleSchema } from "./schemas/tuple.js";
+import { ObjectSchema } from "./schemas/object.js";
+import { RecordSchema } from "./schemas/record.js";
+import { UnionSchema } from "./schemas/union.js";
+import { IntersectionSchema } from "./schemas/intersection.js";
+import { OptionalSchema } from "./schemas/optional.js";
+import { NullableSchema } from "./schemas/nullable.js";
+import { BaseSchema } from "./schemas/base.js";
+
+import type { UnknownKeyMode, ParseResult, AnyValiDocument, ExportMode } from "./types.js";
+
+/** Create a string schema */
+export function string(): StringSchema {
+  return new StringSchema();
+}
+
+/** Create a number (float64) schema */
+export function number(): NumberSchema {
+  return new NumberSchema();
+}
+
+/** Create a float32 schema */
+export function float32(): Float32Schema {
+  return new Float32Schema();
+}
+
+/** Create a float64 schema */
+export function float64(): Float64Schema {
+  return new Float64Schema();
+}
+
+/** Create an int (int64) schema */
+export function int(): IntSchema {
+  return new IntSchema();
+}
+
+/** Create an int8 schema */
+export function int8(): Int8Schema {
+  return new Int8Schema();
+}
+
+/** Create an int16 schema */
+export function int16(): Int16Schema {
+  return new Int16Schema();
+}
+
+/** Create an int32 schema */
+export function int32(): Int32Schema {
+  return new Int32Schema();
+}
+
+/** Create an int64 schema */
+export function int64(): Int64Schema {
+  return new Int64Schema();
+}
+
+/** Create a uint8 schema */
+export function uint8(): Uint8Schema {
+  return new Uint8Schema();
+}
+
+/** Create a uint16 schema */
+export function uint16(): Uint16Schema {
+  return new Uint16Schema();
+}
+
+/** Create a uint32 schema */
+export function uint32(): Uint32Schema {
+  return new Uint32Schema();
+}
+
+/** Create a uint64 schema */
+export function uint64(): Uint64Schema {
+  return new Uint64Schema();
+}
+
+/** Create a boolean schema */
+export function bool(): BoolSchema {
+  return new BoolSchema();
+}
+
+/** Create a null schema. Named null_ to avoid conflict with the null keyword. */
+export function null_(): NullSchema {
+  return new NullSchema();
+}
+
+/** Create an any schema */
+export function any(): AnySchema {
+  return new AnySchema();
+}
+
+/** Create an unknown schema */
+export function unknown(): UnknownSchema {
+  return new UnknownSchema();
+}
+
+/** Create a never schema */
+export function never(): NeverSchema {
+  return new NeverSchema();
+}
+
+/** Create a literal schema */
+export function literal<T extends string | number | boolean | null>(
+  value: T
+): LiteralSchema<T> {
+  return new LiteralSchema(value);
+}
+
+/** Create an enum schema. Named enum_ to avoid conflict with the enum keyword. */
+export function enum_<T extends readonly (string | number)[]>(
+  values: T,
+): EnumSchema<T> {
+  return new EnumSchema(values);
+}
+
+/** Create an array schema */
+export function array<T extends BaseSchema<any, any>>(
+  items: T,
+): ArraySchema<T> {
+  return new ArraySchema(items);
+}
+
+/** Create a tuple schema */
+export function tuple<T extends BaseSchema<any, any>[]>(
+  items: [...T],
+): TupleSchema<T> {
+  return new TupleSchema(items);
+}
+
+/** Create an object schema */
+export function object<T extends Record<string, BaseSchema<any, any>>>(
+  shape: T,
+  options?: { unknownKeys?: UnknownKeyMode },
+): ObjectSchema<T> {
+  return new ObjectSchema(shape, options);
+}
+
+/** Create a record schema */
+export function record<T extends BaseSchema<any, any>>(
+  valueSchema: T,
+): RecordSchema<T> {
+  return new RecordSchema(valueSchema);
+}
+
+/** Create a union schema */
+export function union<T extends BaseSchema<any, any>[]>(
+  variants: [...T],
+): UnionSchema<T> {
+  return new UnionSchema(variants);
+}
+
+/** Create an intersection schema */
+export function intersection<T extends BaseSchema<any, any>[]>(
+  schemas: [...T],
+): IntersectionSchema<T> {
+  return new IntersectionSchema(schemas);
+}
+
+/** Wrap a schema as optional */
+export function optional<T extends BaseSchema<any, any>>(
+  schema: T,
+): OptionalSchema<T> {
+  return new OptionalSchema(schema);
+}
+
+/** Wrap a schema as nullable */
+export function nullable<T extends BaseSchema<any, any>>(
+  schema: T,
+): NullableSchema<T> {
+  return new NullableSchema(schema);
+}
+
+// ---- Top-level parse functions ----
+
+/** Parse input using the given schema. Throws ValidationError on failure. */
+export function parse<T>(schema: BaseSchema<unknown, T>, input: unknown): T {
+  return schema.parse(input);
+}
+
+/** Parse input using the given schema. Returns a result object. */
+export function safeParse<T>(
+  schema: BaseSchema<unknown, T>,
+  input: unknown
+): ParseResult<T> {
+  return schema.safeParse(input);
+}
+
+// ---- Interchange functions ----
+
+import { exportSchema as _exportSchema } from "./interchange/exporter.js";
+import { importSchema as _importSchema } from "./interchange/importer.js";
+
+/** Export a schema to an AnyValiDocument */
+export function exportSchema(
+  schema: BaseSchema,
+  mode: ExportMode = "portable"
+): AnyValiDocument {
+  return _exportSchema(schema, mode);
+}
+
+/** Import an AnyValiDocument to a live schema */
+export function importSchema(doc: AnyValiDocument): BaseSchema {
+  return _importSchema(doc);
+}

package/src/infer.ts

@@ -0,0 +1,12 @@
+import type { BaseSchema } from "./schemas/base.js";
+
+/** Any AnyVali schema. Use as a generic constraint. Equivalent to Zod's ZodTypeAny. */
+export type SchemaAny = BaseSchema<any, any>;
+
+/** Extract the output type from a schema. Equivalent to Zod's z.infer. */
+export type Infer<T extends SchemaAny> = T["_output"];
+
+/** Extract the input type from a schema. */
+export type InferInput<T extends SchemaAny> = T extends BaseSchema<infer I, any>
+  ? I
+  : never;

package/src/interchange/document.ts

@@ -0,0 +1,18 @@
+import type { AnyValiDocument } from "../types.js";
+
+export const ANYVALI_VERSION = "1.0";
+export const SCHEMA_VERSION = "1";
+
+export function createDocument(
+  root: import("../types.js").SchemaNode,
+  definitions: Record<string, import("../types.js").SchemaNode> = {},
+  extensions: Record<string, Record<string, unknown>> = {}
+): AnyValiDocument {
+  return {
+    anyvaliVersion: ANYVALI_VERSION,
+    schemaVersion: SCHEMA_VERSION,
+    root,
+    definitions,
+    extensions,
+  };
+}

package/src/interchange/exporter.ts

@@ -0,0 +1,12 @@
+import type { AnyValiDocument, ExportMode } from "../types.js";
+import { BaseSchema } from "../schemas/base.js";
+
+/**
+ * Export a schema to a portable AnyValiDocument.
+ */
+export function exportSchema(
+  schema: BaseSchema,
+  mode: ExportMode = "portable"
+): AnyValiDocument {
+  return schema.export(mode);
+}

package/src/interchange/importer.ts

@@ -0,0 +1,285 @@
+import type {
+  AnyValiDocument,
+  SchemaNode,
+} from "../types.js";
+import { BaseSchema } from "../schemas/base.js";
+import { StringSchema } from "../schemas/string.js";
+import {
+  NumberSchema,
+  Float32Schema,
+  Float64Schema,
+} from "../schemas/number.js";
+import {
+  IntSchema,
+  Int8Schema,
+  Int16Schema,
+  Int32Schema,
+  Int64Schema,
+  Uint8Schema,
+  Uint16Schema,
+  Uint32Schema,
+  Uint64Schema,
+} from "../schemas/int.js";
+import { BoolSchema } from "../schemas/bool.js";
+import { NullSchema } from "../schemas/null.js";
+import { AnySchema } from "../schemas/any.js";
+import { UnknownSchema } from "../schemas/unknown.js";
+import { NeverSchema } from "../schemas/never.js";
+import { LiteralSchema } from "../schemas/literal.js";
+import { EnumSchema } from "../schemas/enum.js";
+import { ArraySchema } from "../schemas/array.js";
+import { TupleSchema } from "../schemas/tuple.js";
+import { ObjectSchema } from "../schemas/object.js";
+import { RecordSchema } from "../schemas/record.js";
+import { UnionSchema } from "../schemas/union.js";
+import { IntersectionSchema } from "../schemas/intersection.js";
+import { OptionalSchema } from "../schemas/optional.js";
+import { NullableSchema } from "../schemas/nullable.js";
+import { RefSchema } from "../schemas/ref.js";
+import { normalizeCoercionConfig } from "../parse/coerce.js";
+import type { StringFormat, UnknownKeyMode } from "../types.js";
+
+/**
+ * Import an AnyValiDocument back into a live Schema.
+ */
+/**
+ * Maximum schema-document nesting depth accepted by importSchema. Bounds the
+ * recursive importNode walk so an untrusted, deeply nested document cannot
+ * exhaust the call stack (DoS). Throws a controlled error instead of a
+ * RangeError stack overflow.
+ */
+const MAX_IMPORT_DEPTH = 512;
+
+export function importSchema(doc: AnyValiDocument): BaseSchema {
+  const definitions = doc.definitions ?? {};
+  const resolvedDefs = new Map<string, BaseSchema>();
+
+  function importNode(node: any, depth: number = 0): BaseSchema {
+    if (depth > MAX_IMPORT_DEPTH) {
+      throw new Error(
+        `Schema document too deeply nested (max depth ${MAX_IMPORT_DEPTH} exceeded)`
+      );
+    }
+    const d = depth + 1;
+    let schema: BaseSchema;
+
+    switch (node.kind) {
+      case "string": {
+        let s = new StringSchema();
+        if (node.minLength !== undefined) s = s.minLength(node.minLength);
+        if (node.maxLength !== undefined) s = s.maxLength(node.maxLength);
+        if (node.pattern !== undefined) s = s.pattern(node.pattern);
+        if (node.startsWith !== undefined) s = s.startsWith(node.startsWith);
+        if (node.endsWith !== undefined) s = s.endsWith(node.endsWith);
+        if (node.includes !== undefined) s = s.includes(node.includes);
+        if (node.format !== undefined)
+          s = s.format(node.format as StringFormat);
+        schema = s;
+        break;
+      }
+
+      case "number":
+      case "float64": {
+        let s =
+          node.kind === "float64" ? new Float64Schema() : new NumberSchema();
+        schema = applyNumericConstraints(s, node);
+        break;
+      }
+
+      case "float32": {
+        schema = applyNumericConstraints(new Float32Schema(), node);
+        break;
+      }
+
+      case "int":
+      case "int64": {
+        schema = applyNumericConstraints(
+          node.kind === "int64" ? new Int64Schema() : new IntSchema(),
+          node
+        );
+        break;
+      }
+
+      case "int8":
+        schema = applyNumericConstraints(new Int8Schema(), node);
+        break;
+      case "int16":
+        schema = applyNumericConstraints(new Int16Schema(), node);
+        break;
+      case "int32":
+        schema = applyNumericConstraints(new Int32Schema(), node);
+        break;
+      case "uint8":
+        schema = applyNumericConstraints(new Uint8Schema(), node);
+        break;
+      case "uint16":
+        schema = applyNumericConstraints(new Uint16Schema(), node);
+        break;
+      case "uint32":
+        schema = applyNumericConstraints(new Uint32Schema(), node);
+        break;
+      case "uint64":
+        schema = applyNumericConstraints(new Uint64Schema(), node);
+        break;
+
+      case "bool":
+        schema = new BoolSchema();
+        break;
+
+      case "null":
+        schema = new NullSchema();
+        break;
+
+      case "any":
+        schema = new AnySchema();
+        break;
+
+      case "unknown":
+        schema = new UnknownSchema();
+        break;
+
+      case "never":
+        schema = new NeverSchema();
+        break;
+
+      case "literal": {
+        schema = new LiteralSchema(node.value);
+        break;
+      }
+
+      case "enum": {
+        schema = new EnumSchema(node.values);
+        break;
+      }
+
+      case "array": {
+        let s = new ArraySchema(importNode(node.items, d));
+        if (node.minItems !== undefined) s = s.minItems(node.minItems);
+        if (node.maxItems !== undefined) s = s.maxItems(node.maxItems);
+        schema = s;
+        break;
+      }
+
+      case "tuple": {
+        // Corpus uses "elements", our export uses "items"
+        const elements = node.elements ?? node.items;
+        schema = new TupleSchema(
+          elements.map((i: any) => importNode(i, d))
+        );
+        break;
+      }
+
+      case "object": {
+        const shape: Record<string, BaseSchema> = Object.create(null);
+        const requiredSet = new Set<string>(node.required ?? []);
+        for (const [key, propNode] of Object.entries(
+          node.properties ?? {}
+        )) {
+          let propSchema = importNode(propNode, d);
+          if (!requiredSet.has(key)) {
+            propSchema = new OptionalSchema(propSchema);
+          }
+          // Use defineProperty to safely handle __proto__ and other special keys
+          Object.defineProperty(shape, key, {
+            value: propSchema,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+          });
+        }
+        Object.setPrototypeOf(shape, Object.prototype);
+        schema = new ObjectSchema(shape, {
+          unknownKeys:
+            (node.unknownKeys as UnknownKeyMode) ?? "strip",
+        });
+        break;
+      }
+
+      case "record": {
+        // Corpus uses "values", our export uses "valueSchema"
+        const valueNode = node.values ?? node.valueSchema;
+        schema = new RecordSchema(importNode(valueNode, d));
+        break;
+      }
+
+      case "union": {
+        schema = new UnionSchema(
+          node.variants.map((v: any) => importNode(v, d))
+        );
+        break;
+      }
+
+      case "intersection": {
+        schema = new IntersectionSchema(
+          node.allOf.map((s: any) => importNode(s, d))
+        );
+        break;
+      }
+
+      case "optional": {
+        // Corpus uses "schema", our export uses "inner"
+        const innerNode = node.schema ?? node.inner;
+        schema = new OptionalSchema(importNode(innerNode, d));
+        break;
+      }
+
+      case "nullable": {
+        // Corpus uses "schema", our export uses "inner"
+        const innerNode = node.schema ?? node.inner;
+        schema = new NullableSchema(importNode(innerNode, d));
+        break;
+      }
+
+      case "ref": {
+        const refPath = node.ref as string;
+        const defName = refPath.replace("#/definitions/", "");
+        schema = new RefSchema(refPath, () => {
+          if (resolvedDefs.has(defName)) {
+            return resolvedDefs.get(defName)!;
+          }
+          const defNode = definitions[defName];
+          if (!defNode) {
+            throw new Error(`Unresolved definition: ${defName}`);
+          }
+          const resolved = importNode(defNode);
+          resolvedDefs.set(defName, resolved);
+          return resolved;
+        });
+        break;
+      }
+
+      default:
+        throw new Error(`Unsupported schema kind: ${node.kind}`);
+    }
+
+    // Apply default
+    if (node.default !== undefined) {
+      schema = schema.default(node.default as any);
+    }
+
+    // Apply coercion config - handle both string and object formats
+    if (node.coerce !== undefined) {
+      const config = normalizeCoercionConfig(node.coerce);
+      schema = schema.coerce(config);
+    }
+
+    return schema;
+  }
+
+  return importNode(doc.root);
+}
+
+function applyNumericConstraints<T extends NumberSchema>(
+  schema: T,
+  node: any
+): T {
+  let s = schema;
+  if (node.min !== undefined) s = s.min(node.min) as T;
+  if (node.max !== undefined) s = s.max(node.max) as T;
+  if (node.exclusiveMin !== undefined)
+    s = s.exclusiveMin(node.exclusiveMin) as T;
+  if (node.exclusiveMax !== undefined)
+    s = s.exclusiveMax(node.exclusiveMax) as T;
+  if (node.multipleOf !== undefined) s = s.multipleOf(node.multipleOf) as T;
+  return s;
+}

package/src/issue-codes.ts

@@ -0,0 +1,19 @@
+export const ISSUE_CODES = {
+  INVALID_TYPE: "invalid_type",
+  REQUIRED: "required",
+  UNKNOWN_KEY: "unknown_key",
+  TOO_SMALL: "too_small",
+  TOO_LARGE: "too_large",
+  INVALID_STRING: "invalid_string",
+  INVALID_NUMBER: "invalid_number",
+  INVALID_LITERAL: "invalid_literal",
+  INVALID_UNION: "invalid_union",
+  CUSTOM_VALIDATION_NOT_PORTABLE: "custom_validation_not_portable",
+  UNSUPPORTED_EXTENSION: "unsupported_extension",
+  UNSUPPORTED_SCHEMA_KIND: "unsupported_schema_kind",
+  COERCION_FAILED: "coercion_failed",
+  DEFAULT_INVALID: "default_invalid",
+  TOO_DEEP: "too_deep",
+} as const;
+
+export type IssueCode = (typeof ISSUE_CODES)[keyof typeof ISSUE_CODES];