@fougere/schema 0.2.0-alpha.2 → 0.4.0-alpha.0

package/src/constraint/FieldGroup.ts

@@ -0,0 +1,91 @@
+import type { Field, Fields } from "../fields/Field.js";
+
+export abstract class FieldGroup {
+  constructor(readonly members: readonly string[]) {}
+
+  protected withMembers(members: readonly string[]): this {
+    return new (this.constructor as new (members: readonly string[]) => this)(
+      members,
+    );
+  }
+
+  get isSelf(): boolean {
+    return this.members.length === 0;
+  }
+
+  resolvedOn(ownKey: string): this {
+    return this.isSelf ? this.withMembers([ownKey]) : this;
+  }
+
+  covers(key: string): boolean {
+    return this.members.includes(key);
+  }
+
+  equals(other: FieldGroup): boolean {
+    return (
+      this.constructor === other.constructor &&
+      this.members.length === other.members.length &&
+      this.members.every((member, i) => member === other.members[i])
+    );
+  }
+
+  onto(fields: Fields): Fields {
+    const missing = this.members.filter((key) => !(key in fields));
+    if (missing.length)
+      throw new Error(
+        `${this.constructor.name.toLowerCase()}: [${this.members.join(", ")}] names ` +
+          `${missing.map((m) => `'${m}'`).join(", ")}, which the entity does not declare.`,
+      );
+
+    const out: Fields = { ...fields };
+    for (const key of this.members) {
+      const field = out[key]!;
+      out[key] = field.with({
+        role: { ...field.role, rules: [...(field.role?.rules ?? []), this] },
+      });
+    }
+    return out;
+  }
+
+  rename(map: (key: string) => string | undefined): this | null {
+    if (this.isSelf) return this;
+    const carried = this.members.map(map);
+    return carried.every((key): key is string => key !== undefined)
+      ? this.withMembers(carried)
+      : null;
+  }
+
+  toJSON(): string[] {
+    return [...this.members];
+  }
+
+  static normalize<R extends FieldGroup>(
+    groups: readonly (R | readonly string[])[] | undefined,
+    make: (members: readonly string[]) => R,
+  ): readonly R[] | undefined {
+    if (!groups) return undefined;
+    return groups.map((group) =>
+      group instanceof FieldGroup ? (group as R) : make(group),
+    );
+  }
+
+  static on<R extends FieldGroup>(
+    field: Field,
+    kind: Function & { prototype: R },
+  ): R[] {
+    return (field.role?.rules ?? []).filter(
+      (rule): rule is R => rule instanceof kind,
+    );
+  }
+
+  static groupsOf<R extends FieldGroup>(
+    fields: Fields,
+    kind: Function & { prototype: R },
+  ): R[] {
+    const seen = new Map<string, R>();
+    for (const field of Object.values(fields))
+      for (const rule of FieldGroup.on(field, kind))
+        if (rule.members.length > 1) seen.set(rule.members.join(" "), rule);
+    return [...seen.values()];
+  }
+}

package/src/constraint/Unique.ts

@@ -0,0 +1,3 @@
+import { FieldGroup } from './FieldGroup.js';
+
+export class Unique extends FieldGroup {}

package/src/entity.ts

@@ -0,0 +1,15 @@
+import { type Fields } from './fields/Field.js';
+import { FieldSet } from './fields/FieldSet.js';
+import { type EntityDeclarations } from './EntityDeclarations.js';
+import { Schema, type SchemaConstructor } from './schema/Schema.js';
+
+export function entity<TFields extends Fields>(
+  originalFields: TFields,
+  { unique, adapters, previous }: EntityDeclarations<TFields> = {},
+): SchemaConstructor<TFields> {
+  return Schema.of({
+    fields: FieldSet.declared(originalFields, unique),
+    adapters,
+    previous,
+  });
+}

package/src/fields/Field.ts

