anyvali 0.3.1 → 0.3.3

package/src/types.ts

@@ -1,239 +1,239 @@
-// ---- Schema Node (interchange JSON representation) ----
-
-export type SchemaKind =
-  | "any"
-  | "unknown"
-  | "never"
-  | "null"
-  | "bool"
-  | "string"
-  | "number"
-  | "int"
-  | "float32"
-  | "float64"
-  | "int8"
-  | "int16"
-  | "int32"
-  | "int64"
-  | "uint8"
-  | "uint16"
-  | "uint32"
-  | "uint64"
-  | "literal"
-  | "enum"
-  | "array"
-  | "tuple"
-  | "object"
-  | "record"
-  | "union"
-  | "intersection"
-  | "optional"
-  | "nullable"
-  | "ref";
-
-export interface MetadataOptions {
-  replace?: boolean;
-}
-
-export interface DescribeOptions {
-  title?: string;
-  deprecated?: boolean;
-  deprecatedMessage?: string;
-  notStable?: boolean;
-  since?: string;
-  sensitive?: boolean;
-  readonly?: boolean;
-  writeonly?: boolean;
-  examples?: unknown[];
-}
-
-export interface SchemaNodeBase {
-  kind: SchemaKind;
-  default?: unknown;
-  coerce?: CoercionConfig | string | string[];
-  metadata?: Record<string, unknown>;
-}
-
-export interface CoercionConfig {
-  from?: string;
-  trim?: boolean;
-  lower?: boolean;
-  upper?: boolean;
-}
-
-// String node
-export interface StringSchemaNode extends SchemaNodeBase {
-  kind: "string";
-  minLength?: number;
-  maxLength?: number;
-  pattern?: string;
-  startsWith?: string;
-  endsWith?: string;
-  includes?: string;
-  format?: StringFormat;
-}
-
-export type StringFormat =
-  | "email"
-  | "url"
-  | "uuid"
-  | "ipv4"
-  | "ipv6"
-  | "date"
-  | "date-time";
-
-// Numeric nodes
-export interface NumericSchemaNode extends SchemaNodeBase {
-  kind:
-    | "number"
-    | "int"
-    | "float32"
-    | "float64"
-    | "int8"
-    | "int16"
-    | "int32"
-    | "int64"
-    | "uint8"
-    | "uint16"
-    | "uint32"
-    | "uint64";
-  min?: number;
-  max?: number;
-  exclusiveMin?: number;
-  exclusiveMax?: number;
-  multipleOf?: number;
-}
-
-// Simple nodes
-export interface SimpleSchemaNode extends SchemaNodeBase {
-  kind: "any" | "unknown" | "never" | "null" | "bool";
-}
-
-// Literal node
-export interface LiteralSchemaNode extends SchemaNodeBase {
-  kind: "literal";
-  value: string | number | boolean | null;
-}
-
-// Enum node
-export interface EnumSchemaNode extends SchemaNodeBase {
-  kind: "enum";
-  values: (string | number)[];
-}
-
-// Array node
-export interface ArraySchemaNode extends SchemaNodeBase {
-  kind: "array";
-  items: SchemaNode;
-  minItems?: number;
-  maxItems?: number;
-}
-
-// Tuple node
-export interface TupleSchemaNode extends SchemaNodeBase {
-  kind: "tuple";
-  items: SchemaNode[];
-}
-
-// Object node
-export interface ObjectSchemaNode extends SchemaNodeBase {
-  kind: "object";
-  properties: Record<string, SchemaNode>;
-  required: string[];
-  unknownKeys?: UnknownKeyMode;
-}
-
-// Record node
-export interface RecordSchemaNode extends SchemaNodeBase {
-  kind: "record";
-  valueSchema: SchemaNode;
-}
-
-// Union node
-export interface UnionSchemaNode extends SchemaNodeBase {
-  kind: "union";
-  variants: SchemaNode[];
-}
-
-// Intersection node
-export interface IntersectionSchemaNode extends SchemaNodeBase {
-  kind: "intersection";
-  allOf: SchemaNode[];
-}
-
-// Optional node
-export interface OptionalSchemaNode extends SchemaNodeBase {
-  kind: "optional";
-  inner: SchemaNode;
-}
-
-// Nullable node
-export interface NullableSchemaNode extends SchemaNodeBase {
-  kind: "nullable";
-  inner: SchemaNode;
-}
-
-// Ref node
-export interface RefSchemaNode extends SchemaNodeBase {
-  kind: "ref";
-  ref: string;
-}
-
-export type SchemaNode =
-  | StringSchemaNode
-  | NumericSchemaNode
-  | SimpleSchemaNode
-  | LiteralSchemaNode
-  | EnumSchemaNode
-  | ArraySchemaNode
-  | TupleSchemaNode
-  | ObjectSchemaNode
-  | RecordSchemaNode
-  | UnionSchemaNode
-  | IntersectionSchemaNode
-  | OptionalSchemaNode
-  | NullableSchemaNode
-  | RefSchemaNode;
-
-// ---- Parse Result ----
-
-export type ParseResult<T> =
-  | { success: true; data: T }
-  | { success: false; issues: ValidationIssue[] };
-
-export interface ValidationIssue {
-  code: string;
-  message: string;
-  path: (string | number)[];
-  expected?: string;
-  received?: string;
-  meta?: Record<string, unknown>;
-}
-
-// ---- Interchange Document ----
-
-export interface AnyValiDocument {
-  anyvaliVersion: string;
-  schemaVersion: string;
-  root: SchemaNode;
-  definitions: Record<string, SchemaNode>;
-  extensions: Record<string, Record<string, unknown>>;
-}
-
-// ---- Modes ----
-
-export type ExportMode = "portable" | "extended";
-
-export type UnknownKeyMode = "reject" | "strip" | "allow";
-
-// ---- Parse Context (internal) ----
-
-export interface ParseContext {
-  path: (string | number)[];
-  issues: ValidationIssue[];
-  definitions?: Record<string, SchemaNode>;
-  /** Tracks objects already being validated to detect circular references. */
-  seen?: WeakSet<object>;
-  /** Current recursion depth, used to bound unbounded recursion (DoS guard). */
-  depth?: number;
-}
+// ---- Schema Node (interchange JSON representation) ----
+
+export type SchemaKind =
+  | "any"
+  | "unknown"
+  | "never"
+  | "null"
+  | "bool"
+  | "string"
+  | "number"
+  | "int"
+  | "float32"
+  | "float64"
+  | "int8"
+  | "int16"
+  | "int32"
+  | "int64"
+  | "uint8"
+  | "uint16"
+  | "uint32"
+  | "uint64"
+  | "literal"
+  | "enum"
+  | "array"
+  | "tuple"
+  | "object"
+  | "record"
+  | "union"
+  | "intersection"
+  | "optional"
+  | "nullable"
+  | "ref";
+
+export interface MetadataOptions {
+  replace?: boolean;
+}
+
+export interface DescribeOptions {
+  title?: string;
+  deprecated?: boolean;
+  deprecatedMessage?: string;
+  notStable?: boolean;
+  since?: string;
+  sensitive?: boolean;
+  readonly?: boolean;
+  writeonly?: boolean;
+  examples?: unknown[];
+}
+
+export interface SchemaNodeBase {
+  kind: SchemaKind;
+  default?: unknown;
+  coerce?: CoercionConfig | string | string[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface CoercionConfig {
+  from?: string;
+  trim?: boolean;
+  lower?: boolean;
+  upper?: boolean;
+}
+
+// String node
+export interface StringSchemaNode extends SchemaNodeBase {
+  kind: "string";
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  startsWith?: string;
+  endsWith?: string;
+  includes?: string;
+  format?: StringFormat;
+}
+
+export type StringFormat =
+  | "email"
+  | "url"
+  | "uuid"
+  | "ipv4"
+  | "ipv6"
+  | "date"
+  | "date-time";
+
+// Numeric nodes
+export interface NumericSchemaNode extends SchemaNodeBase {
+  kind:
+    | "number"
+    | "int"
+    | "float32"
+    | "float64"
+    | "int8"
+    | "int16"
+    | "int32"
+    | "int64"
+    | "uint8"
+    | "uint16"
+    | "uint32"
+    | "uint64";
+  min?: number;
+  max?: number;
+  exclusiveMin?: number;
+  exclusiveMax?: number;
+  multipleOf?: number;
+}
+
+// Simple nodes
+export interface SimpleSchemaNode extends SchemaNodeBase {
+  kind: "any" | "unknown" | "never" | "null" | "bool";
+}
+
+// Literal node
+export interface LiteralSchemaNode extends SchemaNodeBase {
+  kind: "literal";
+  value: string | number | boolean | null;
+}
+
+// Enum node
+export interface EnumSchemaNode extends SchemaNodeBase {
+  kind: "enum";
+  values: (string | number)[];
+}
+
+// Array node
+export interface ArraySchemaNode extends SchemaNodeBase {
+  kind: "array";
+  items: SchemaNode;
+  minItems?: number;
+  maxItems?: number;
+}
+
+// Tuple node
+export interface TupleSchemaNode extends SchemaNodeBase {
+  kind: "tuple";
+  items: SchemaNode[];
+}
+
+// Object node
+export interface ObjectSchemaNode extends SchemaNodeBase {
+  kind: "object";
+  properties: Record<string, SchemaNode>;
+  required: string[];
+  unknownKeys?: UnknownKeyMode;
+}
+
+// Record node
+export interface RecordSchemaNode extends SchemaNodeBase {
+  kind: "record";
+  valueSchema: SchemaNode;
+}
+
+// Union node
+export interface UnionSchemaNode extends SchemaNodeBase {
+  kind: "union";
+  variants: SchemaNode[];
+}
+
+// Intersection node
+export interface IntersectionSchemaNode extends SchemaNodeBase {
+  kind: "intersection";
+  allOf: SchemaNode[];
+}
+
+// Optional node
+export interface OptionalSchemaNode extends SchemaNodeBase {
+  kind: "optional";
+  inner: SchemaNode;
+}
+
+// Nullable node
+export interface NullableSchemaNode extends SchemaNodeBase {
+  kind: "nullable";
+  inner: SchemaNode;
+}
+
+// Ref node
+export interface RefSchemaNode extends SchemaNodeBase {
+  kind: "ref";
+  ref: string;
+}
+
+export type SchemaNode =
+  | StringSchemaNode
+  | NumericSchemaNode
+  | SimpleSchemaNode
+  | LiteralSchemaNode
+  | EnumSchemaNode
+  | ArraySchemaNode
+  | TupleSchemaNode
+  | ObjectSchemaNode
+  | RecordSchemaNode
+  | UnionSchemaNode
+  | IntersectionSchemaNode
+  | OptionalSchemaNode
+  | NullableSchemaNode
+  | RefSchemaNode;
+
+// ---- Parse Result ----
+
+export type ParseResult<T> =
+  | { success: true; data: T }
+  | { success: false; issues: ValidationIssue[] };
+
+export interface ValidationIssue {
+  code: string;
+  message: string;
+  path: (string | number)[];
+  expected?: string;
+  received?: string;
+  meta?: Record<string, unknown>;
+}
+
+// ---- Interchange Document ----
+
+export interface AnyValiDocument {
+  anyvaliVersion: string;
+  schemaVersion: string;
+  root: SchemaNode;
+  definitions: Record<string, SchemaNode>;
+  extensions: Record<string, Record<string, unknown>>;
+}
+
+// ---- Modes ----
+
+export type ExportMode = "portable" | "extended";
+
+export type UnknownKeyMode = "reject" | "strip" | "allow";
+
+// ---- Parse Context (internal) ----
+
+export interface ParseContext {
+  path: (string | number)[];
+  issues: ValidationIssue[];
+  definitions?: Record<string, SchemaNode>;
+  /** Tracks objects already being validated to detect circular references. */
+  seen?: WeakSet<object>;
+  /** Current recursion depth, used to bound unbounded recursion (DoS guard). */
+  depth?: number;
+}

package/tests/unit/collections.test.ts

@@ -1,99 +1,99 @@
-import { describe, it, expect } from "vitest";
-import { array, tuple, record, string, int, bool, any } from "../../src/index.js";
-
-describe("ArraySchema", () => {
-  it("accepts valid arrays", () => {
-    const s = array(int());
-    expect(s.parse([1, 2, 3])).toEqual([1, 2, 3]);
-  });
-
-  it("rejects non-arrays", () => {
-    const s = array(int());
-    expect(s.safeParse("not an array").success).toBe(false);
-  });
-
-  it("validates array items", () => {
-    const s = array(int());
-    const result = s.safeParse([1, "two", 3]);
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.issues[0].path).toEqual([1]);
-    }
-  });
-
-  it("validates minItems", () => {
-    const s = array(int()).minItems(2);
-    expect(s.parse([1, 2])).toEqual([1, 2]);
-    expect(s.safeParse([1]).success).toBe(false);
-  });
-
-  it("validates maxItems", () => {
-    const s = array(int()).maxItems(2);
-    expect(s.parse([1, 2])).toEqual([1, 2]);
-    expect(s.safeParse([1, 2, 3]).success).toBe(false);
-  });
-});
-
-describe("TupleSchema", () => {
-  it("accepts valid tuples", () => {
-    const s = tuple([string(), int(), bool()]);
-    expect(s.parse(["hello", 42, true])).toEqual(["hello", 42, true]);
-  });
-
-  it("rejects wrong length", () => {
-    const s = tuple([string(), int()]);
-    expect(s.safeParse(["hello"]).success).toBe(false);
-    expect(s.safeParse(["hello", 42, true]).success).toBe(false);
-  });
-
-  it("validates element types", () => {
-    const s = tuple([string(), int()]);
-    const result = s.safeParse([42, "hello"]);
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.issues[0].path).toEqual([0]);
-    }
-  });
-});
-
-describe("RecordSchema", () => {
-  it("accepts valid records", () => {
-    const s = record(int());
-    expect(s.parse({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
-  });
-
-  it("rejects non-objects", () => {
-    const s = record(int());
-    expect(s.safeParse("not object").success).toBe(false);
-    expect(s.safeParse(null).success).toBe(false);
-    expect(s.safeParse([]).success).toBe(false);
-  });
-
-  it("validates record values", () => {
-    const s = record(int());
-    const result = s.safeParse({ a: 1, b: "two" });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.issues[0].path).toEqual(["b"]);
-    }
-  });
-
-  it("preserves __proto__ as data in records", () => {
-    const s = record(any());
-    const input = JSON.parse(
-      '{"safe":1,"__proto__":{"polluted":"yes"}}'
-    ) as Record<
-      string,
-      unknown
-    >;
-
-    const result = s.parse(input);
-
-    expect(result.safe).toBe(1);
-    expect(Object.getPrototypeOf(result)).toBe(Object.prototype);
-    expect(Object.prototype.hasOwnProperty.call(result, "__proto__")).toBe(true);
-    expect(
-      Object.getOwnPropertyDescriptor(result, "__proto__")?.value
-    ).toEqual({ polluted: "yes" });
-  });
-});
+import { describe, it, expect } from "vitest";
+import { array, tuple, record, string, int, bool, any } from "../../src/index.js";
+
+describe("ArraySchema", () => {
+  it("accepts valid arrays", () => {
+    const s = array(int());
+    expect(s.parse([1, 2, 3])).toEqual([1, 2, 3]);
+  });
+
+  it("rejects non-arrays", () => {
+    const s = array(int());
+    expect(s.safeParse("not an array").success).toBe(false);
+  });
+
+  it("validates array items", () => {
+    const s = array(int());
+    const result = s.safeParse([1, "two", 3]);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].path).toEqual([1]);
+    }
+  });
+
+  it("validates minItems", () => {
+    const s = array(int()).minItems(2);
+    expect(s.parse([1, 2])).toEqual([1, 2]);
+    expect(s.safeParse([1]).success).toBe(false);
+  });
+
+  it("validates maxItems", () => {
+    const s = array(int()).maxItems(2);
+    expect(s.parse([1, 2])).toEqual([1, 2]);
+    expect(s.safeParse([1, 2, 3]).success).toBe(false);
+  });
+});
+
+describe("TupleSchema", () => {
+  it("accepts valid tuples", () => {
+    const s = tuple([string(), int(), bool()]);
+    expect(s.parse(["hello", 42, true])).toEqual(["hello", 42, true]);
+  });
+
+  it("rejects wrong length", () => {
+    const s = tuple([string(), int()]);
+    expect(s.safeParse(["hello"]).success).toBe(false);
+    expect(s.safeParse(["hello", 42, true]).success).toBe(false);
+  });
+
+  it("validates element types", () => {
+    const s = tuple([string(), int()]);
+    const result = s.safeParse([42, "hello"]);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].path).toEqual([0]);
+    }
+  });
+});
+
+describe("RecordSchema", () => {
+  it("accepts valid records", () => {
+    const s = record(int());
+    expect(s.parse({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
+  });
+
+  it("rejects non-objects", () => {
+    const s = record(int());
+    expect(s.safeParse("not object").success).toBe(false);
+    expect(s.safeParse(null).success).toBe(false);
+    expect(s.safeParse([]).success).toBe(false);
+  });
+
+  it("validates record values", () => {
+    const s = record(int());
+    const result = s.safeParse({ a: 1, b: "two" });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].path).toEqual(["b"]);
+    }
+  });
+
+  it("preserves __proto__ as data in records", () => {
+    const s = record(any());
+    const input = JSON.parse(
+      '{"safe":1,"__proto__":{"polluted":"yes"}}'
+    ) as Record<
+      string,
+      unknown
+    >;
+
+    const result = s.parse(input);
+
+    expect(result.safe).toBe(1);
+    expect(Object.getPrototypeOf(result)).toBe(Object.prototype);
+    expect(Object.prototype.hasOwnProperty.call(result, "__proto__")).toBe(true);
+    expect(
+      Object.getOwnPropertyDescriptor(result, "__proto__")?.value
+    ).toEqual({ polluted: "yes" });
+  });
+});