anyvali 0.3.1

package/src/schemas/int.ts

@@ -0,0 +1,129 @@
+import type { ParseContext, SchemaNode, SchemaKind } from "../types.js";
+import { NumberSchema } from "./number.js";
+import { ISSUE_CODES } from "../issue-codes.js";
+import { describeType } from "../util.js";
+
+interface IntRange {
+  min: number;
+  max: number;
+}
+
+const INT_RANGES: Record<string, IntRange> = {
+  int8: { min: -128, max: 127 },
+  int16: { min: -32768, max: 32767 },
+  int32: { min: -2147483648, max: 2147483647 },
+  int64: { min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+  uint8: { min: 0, max: 255 },
+  uint16: { min: 0, max: 65535 },
+  uint32: { min: 0, max: 4294967295 },
+  uint64: { min: 0, max: Number.MAX_SAFE_INTEGER },
+  int: { min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+};
+
+export class IntSchema extends NumberSchema {
+  private _intRange: IntRange;
+
+  constructor(kind: SchemaKind = "int") {
+    super(kind);
+    this._intRange = INT_RANGES[kind] ?? INT_RANGES.int;
+  }
+
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    if (typeof input !== "number" || !Number.isFinite(input)) {
+      ctx.issues.push({
+        code: ISSUE_CODES.INVALID_TYPE,
+        message: `Expected integer, received ${describeType(input)}`,
+        path: [...ctx.path],
+        expected: this._kind,
+        received: describeType(input),
+      });
+      return undefined;
+    }
+
+    if (!Number.isInteger(input)) {
+      ctx.issues.push({
+        code: ISSUE_CODES.INVALID_TYPE,
+        message: `Expected integer, received float`,
+        path: [...ctx.path],
+        expected: this._kind,
+        received: "number",
+      });
+      return undefined;
+    }
+
+    // Range check for the specific int width
+    if (input > this._intRange.max) {
+      ctx.issues.push({
+        code: ISSUE_CODES.TOO_LARGE,
+        message: `Value ${input} is above the maximum for ${this._kind}`,
+        path: [...ctx.path],
+        expected: this._kind,
+        received: String(input),
+      });
+      return undefined;
+    }
+
+    if (input < this._intRange.min) {
+      ctx.issues.push({
+        code: ISSUE_CODES.TOO_SMALL,
+        message: `Value ${input} is below the minimum for ${this._kind}`,
+        path: [...ctx.path],
+        expected: this._kind,
+        received: String(input),
+      });
+      return undefined;
+    }
+
+    // Additional user constraints
+    this._validateConstraints(input, ctx);
+    return input;
+  }
+}
+
+export class Int8Schema extends IntSchema {
+  constructor() {
+    super("int8");
+  }
+}
+
+export class Int16Schema extends IntSchema {
+  constructor() {
+    super("int16");
+  }
+}
+
+export class Int32Schema extends IntSchema {
+  constructor() {
+    super("int32");
+  }
+}
+
+export class Int64Schema extends IntSchema {
+  constructor() {
+    super("int64");
+  }
+}
+
+export class Uint8Schema extends IntSchema {
+  constructor() {
+    super("uint8");
+  }
+}
+
+export class Uint16Schema extends IntSchema {
+  constructor() {
+    super("uint16");
+  }
+}
+
+export class Uint32Schema extends IntSchema {
+  constructor() {
+    super("uint32");
+  }
+}
+
+export class Uint64Schema extends IntSchema {
+  constructor() {
+    super("uint64");
+  }
+}

package/src/schemas/intersection.ts

@@ -0,0 +1,81 @@
+import type { ParseContext, SchemaNode } from "../types.js";
+import { BaseSchema } from "./base.js";
+
+/** Convert a union of types to an intersection. */
+type UnionToIntersection<U> = (
+  U extends any ? (x: U) => void : never
+) extends (x: infer I) => void
+  ? I
+  : never;
+
+/** Flatten an intersection into a clean single-level type. */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+
+export class IntersectionSchema<
+  T extends BaseSchema<any, any>[] = BaseSchema[],
+> extends BaseSchema<
+  unknown,
+  Prettify<UnionToIntersection<T[number]["_output"]>>
+> {
+  private _schemas: T;
+
+  constructor(schemas: [...T]) {
+    super();
+    this._schemas = schemas as T;
+  }
+
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    let result: unknown = input;
+    let anyFailed = false;
+
+    for (const schema of this._schemas) {
+      const innerCtx: ParseContext = {
+        path: [...ctx.path],
+        issues: [],
+        // Propagate recursion depth and circular-reference tracking so the
+        // depth guard is not reset (and bypassed) at each intersection member.
+        definitions: ctx.definitions,
+        seen: ctx.seen,
+        depth: ctx.depth,
+      };
+      const validated = schema._runPipeline(input, innerCtx);
+
+      if (innerCtx.issues.length > 0) {
+        ctx.issues.push(...innerCtx.issues);
+        anyFailed = true;
+      } else {
+        // Merge object results
+        if (
+          typeof result === "object" &&
+          result !== null &&
+          typeof validated === "object" &&
+          validated !== null &&
+          !Array.isArray(result) &&
+          !Array.isArray(validated)
+        ) {
+          result = {
+            ...(result as Record<string, unknown>),
+            ...(validated as Record<string, unknown>),
+          };
+        } else {
+          result = validated;
+        }
+      }
+    }
+
+    if (anyFailed) {
+      return undefined;
+    }
+
+    return result;
+  }
+
+  _toNode(): SchemaNode {
+    const node = {
+      kind: "intersection" as const,
+      allOf: this._schemas.map((s) => s._toNode()),
+    };
+    this._addDefault(node as unknown as SchemaNode);
+    return node as unknown as SchemaNode;
+  }
+}