@@ -0,0 +1,80 @@
+import type { Shape } from "../axis/shape/Shape.js";
+import { Role, type RoleRules } from "../axis/role/Role.js";
+import type { LifecycleRules } from "../axis/lifecycle/Lifecycle.js";
+import type { BoundaryRef } from "../axis/boundary/Boundary.js";
+import type { Meta } from "../axis/Meta.js";
+import type { Axis } from "../axis/Axis.js";
+import { FieldJudge } from "../judge/FieldJudge.js";
+import { ValueJudge } from "../judge/ValueJudge.js";
+
+export type Fields = Record<string, Field>;
+
+/** A key of a field set — the name a declaration addresses a field by. */
+export type FieldName<TFields extends Fields> = Extract<keyof TFields, string>;
+
+/** The carrier, the three extension axes, the annotation — the five the judge reads. */
+export type FieldDeclaration = Pick<Field, "shape" | Axis["slot"] | "meta">;
+
+export class Field<T = unknown> {
+  readonly shape: Shape;
+  readonly role?: RoleRules;
+  readonly lifecycle?: LifecycleRules;
+  readonly boundary?: BoundaryRef;
+  readonly meta?: Meta;
+
+  declare readonly _type?: T;
+
+  constructor(init: FieldDeclaration, key?: string) {
+    const verdict = FieldJudge.of(init).verdict;
+
+    if (!verdict.success) {
+      throw new Error(
+        `${key ? `Field '${key}': ` : ""}` +
+          verdict.errors.map((e) => `${e.path}: ${e.message}`).join("; "),
+      );
+    }
+
+    this.shape = init.shape;
+    this.role = Role.resolvedOn(init.role, key);
+    this.lifecycle = init.lifecycle;
+    this.boundary = init.boundary;
+    this.meta = init.meta;
+
+    const create = this.lifecycle?.create;
+    if (typeof create === "object" && create !== null && "value" in create) {
+      const checked = ValueJudge.of(this).check(create.value);
+      if ("error" in checked)
+        throw new Error(
+          `${key ? `Field '${key}': ` : ""}the declared default ${JSON.stringify(create.value)} ` +
+            `is not a legal value for it — ${checked.error}.`,
+        );
+    }
+  }
+
+  static is(value: unknown): value is Field {
+    return FieldJudge.of(value).verdict.success;
+  }
+
+  with<U = T>(overrides: Partial<FieldDeclaration>): Field<U> {
+    return new Field<U>({ ...this, ...overrides });
+  }
+
+  rename(map: (key: string) => string | undefined): Field<T> {
+    const rules = this.role?.rules;
+    if (!rules?.length) return this;
+
+    const carried = rules
+      .map((group) => group.rename(map))
+      .filter((group) => group !== null);
+    const unchanged =
+      carried.length === rules.length &&
+      carried.every((group, i) => group.equals(rules[i]!));
+    if (unchanged) return this;
+
+    const { rules: _dropped, ...rest } = this.role!;
+    return this.with({
+      role: carried.length ? { ...rest, rules: carried } : rest,
+    });
+  }
+}
+

package/src/fields/FieldSet.ts

@@ -0,0 +1,62 @@
+import { Role } from '../axis/role/Role.js';
+import { FieldGroup } from '../constraint/FieldGroup.js';
+import { Unique } from '../constraint/Unique.js';
+import type { CompositeUnique } from '../EntityDeclarations.js';
+import { Field, type FieldName, type Fields } from './Field.js';
+
+export class FieldSet<TFields extends Fields = Fields> {
+  private constructor(private readonly fields: TFields) {}
+
+  static of<TFields extends Fields>(fields: TFields): FieldSet<TFields> {
+    return new FieldSet(fields);
+  }
+
+  /**
+   * Every entry through the field door, then the groups declared over several of them.
+   * A group written here names its members; one written on a field named itself, and the
+   * key it sat under resolved it.
+   */
+  static declared<TFields extends Fields>(
+    declared: TFields,
+    unique?: CompositeUnique<TFields>,
+  ): TFields {
+    let fields: Fields = {};
+    for (const [key, field] of Object.entries(declared)) fields[key] = new Field(field, key);
+    for (const group of unique ?? []) fields = new Unique(group).onto(fields);
+    return fields as TFields;
+  }
+
+  /**
+   * The name of the field that carries `primary`, or `undefined` when none does.
+   *
+   * `Role.of(field).isPrimary` answers about ONE field; this answers about a shape, which
+   * is the question every reader actually had. It was the same three lines spelled five
+   * times — a mirror's key, a form's row identity, GraphQL's node id, the DDL's primary
+   * key and the ORM's `findById` column — so a shape with two primaries meant whichever
+   * one that loop happened to see first, five times over.
+   *
+   * The absence is answered and not defaulted: `'id'` is a fine fallback for a form and a
+   * lie for a DDL, so the caller decides.
+   */
+  get primary(): FieldName<TFields> | undefined {
+    const primaries = Object.entries(this.fields)
+      .filter(([, field]) => Role.of(field).isPrimary)
+      .map(([name]) => name);
+
+    if (primaries.length > 1) {
+      throw new Error(
+        `FieldSet.primary: ${primaries.map((name) => JSON.stringify(name)).join(', ')} all declare ` +
+        '`primary`; a field set can have only one primary field.',
+      );
+    }
+
+    return primaries[0] as FieldName<TFields> | undefined;
+  }
+
+  get uniqueGroups(): CompositeUnique<TFields> | undefined {
+    const groups = FieldGroup.groupsOf(this.fields, Unique);
+    return groups.length
+      ? groups.map((group) => [...group.members]) as unknown as CompositeUnique<TFields>
+      : undefined;
+  }
+}

