Object and Record Arbitraries

/**
 * Generate objects following a schema with optional/required keys
 * @param model - Schema mapping keys to arbitraries
 * @param constraints - Which keys are required
 * @returns Arbitrary generating record objects
 */
function record<T, K extends keyof T = keyof T>(
  model: { [K in keyof T]: Arbitrary<T[K]> },
  constraints?: RecordConstraints<K>
): Arbitrary<RecordValue<T, K>>;

interface RecordConstraints<K> {
  requiredKeys?: K[];
}

type RecordValue<T, K extends keyof T> = { [P in K]: T[P] } & Partial<T>;

import { record, string, integer, boolean, property, assert } from 'fast-check';

// User record with required and optional fields
const userArb = record(
  {
    id: string(),
    name: string(),
    age: integer({ min: 0, max: 120 }),
    email: string(),
    active: boolean(),
  },
  { requiredKeys: ['id', 'name'] }
);

assert(
  property(userArb, (user) => {
    return 'id' in user && 'name' in user;
  })
);

/**
 * Generate arbitrary nested objects with configurable depth and keys
 * @param constraints - Depth, key type, and size constraints
 * @returns Arbitrary generating arbitrary objects
 */
function object(constraints?: ObjectConstraints): Arbitrary<Record<string, unknown>>;

interface ObjectConstraints {
  key?: Arbitrary<string>;
  maxDepth?: number;
  maxKeys?: number;
  size?: SizeForArbitrary;
  depthIdentifier?: DepthIdentifier | string;
  values?: Arbitrary<unknown>[];
  withBigInt?: boolean;
  withBoxedValues?: boolean;
  withDate?: boolean;
  withMap?: boolean;
  withNullPrototype?: boolean;
  withObjectString?: boolean;
  withSet?: boolean;
  withTypedArray?: boolean;
}

import { object, property, assert } from 'fast-check';

// Generate arbitrary objects
assert(
  property(object({ maxDepth: 2, maxKeys: 5 }), (obj) => {
    return typeof obj === 'object' && obj !== null;
  })
);

/**
 * Generate dictionary objects (string keys to arbitrary values)
 * @param keyArb - Arbitrary for dictionary keys
 * @param valueArb - Arbitrary for dictionary values
 * @param constraints - Size and length constraints
 * @returns Arbitrary generating dictionary objects
 */
function dictionary<T>(
  keyArb: Arbitrary<string>,
  valueArb: Arbitrary<T>,
  constraints?: DictionaryConstraints
): Arbitrary<Record<string, T>>;

interface DictionaryConstraints {
  minKeys?: number;
  maxKeys?: number;
  size?: SizeForArbitrary;
}

import { dictionary, string, integer, property, assert } from 'fast-check';

// String to number mapping
assert(
  property(dictionary(string(), integer(), { maxKeys: 10 }), (dict) => {
    return Object.keys(dict).length <= 10;
  })
);

/**
 * Generate any JavaScript value (primitives, objects, arrays, etc)
 * @param constraints - Same as object constraints
 * @returns Arbitrary generating any value
 */
function anything(constraints?: ObjectConstraints): Arbitrary<unknown>;

import { anything, property, assert } from 'fast-check';

// Test JSON.stringify doesn't crash
assert(
  property(anything(), (value) => {
    try {
      JSON.stringify(value);
      return true;
    } catch {
      return true; // Some values like circular refs can't be stringified
    }
  })
);

/**
 * Generate valid JSON strings
 * @param constraints - Depth and size constraints
 * @returns Arbitrary generating JSON strings
 */
function json(constraints?: JsonSharedConstraints): Arbitrary<string>;

/**
 * Generate JSON-compatible values (objects, arrays, primitives)
 * @param constraints - Depth and size constraints
 * @returns Arbitrary generating JSON values
 */
function jsonValue(constraints?: JsonSharedConstraints): Arbitrary<JsonValue>;

interface JsonSharedConstraints {
  maxDepth?: number;
  depthIdentifier?: DepthIdentifier | string;
}

type JsonValue =
  | null
  | boolean
  | number
  | string
  | JsonValue[]
  | { [key: string]: JsonValue };

import { json, jsonValue, property, assert } from 'fast-check';

// JSON strings are parseable
assert(
  property(json(), (jsonStr) => {
    const parsed = JSON.parse(jsonStr);
    return JSON.stringify(parsed) !== undefined;
  })
);

// JSON values can be stringified
assert(
  property(jsonValue({ maxDepth: 3 }), (value) => {
    const stringified = JSON.stringify(value);
    return JSON.parse(stringified) !== undefined;
  })
);

type SizeForArbitrary =
  | 'xsmall'
  | 'small'
  | 'medium'
  | 'large'
  | 'xlarge'
  | '='
  | number
  | { min?: number; max?: number };

type DepthIdentifier = { readonly name: string };