package/src/schemas/literal.ts

@@ -0,0 +1,34 @@
+import type { ParseContext, SchemaNode } from "../types.js";
+import { BaseSchema } from "./base.js";
+import { ISSUE_CODES } from "../issue-codes.js";
+
+type LiteralValue = string | number | boolean | null;
+
+export class LiteralSchema<T extends LiteralValue> extends BaseSchema<T, T> {
+  private _value: T;
+
+  constructor(value: T) {
+    super();
+    this._value = value;
+  }
+
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    if (input !== this._value) {
+      ctx.issues.push({
+        code: ISSUE_CODES.INVALID_LITERAL,
+        message: `Expected literal ${String(this._value)}, received ${String(input)}`,
+        path: [...ctx.path],
+        expected: String(this._value),
+        received: String(input),
+      });
+      return undefined;
+    }
+    return input;
+  }
+
+  _toNode(): SchemaNode {
+    const node = { kind: "literal" as const, value: this._value };
+    this._addDefault(node as unknown as SchemaNode);
+    return node as unknown as SchemaNode;
+  }
+}

package/src/schemas/never.ts

@@ -0,0 +1,21 @@
+import type { ParseContext, SchemaNode } from "../types.js";
+import { BaseSchema } from "./base.js";
+import { ISSUE_CODES } from "../issue-codes.js";
+import { describeType } from "../util.js";
+
+export class NeverSchema extends BaseSchema<never, never> {
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    ctx.issues.push({
+      code: ISSUE_CODES.INVALID_TYPE,
+      message: `Expected never (no value is valid)`,
+      path: [...ctx.path],
+      expected: "never",
+      received: describeType(input),
+    });
+    return undefined;
+  }
+
+  _toNode(): SchemaNode {
+    return { kind: "never" } as SchemaNode;
+  }
+}

package/src/schemas/null.ts

@@ -0,0 +1,26 @@
+import type { ParseContext, SchemaNode } from "../types.js";
+import { BaseSchema } from "./base.js";
+import { ISSUE_CODES } from "../issue-codes.js";
+import { describeType } from "../util.js";
+
+export class NullSchema extends BaseSchema<null, null> {
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    if (input !== null) {
+      ctx.issues.push({
+        code: ISSUE_CODES.INVALID_TYPE,
+        message: `Expected null, received ${describeType(input)}`,
+        path: [...ctx.path],
+        expected: "null",
+        received: describeType(input),
+      });
+      return undefined;
+    }
+    return null;
+  }
+
+  _toNode(): SchemaNode {
+    const node: SchemaNode = { kind: "null" } as SchemaNode;
+    this._addDefault(node);
+    return node;
+  }
+}