package/src/index.ts

@@ -0,0 +1,64 @@
+export { Field, type Fields } from './fields/Field.js';
+export { FieldSet } from './fields/FieldSet.js';
+export { type Shape, Anatomy } from './axis/shape/Shape.js';
+export { type StringFormat, type FormatPredicate, Formats } from './axis/shape/Formats.js';
+export { Role, type RoleRules } from './axis/role/Role.js';
+export { type Relation, type EntityConstructor } from './axis/role/Relation.js';
+export { Lifecycle, type LifecycleRules } from './axis/lifecycle/Lifecycle.js';
+export { type GeneratorRef, Generators } from './axis/lifecycle/Generators.js';
+export { Clock } from './axis/lifecycle/Clock.js';
+export { Boundary, type BoundaryRules, type BoundaryRef } from './axis/boundary/Boundary.js';
+export { type Decoder, type Encoder, Boundaries } from './axis/boundary/Boundaries.js';
+export { type Meta } from './axis/Meta.js';
+export { FieldGroup } from './constraint/FieldGroup.js';
+export { Unique } from './constraint/Unique.js';
+
+export { Schema, ANONYMOUS_SCHEMA_NAME, type SchemaConstructor } from './schema/Schema.js';
+export { SchemaDerivation } from './schema/SchemaDerivation.js';
+export { isObject } from './judge/ValueForm.js';
+export { Cases, type Case } from './judge/Cases.js';
+export { RowRefusal } from './judge/RowRefusal.js';
+export { type SchemaView, type Row, type PartialRow } from './schema/SchemaView.js';
+export { type FougereEntityAdapters, type EntityAdapters } from './EntityAdapters.js';
+export { lowerFirst, upperFirst } from './utils.js';
+
+export { primary } from './vocabulary/primary.js';
+export { text } from './vocabulary/text.js';
+export { email } from './vocabulary/email.js';
+export { url } from './vocabulary/url.js';
+export { list } from './vocabulary/list.js';
+export { number } from './vocabulary/number.js';
+export { bool } from './vocabulary/bool.js';
+export { date } from './vocabulary/date.js';
+export { created } from './vocabulary/created.js';
+export { updated } from './vocabulary/updated.js';
+export { oneOf } from './vocabulary/oneOf.js';
+export { ref } from './vocabulary/ref.js';
+export { many } from './vocabulary/many.js';
+export { optional } from './vocabulary/optional.js';
+export { nullable } from './vocabulary/nullable.js';
+export { immutable } from './vocabulary/immutable.js';
+export { unique } from './vocabulary/unique.js';
+export { indexed } from './vocabulary/indexed.js';
+export { readOnly } from './vocabulary/readOnly.js';
+export { writeOnly } from './vocabulary/writeOnly.js';
+export { json } from './vocabulary/json.js';
+
+export { applyCreate, applyUpdate } from './axis/lifecycle/apply.js';
+export { Visibility } from './projection/Visibility.js';
+export { Card } from './card/Card.js';
+export { Bundle } from './card/Bundle.js';
+export type { Change, Diff, DiffOptions, SetDiff, SetDiffOptions, RenameCandidate, TypeSet } from './card/diff.js';
+export { EntityTypeSource, type EntityTypeSourceOptions } from './card/EntityTypeSource.js';
+export { FacadeTypeSource, type FacadeTypeSourceOptions, type OpDescriptor } from './card/FacadeTypeSource.js';
+export { type SchemaBundle, type SchemaDescriptor, type FieldDescriptor, type FieldExtension, type RoleDescriptor, type RelationDescriptor } from './card/Descriptor.js';
+export { type SchemaOrCard, schemaOf, fieldsOf } from './projection/SchemaOrCard.js';
+export type { StandardSchemaV1 } from './projection/standard.js';
+
+export { entity } from './entity.js';
+
+export { FieldJudge } from './judge/FieldJudge.js';
+export { ValueJudge } from './judge/ValueJudge.js';
+export { RowJudge } from './judge/RowJudge.js';
+export { type ValidateOptions } from './judge/options.js';
+export { type ValidationError, type ValidationResult, type Checked } from './judge/result.js';

package/src/judge/Cases.ts

@@ -0,0 +1,139 @@
+import { Anatomy } from '../axis/shape/Shape.js';
+import { Boundary } from '../axis/boundary/Boundary.js';
+import { Lifecycle } from '../axis/lifecycle/Lifecycle.js';
+import { Role } from '../axis/role/Role.js';
+import type { Field } from '../fields/Field.js';
+import type { SchemaView } from '../schema/SchemaView.js';
+import { RowJudge } from './RowJudge.js';
+import { RowRefusal } from './RowRefusal.js';
+
+/**
+ * One input, and what the judge must answer.
+ *
+ * `expect` carries the PATH of the field at fault and never the message. We know which
+ * field must be refused because we are the ones who broke it; naming the message would
+ * make this list a second judge, and the two would then have to be kept in step by hand —
+ * which is the duplication the whole thing exists to remove.
+ */
+export interface Case {
+  /** What this input does, in one clause — carried into the assertion so a failure reads. */
+  why: string;
+  body: unknown;
+  /**
+   * Judged as an update rather than a creation. The two modes refuse different things:
+   * an absence is `Required` on create and legal on patch, an immutable field is legal
+   * on create and refused on patch.
+   */
+  patch: boolean;
+  expect: 'accept' | { reject: string };
+}
+
+/** A value of the wrong type for the declared shape — the one violation every field has. */
+function wrongTypeFor(field: Field): unknown {
+  const declared = (field.shape as { type?: string | readonly string[] }).type;
+  const names = Array.isArray(declared) ? declared : [declared];
+  return names.includes('string') ? 42 : 'not-a-value-of-this-shape';
+}
+
+/** Values that break a stated bound. Empty when the field states none. */
+function outOfBoundsFor(field: Field): { why: string; value: unknown }[] {
+  // Through `Anatomy`, not a cast: the cast admitted any keyword, and it declared
+  // `maxItems` — which no branch below ever produced. In the one function whose job is
+  // to be exhaustive, a bound the type does not carry is a case nobody notices missing.
+  const shape = Anatomy.of(field.shape).base;
+  const out: { why: string; value: unknown }[] = [];
+  if (shape?.type === 'string') {
+    if (typeof shape.minLength === 'number' && shape.minLength > 0)
+      out.push({ why: 'shorter than min', value: 'x'.repeat(shape.minLength - 1) });
+    if (typeof shape.maxLength === 'number')
+      out.push({ why: 'longer than max', value: 'x'.repeat(shape.maxLength + 1) });
+    if (shape.enum) out.push({ why: 'outside the stated set', value: '__not-in-enum__' });
+  }
+  if (shape?.type === 'number' || shape?.type === 'integer') {
+    if (typeof shape.minimum === 'number') out.push({ why: 'below minimum', value: shape.minimum - 1 });
+    if (typeof shape.maximum === 'number') out.push({ why: 'above maximum', value: shape.maximum + 1 });
+  }
+  if (shape?.type === 'array') {
+    if (typeof shape.minItems === 'number' && shape.minItems > 0)
+      out.push({ why: 'fewer items than min', value: [] });
+    if (typeof shape.maxItems === 'number')
+      out.push({ why: 'more items than max', value: Array.from({ length: shape.maxItems + 1 }, () => null) });
+  }
+  return out;
+}
+
+/**
+ * The decision table, enumerated on the entity's own fields.
+ *
+ * Use the complete entity so a derived view cannot hide a divergent field. The caller
+ * supplies a valid row; generating data belongs to the testing package.
+ */
+export class Cases {
+  private constructor(
+    readonly all: readonly Case[],
+  ) {}
+
+  static of(entity: SchemaView, valid: Record<string, unknown>): Cases {
+    return new Cases(enumerate(entity, valid));
+  }
+
+  /**
+   * Whether a verdict is the one a case expected.
+   *
+   * Takes the RESULT rather than the input so the same reader serves the local judge, the
+   * façade and a door — the three that have to agree.
+   */
+  static holds(expected: Case['expect'], result: { success: boolean; errors?: { path: string }[] }): boolean {
+    if (expected === 'accept') return result.success;
+    if (result.success) return false;
+    return (result.errors ?? []).some((error) => error.path === expected.reject);
+  }
+
+  /** Every way a row is refused for its structure — the closed set this table must cover. */
+  static get refusals(): string[] {
+    return Object.values(RowRefusal);
+  }
+
+  [Symbol.iterator](): Iterator<Case> {
+    return this.all[Symbol.iterator]();
+  }
+}
+
+function enumerate(entity: SchemaView, valid: Record<string, unknown>): Case[] {
+  const fields = entity.getFields();
+  const judge = RowJudge.of(fields);
+  const cases: Case[] = [];
+  const withField = (name: string, value: unknown) => ({ ...valid, [name]: value });
+
+  cases.push({ why: 'a valid body', body: valid, patch: false, expect: 'accept' });
+  cases.push({ why: 'a key outside the contract', body: { ...valid, __unknown__: 'x' }, patch: false, expect: { reject: '__unknown__' } });
+  cases.push({ why: 'not an object at all', body: 'a string', patch: false, expect: { reject: '.' } });
+
+  for (const [name, field] of Object.entries(fields) as [string, Field][]) {
+    // A reference names a row that must exist; the caller supplied its id and we do not
+    // get to invent a second one, so the only case we can state about it is the bound one.
+    const isRef = Role.of(field).isReference;
+
+    if (judge.onAbsent(field) === null && name in valid) {
+      const body = { ...valid };
+      delete body[name];
+      cases.push({ why: `${name} absent`, body, patch: false, expect: { reject: name } });
+    }
+
+    if (Boundary.of(field).readOnly) {
+      cases.push({ why: `${name} supplied although read-only`, body: withField(name, wrongTypeFor(field)), patch: false, expect: { reject: name } });
+    }
+
+    if (Lifecycle.of(field).immutable && !Role.of(field).isPrimary) {
+      cases.push({ why: `${name} supplied on an update`, body: { [name]: valid[name] ?? wrongTypeFor(field) }, patch: true, expect: { reject: name } });
+    }
+
+    if (name in valid && !isRef) {
+      cases.push({ why: `${name} of the wrong type`, body: withField(name, wrongTypeFor(field)), patch: false, expect: { reject: name } });
+      for (const { why, value } of outOfBoundsFor(field))
+        cases.push({ why: `${name} ${why}`, body: withField(name, value), patch: false, expect: { reject: name } });
+    }
+  }
+
+  return cases;
+}