package/src/schemas/nullable.ts

@@ -0,0 +1,36 @@
+import type { ParseContext, SchemaNode } from "../types.js";
+import { BaseSchema } from "./base.js";
+
+export class NullableSchema<
+  T extends BaseSchema<any, any> = BaseSchema,
+> extends BaseSchema<unknown, T["_output"] | null> {
+  /** @internal */ _inner: T;
+
+  constructor(inner: T) {
+    super();
+    this._inner = inner;
+  }
+
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    if (input === null) {
+      return null;
+    }
+    return this._inner._validate(input, ctx);
+  }
+
+  _runPipeline(input: unknown, ctx: ParseContext): unknown {
+    if (input === null) {
+      return null;
+    }
+    return this._inner._runPipeline(input, ctx);
+  }
+
+  _toNode(): SchemaNode {
+    const node = {
+      kind: "nullable" as const,
+      inner: this._inner._toNode(),
+    };
+    this._addDefault(node as unknown as SchemaNode);
+    return node as unknown as SchemaNode;
+  }
+}

package/src/schemas/number.ts

@@ -0,0 +1,151 @@
+import type { ParseContext, SchemaNode, SchemaKind } from "../types.js";
+import { BaseSchema } from "./base.js";
+import { ISSUE_CODES } from "../issue-codes.js";
+import { describeType } from "../util.js";
+
+export class NumberSchema extends BaseSchema<number, number> {
+  protected _kind: SchemaKind;
+  protected _min?: number;
+  protected _max?: number;
+  protected _exclusiveMin?: number;
+  protected _exclusiveMax?: number;
+  protected _multipleOf?: number;
+
+  constructor(kind: SchemaKind = "number") {
+    super();
+    this._kind = kind;
+  }
+
+  _getCoercionTarget(): string {
+    return this._kind;
+  }
+
+  min(n: number): this {
+    const clone = this._clone();
+    clone._min = n;
+    return clone;
+  }
+
+  max(n: number): this {
+    const clone = this._clone();
+    clone._max = n;
+    return clone;
+  }
+
+  exclusiveMin(n: number): this {
+    const clone = this._clone();
+    clone._exclusiveMin = n;
+    return clone;
+  }
+
+  exclusiveMax(n: number): this {
+    const clone = this._clone();
+    clone._exclusiveMax = n;
+    return clone;
+  }
+
+  multipleOf(n: number): this {
+    const clone = this._clone();
+    clone._multipleOf = n;
+    return clone;
+  }
+
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    if (typeof input !== "number" || !Number.isFinite(input)) {
+      ctx.issues.push({
+        code: ISSUE_CODES.INVALID_TYPE,
+        message: `Expected ${this._kind}, received ${describeType(input)}`,
+        path: [...ctx.path],
+        expected: this._kind,
+        received: describeType(input),
+      });
+      return undefined;
+    }
+
+    this._validateConstraints(input, ctx);
+    return input;
+  }
+
+  protected _validateConstraints(val: number, ctx: ParseContext): void {
+    if (this._min !== undefined && val < this._min) {
+      ctx.issues.push({
+        code: ISSUE_CODES.TOO_SMALL,
+        message: `Number must be >= ${this._min}`,
+        path: [...ctx.path],
+        expected: String(this._min),
+        received: String(val),
+      });
+    }
+
+    if (this._max !== undefined && val > this._max) {
+      ctx.issues.push({
+        code: ISSUE_CODES.TOO_LARGE,
+        message: `Number must be <= ${this._max}`,
+        path: [...ctx.path],
+        expected: String(this._max),
+        received: String(val),
+      });
+    }
+
+    if (this._exclusiveMin !== undefined && val <= this._exclusiveMin) {
+      ctx.issues.push({
+        code: ISSUE_CODES.TOO_SMALL,
+        message: `Number must be > ${this._exclusiveMin}`,
+        path: [...ctx.path],
+        expected: String(this._exclusiveMin),
+        received: String(val),
+      });
+    }
+
+    if (this._exclusiveMax !== undefined && val >= this._exclusiveMax) {
+      ctx.issues.push({
+        code: ISSUE_CODES.TOO_LARGE,
+        message: `Number must be < ${this._exclusiveMax}`,
+        path: [...ctx.path],
+        expected: String(this._exclusiveMax),
+        received: String(val),
+      });
+    }
+
+    if (this._multipleOf !== undefined) {
+      const remainder = val % this._multipleOf;
+      if (
+        Math.abs(remainder) > 1e-10 &&
+        Math.abs(remainder - this._multipleOf) > 1e-10
+      ) {
+        ctx.issues.push({
+          code: ISSUE_CODES.INVALID_NUMBER,
+          message: `Number must be a multiple of ${this._multipleOf}`,
+          path: [...ctx.path],
+          expected: String(this._multipleOf),
+          received: String(val),
+        });
+      }
+    }
+  }
+
+  _toNode(): SchemaNode {
+    const node: Record<string, unknown> = { kind: this._kind };
+    if (this._min !== undefined) node.min = this._min;
+    if (this._max !== undefined) node.max = this._max;
+    if (this._exclusiveMin !== undefined)
+      node.exclusiveMin = this._exclusiveMin;
+    if (this._exclusiveMax !== undefined)
+      node.exclusiveMax = this._exclusiveMax;
+    if (this._multipleOf !== undefined) node.multipleOf = this._multipleOf;
+    this._addDefault(node as unknown as SchemaNode);
+    return node as unknown as SchemaNode;
+  }
+}
+
+export class Float32Schema extends NumberSchema {
+  constructor() {
+    super("float32");
+  }
+}
+
+export class Float64Schema extends NumberSchema {
+  constructor() {
+    super("float64");
+  }
+}