package/src/judge/FieldJudge.ts

@@ -0,0 +1,61 @@
+import { EXTENSION_AXES } from "../axis/Axis.js";
+import { Anatomy } from "../axis/shape/Shape.js";
+import type { Field } from "../fields/Field.js";
+import { isObject } from "./ValueForm.js";
+import type { ValidationError, ValidationResult } from "./result.js";
+
+export class FieldJudge {
+  private constructor(private readonly declaration: unknown) {}
+
+  static of(declaration: unknown): FieldJudge {
+    return new FieldJudge(declaration);
+  }
+
+  get verdict(): ValidationResult<Field> {
+    const declaration = this.declaration;
+
+    if (!isObject(declaration)) {
+      return {
+        success: false,
+        errors: [
+          {
+            path: ".",
+            message: `Expected an object — got ${JSON.stringify(declaration)}`,
+          },
+        ],
+      };
+    }
+
+    const errors: ValidationError[] = [];
+
+    if (!Anatomy.is(declaration.shape)) {
+      errors.push({
+        path: "shape",
+        message: `Every field states a shape — got ${JSON.stringify(declaration.shape)}`,
+      });
+    }
+
+    for (const axis of EXTENSION_AXES) {
+      const declared = declaration[axis.slot];
+      if (declared !== undefined) axis.judge(declared, errors);
+    }
+
+    if (declaration.meta !== undefined) {
+      if (!isObject(declaration.meta)) {
+        errors.push({
+          path: "meta",
+          message: `Expected an object — got ${JSON.stringify(declaration.meta)}`,
+        });
+      } else if (
+        declaration.meta.description !== undefined &&
+        typeof declaration.meta.description !== "string"
+      ) {
+        errors.push({ path: "meta.description", message: "Expected a string" });
+      }
+    }
+
+    return errors.length
+      ? { success: false, errors }
+      : { success: true, data: declaration as unknown as Field };
+  }
+}

package/src/judge/RowJudge.ts

@@ -0,0 +1,84 @@
+import { Boundary } from '../axis/boundary/Boundary.js';
+import { Lifecycle } from '../axis/lifecycle/Lifecycle.js';
+import { Role } from '../axis/role/Role.js';
+import type { Field, Fields } from '../fields/Field.js';
+import type { ValidateOptions } from './options.js';
+import type { ValidationError, ValidationResult } from './result.js';
+import { ValueJudge } from './ValueJudge.js';
+import { RowRefusal } from './RowRefusal.js';
+
+export class RowJudge {
+  private constructor(
+    private readonly fields: Fields,
+    private readonly options: ValidateOptions,
+  ) {}
+
+  static of(fields: Fields, options: ValidateOptions = {}): RowJudge {
+    return new RowJudge(fields, options);
+  }
+
+  onAbsent(field: Field): 'skip' | 'empty-list' | null {
+    if (Boundary.of(field).readOnly) return 'skip';
+    if (!Lifecycle.of(field).requiredAtCreate) return 'skip';
+    if (Role.of(field).isCollection) return 'empty-list';
+    return null;
+  }
+
+  check(input: unknown): ValidationResult<Record<string, unknown>> {
+    if (typeof input !== 'object' || input === null) {
+      return { success: false, errors: [{ path: '.', message: RowRefusal.notAnObject }] };
+    }
+
+    const data = input as Record<string, unknown>;
+    const errors: ValidationError[] = [];
+    const out: Record<string, unknown> = {};
+
+    for (const key of Object.keys(data)) {
+      if (!(key in this.fields)) {
+        errors.push({ path: key, message: RowRefusal.unknownField });
+      }
+    }
+
+    for (const [key, field] of Object.entries(this.fields)) {
+      const path = key;
+      const value = data[key];
+
+      if (value === undefined) {
+        if (this.options.patch) continue;
+        const absence = this.onAbsent(field);
+        if (absence === null) {
+          errors.push({ path, message: RowRefusal.required });
+          continue;
+        }
+        if (absence === 'empty-list') out[key] = [];
+        continue;
+      }
+
+      const boundary = Boundary.of(field);
+      if (boundary.readOnly) {
+        errors.push({ path, message: RowRefusal.readOnly });
+        continue;
+      }
+      if (this.options.patch && Lifecycle.of(field).immutable) {
+        errors.push({ path, message: RowRefusal.immutable });
+        continue;
+      }
+
+      const checked = ValueJudge.of(field).check(value);
+      if ('error' in checked) {
+        errors.push({ path, message: checked.error });
+        continue;
+      }
+      if (checked.value === null) {
+        out[key] = null;
+        continue;
+      }
+      const decoded = boundary.decode(checked.value);
+      if ('error' in decoded) errors.push({ path, message: decoded.error });
+      else out[key] = decoded.value;
+    }
+
+    if (errors.length > 0) return { success: false, errors };
+    return { success: true, data: out };
+  }
+}

package/src/judge/RowRefusal.ts

@@ -0,0 +1,17 @@
+/**
+ * Every way a row is refused for its STRUCTURE — the closed set, stated once.
+ *
+ * A value refused by its own shape carries the engine's message and a decoder refused by
+ * user code carries that code's; neither is structural and neither belongs here. These
+ * five are `RowJudge`'s own, and a table of cases enumerates them instead of reading the
+ * text of a function — which a minifier rewrites without a word.
+ */
+export const RowRefusal = {
+  notAnObject: 'Expected an object',
+  unknownField: 'Unknown field',
+  required: 'Required',
+  readOnly: 'Read-only',
+  immutable: 'Immutable',
+} as const;
+
+export type RowRefusal = (typeof RowRefusal)[keyof typeof RowRefusal];

package/src/judge/ValueForm.ts

@@ -0,0 +1,7 @@
+export const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+export const oneOfTokens = <T extends readonly string[]>(
+  value: unknown,
+  tokens: T,
+): value is T[number] => typeof value === 'string' && (tokens as readonly string[]).includes(value);