package/src/schemas/object.ts

@@ -0,0 +1,203 @@
+import type { ParseContext, SchemaNode, UnknownKeyMode } from "../types.js";
+import { BaseSchema, ABSENT } from "./base.js";
+import { ISSUE_CODES } from "../issue-codes.js";
+import { describeType } from "../util.js";
+import type { OptionalSchema } from "./optional.js";
+
+/** Flatten an intersection into a clean single-level type. */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+
+/** Map a shape record to its inferred output type, separating required from optional fields. */
+export type InferShape<
+  T extends Record<string, BaseSchema<any, any>>,
+> = Prettify<
+  {
+    [K in keyof T as T[K] extends OptionalSchema<any> ? never : K]: T[K]["_output"];
+  } & {
+    [K in keyof T as T[K] extends OptionalSchema<any>
+      ? K
+      : never]?: T[K]["_output"];
+  }
+>;
+
+interface PropertyDef {
+  schema: BaseSchema;
+  required: boolean;
+}
+
+export class ObjectSchema<
+  TShape extends Record<string, BaseSchema<any, any>> = Record<
+    string,
+    BaseSchema
+  >,
+> extends BaseSchema<Record<string, unknown>, InferShape<TShape>> {
+  private _properties: Map<string, PropertyDef>;
+  private _unknownKeys: UnknownKeyMode;
+  private _unknownKeysExplicit: boolean;
+
+  constructor(
+    shape: TShape,
+    options?: { unknownKeys?: UnknownKeyMode },
+  ) {
+    super();
+    this._properties = new Map();
+    this._unknownKeys = options?.unknownKeys ?? "strip";
+    this._unknownKeysExplicit = options?.unknownKeys !== undefined;
+
+    for (const [key, schema] of Object.entries(shape)) {
+      // Check if the schema is an OptionalSchema wrapper
+      const isOptional = (schema as any)._isOptionalWrapper === true;
+      this._properties.set(key, {
+        schema,
+        required: !isOptional,
+      });
+    }
+  }
+
+  unknownKeys(mode: UnknownKeyMode): ObjectSchema<TShape> {
+    const clone = this._clone();
+    clone._unknownKeys = mode;
+    clone._unknownKeysExplicit = true;
+    return clone;
+  }
+
+  private _effectiveUnknownKeys(): UnknownKeyMode {
+    return this._unknownKeysExplicit ? this._unknownKeys : "strip";
+  }
+
+  private _exportUnknownKeys(): UnknownKeyMode {
+    return this._unknownKeysExplicit ? this._unknownKeys : "strip";
+  }
+
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      ctx.issues.push({
+        code: ISSUE_CODES.INVALID_TYPE,
+        message: `Expected object, received ${describeType(input)}`,
+        path: [...ctx.path],
+        expected: "object",
+        received: describeType(input),
+      });
+      return undefined;
+    }
+
+    // Circular reference detection
+    if (!ctx.seen) ctx.seen = new WeakSet();
+    if (ctx.seen.has(input as object)) {
+      ctx.issues.push({
+        code: ISSUE_CODES.INVALID_TYPE,
+        message: "Circular reference detected",
+        path: [...ctx.path],
+        expected: "object",
+        received: "circular",
+      });
+      return undefined;
+    }
+    ctx.seen.add(input as object);
+
+    const obj = input as Record<string, unknown>;
+    const result: Record<string, unknown> = Object.create(null);
+    const inputKeys = new Set(Object.keys(obj));
+
+    // Detect __proto__ via hasOwnProperty (Object.keys skips it)
+    if (Object.prototype.hasOwnProperty.call(obj, "__proto__")) {
+      inputKeys.add("__proto__");
+    }
+
+    // Validate declared properties
+    for (const [key, prop] of this._properties) {
+      ctx.path.push(key);
+      const hasKey = Object.prototype.hasOwnProperty.call(obj, key);
+      inputKeys.delete(key);
+
+      if (!hasKey) {
+        // Check if required
+        if (prop.required && prop.schema._defaultValue === ABSENT) {
+          const expectedKind = prop.schema._toNode().kind;
+          ctx.issues.push({
+            code: ISSUE_CODES.REQUIRED,
+            message: `Required property "${key}" is missing`,
+            path: [...ctx.path],
+            expected: expectedKind,
+            received: "undefined",
+          });
+          ctx.path.pop();
+          continue;
+        }
+      }
+
+      const rawValue = hasKey ? obj[key] : undefined;
+      const val = prop.schema._runPipeline(rawValue, ctx);
+
+      // Only include in result if value is not undefined or it was explicitly present
+      if (val !== undefined || hasKey || prop.schema._defaultValue !== ABSENT) {
+        Object.defineProperty(result, key, {
+          value: val,
+          writable: true,
+          enumerable: true,
+          configurable: true,
+        });
+      }
+
+      ctx.path.pop();
+    }
+
+    // Handle unknown keys
+    for (const key of inputKeys) {
+      switch (this._effectiveUnknownKeys()) {
+        case "reject":
+          ctx.issues.push({
+            code: ISSUE_CODES.UNKNOWN_KEY,
+            message: `Unknown key "${key}"`,
+            path: [...ctx.path, key],
+            expected: "undefined",
+            received: key,
+          });
+          break;
+        case "allow":
+          Object.defineProperty(result, key, {
+            value: obj[key],
+            writable: true,
+            enumerable: true,
+            configurable: true,
+          });
+          break;
+        case "strip":
+          // Just ignore it
+          break;
+      }
+    }
+
+    // Remove from the ancestor set now that this subtree is fully processed.
+    // The guard tracks the current ancestor chain (true cycles), not every
+    // object ever seen — otherwise a shared/repeated non-circular reference in
+    // sibling positions would be falsely rejected as circular.
+    ctx.seen.delete(input as object);
+
+    // Restore normal prototype so result behaves like a standard object
+    // while preventing __proto__ pollution via Object.create(null) above
+    Object.setPrototypeOf(result, Object.prototype);
+    return result;
+  }
+
+  _toNode(): SchemaNode {
+    const properties: Record<string, SchemaNode> = {};
+    const required: string[] = [];
+
+    for (const [key, prop] of this._properties) {
+      properties[key] = prop.schema._toNode();
+      if (prop.required) {
+        required.push(key);
+      }
+    }
+
+    const node = {
+      kind: "object" as const,
+      properties,
+      required,
+      unknownKeys: this._exportUnknownKeys(),
+    };
+    this._addDefault(node as unknown as SchemaNode);
+    return node as unknown as SchemaNode;
+  }
+}