@fougere/schema 0.5.0-alpha.1 → 0.7.0-alpha.0

package/src/card/Card.ts

@@ -1,256 +0,0 @@
-import { EXTENSION_AXES, EXTENSION_SLOTS, type Resolver } from '../axis/Axis.js';
-import { dequal } from 'dequal';
-import { clean } from '../utils.js';
-import { Field, type Fields } from '../fields/Field.js';
-import { isObject } from '../judge/ValueForm.js';
-import { RowJudge } from '../judge/RowJudge.js';
-import { Schema, type SchemaConstructor } from '../schema/Schema.js';
-import type { Row, SchemaView } from '../schema/SchemaView.js';
-import { refuse } from './admission.js';
-import type {
-  DerivedFrom,
-  FieldDescriptor,
-  FieldExtension,
-  SchemaDescriptor,
-} from './Descriptor.js';
-import type { Change, Diff, DiffOptions, RenameCandidate, TypeSet } from './diff.js';
-
-type FieldsOf<T> = { [K in keyof T]-?: Field<T[K]> };
-
-/** One portable schema description and every decision made about that description. */
-export class Card<T = Row<Fields>> {
-  private constructor(readonly descriptor: SchemaDescriptor) {}
-
-  static fromSchema<TFields extends Fields>(schema: SchemaView<TFields>, name?: string): Card<Row<TFields>> {
-    const fields = schema.getFields();
-    const judge = RowJudge.of(fields);
-    const properties: Record<string, FieldDescriptor> = {};
-    const required: string[] = [];
-    for (const [key, field] of Object.entries(fields)) {
-      properties[key] = describeField(field, key);
-      if (judge.onAbsent(field) === null) required.push(key);
-    }
-
-    const descriptor: SchemaDescriptor = {
-      type: 'object',
-      properties,
-      'x-fougere-version': 1,
-      'x-fougere-vendor': 'fougere',
-    };
-    const title = name ?? schema.derivation?.sourceName ?? schema.name;
-    if (title) descriptor.title = title;
-    if (required.length) descriptor.required = required;
-
-    const origin = originOf(schema);
-    if (origin) descriptor['x-fougere-derived'] = origin;
-    return new Card<Row<TFields>>(descriptor);
-  }
-
-  static fromDescriptor<T = Row<Fields>>(descriptor: SchemaDescriptor): Card<T> {
-    return new Card<T>(descriptor);
-  }
-
-  /** The root derivation recorded by this card, when its schema was cut from another. */
-  get origin(): DerivedFrom | undefined {
-    return this.descriptor['x-fougere-derived'];
-  }
-
-  /**
-   * Rebuild the live schema. A bundle supplies `resolve` so relation thunks can find the
-   * other reconstructed cards; a lone card deliberately falls back to a name stand-in.
-   */
-  toSchema(resolve?: Resolver, name?: string): SchemaConstructor<FieldsOf<T>> {
-    const descriptor = this.descriptor;
-    const where = name ? `schema '${name}'` : 'this schema';
-    if (!isObject(descriptor)) refuse(`${where} is not an object`, 'A card carries one JSON Schema per door.');
-    const version = descriptor['x-fougere-version'];
-    if (version !== 1) {
-      refuse(
-        `${where} states \`x-fougere-version: ${JSON.stringify(version)}\` and this reader speaks 1`,
-        'A producer and its readers move together: re-sync the consumer, or serve the version it speaks.',
-      );
-    }
-    if (!isObject(descriptor.properties)) {
-      refuse(`${where} carries no \`properties\` object`, 'A schema is its fields; there is nothing to rebuild.');
-    }
-
-    const fields: Fields = {};
-    for (const [key, property] of Object.entries(descriptor.properties)) {
-      fields[key] = reconstructField(property, key, resolve);
-    }
-    const schema = Schema.of({ fields });
-    const title = name ?? descriptor.title;
-    if (title) Object.defineProperty(schema, 'name', { value: title, configurable: true });
-    return schema as unknown as SchemaConstructor<FieldsOf<T>>;
-  }
-
-  /** What must change to turn this card into `other`. */
-  diff(other: Card, options: DiffOptions = {}): Diff {
-    const changes: Change[] = [];
-    const renamed = options.renamed ?? {};
-    const before = this.descriptor.properties ?? {};
-    const after = other.descriptor.properties ?? {};
-    const requiredBefore = new Set(this.descriptor.required ?? []);
-    const requiredAfter = new Set(other.descriptor.required ?? []);
-
-    // Apply a declared rename first so subsequent differences use the new field name.
-    const nameAfter = (field: string): string => renamed[field] ?? field;
-    const removed: string[] = [];
-    for (const [field, descriptor] of Object.entries(before)) {
-      const now = nameAfter(field);
-      const target = after[now];
-      if (target === undefined) {
-        removed.push(field);
-        continue;
-      }
-
-      if (now !== field) changes.push({ kind: 'renamed', from: field, to: now, field: target });
-
-      const wasType = typesOf(descriptor);
-      const isType = typesOf(target);
-      if (!dequal(wasType, isType)) changes.push({ kind: 'retyped', field: now, from: wasType, to: isType });
-      else if (!dequal(boundsOf(descriptor), boundsOf(target))) {
-        changes.push({ kind: 'reshaped', field: now, from: descriptor, to: target });
-      }
-
-      const wasRequired = requiredBefore.has(field);
-      const isRequired = requiredAfter.has(now);
-      if (wasRequired !== isRequired) {
-        changes.push({ kind: 'required', field: now, from: wasRequired, to: isRequired });
-      }
-      changes.push(...restated(now, descriptor['x-fougere'], target['x-fougere']));
-    }
-
-    const claimed = new Set(Object.values(renamed));
-    const added = Object.keys(after).filter((field) => !(field in before) && !claimed.has(field));
-    for (const field of removed) {
-      changes.push({ kind: 'removed', field, from: before[field], required: requiredBefore.has(field) });
-    }
-    for (const field of added) {
-      changes.push({ kind: 'added', field, to: after[field], required: requiredAfter.has(field) });
-    }
-
-    return { changes, ambiguous: candidates(removed, added, before, after) };
-  }
-}
-
-function describeExtension(field: Field, key: string): FieldExtension | undefined {
-  const extension: Record<string, unknown> = {};
-  for (const axis of EXTENSION_AXES) {
-    const declared = (field as unknown as Record<string, unknown>)[axis.slot];
-    if (declared === undefined) continue;
-    const wire = axis.describe(declared, key);
-    if (wire !== undefined) extension[axis.slot] = wire;
-  }
-  clean(extension);
-  return Object.keys(extension).length ? (extension as FieldExtension) : undefined;
-}
-
-function describeField(field: Field, key: string): FieldDescriptor {
-  const descriptor: FieldDescriptor = {};
-  for (const [shapeKey, value] of Object.entries(field.shape)) {
-    if (value !== undefined) (descriptor as Record<string, unknown>)[shapeKey] = value;
-  }
-  if (field.meta?.description) descriptor.description = field.meta.description;
-  const extension = describeExtension(field, key);
-  if (extension) descriptor['x-fougere'] = extension;
-  return descriptor;
-}
-
-function originOf(schema: SchemaView): DerivedFrom | undefined {
-  const { derivation } = schema;
-  if (!derivation) return undefined;
-  const survived = Object.fromEntries(Object.entries(derivation.survived).map(([key, value]) => [key, value ?? null]));
-  return { from: derivation.sourceName, survived };
-}
-
-function reconstructShape(property: FieldDescriptor): Field['shape'] | undefined {
-  const types = Array.isArray(property.type) ? property.type : property.type ? [property.type] : [];
-  const base = types.find((type) => type !== 'null');
-  if (base === undefined) return undefined;
-  const type = property.type as Field['shape']['type'];
-  if (base === 'array') {
-    const items = property.items ? reconstructShape(property.items) : undefined;
-    return clean({ type, items, minItems: property.minItems, maxItems: property.maxItems }) as Field['shape'];
-  }
-  switch (base) {
-    case 'string':
-      return clean({
-        type,
-        minLength: property.minLength,
-        maxLength: property.maxLength,
-        pattern: property.pattern,
-        enum: property.enum,
-        format: property.format,
-      }) as Field['shape'];
-    case 'number':
-    case 'integer':
-      return clean({ type, minimum: property.minimum, maximum: property.maximum }) as Field['shape'];
-    case 'boolean':
-      return { type } as Field['shape'];
-    default:
-      return clean({ type, properties: property.properties, required: property.required }) as Field['shape'];
-  }
-}
-
-function reconstructField(property: FieldDescriptor, key: string, resolve?: Resolver): Field {
-  const shape = reconstructShape(property);
-  if (!shape) {
-    throw new Error(
-      `Field '${key}': the card carries no \`type\` for it, so there is no shape to rebuild. `
-      + 'A field always states one.',
-    );
-  }
-  const extension = property['x-fougere'];
-  const axes: Record<string, unknown> = {};
-  for (const axis of EXTENSION_AXES) {
-    const wire = (extension as Record<string, unknown> | undefined)?.[axis.slot];
-    if (wire !== undefined) axes[axis.slot] = axis.reconstruct(wire, resolve);
-  }
-  return new Field({
-    shape,
-    ...axes,
-    meta: property.description !== undefined ? { description: property.description } : undefined,
-  } as never);
-}
-
-function restated(field: string, before: FieldExtension | undefined, after: FieldExtension | undefined): Change[] {
-  return EXTENSION_SLOTS.filter((axis) => !dequal(before?.[axis], after?.[axis])).map(
-    (axis) => ({ kind: 'restated', field, axis, from: before?.[axis], to: after?.[axis] }) as Change,
-  );
-}
-
-function shapeOf(descriptor: FieldDescriptor): Record<string, unknown> {
-  const { 'x-fougere': _extension, ...shape } = descriptor;
-  return shape as Record<string, unknown>;
-}
-
-function typesOf(descriptor: FieldDescriptor): TypeSet {
-  const type = descriptor.type;
-  if (type === undefined) return [];
-  return (Array.isArray(type) ? [...type] : [type]).sort();
-}
-
-function boundsOf(descriptor: FieldDescriptor): Record<string, unknown> {
-  const { type: _type, ...rest } = shapeOf(descriptor);
-  return rest;
-}
-
-function candidates(
-  removed: string[],
-  added: string[],
-  before: Record<string, FieldDescriptor>,
-  after: Record<string, FieldDescriptor>,
-): RenameCandidate[] {
-  const found: RenameCandidate[] = [];
-  for (const gone of removed) {
-    for (const appeared of added) {
-      if (dequal(shapeOf(before[gone]), shapeOf(after[appeared]))) found.push({ removed: gone, added: appeared });
-    }
-  }
-  const was = Object.keys(before);
-  const now = Object.keys(after);
-  const apart = ({ removed: gone, added: appeared }: RenameCandidate): number =>
-    Math.abs(now.indexOf(appeared) - was.indexOf(gone));
-  return found.sort((a, b) => apart(a) - apart(b));
-}

package/src/card/EntityTypeSource.ts

@@ -1,90 +0,0 @@
-import { upperFirst } from '../utils.js';
-import type { FieldDescriptor, SchemaDescriptor } from './Descriptor.js';
-
-function typeOf(field: FieldDescriptor): string {
-  const types = Array.isArray(field.type) ? field.type : field.type ? [field.type] : [];
-  const nullable = types.includes('null');
-  const base = types.find((t) => t !== 'null');
-  const inner = baseTypeOf(base, field);
-  return nullable ? `${inner} | null` : inner;
-}
-
-function baseTypeOf(base: string | undefined, field: FieldDescriptor): string {
-  if (field.enum?.length) {
-    return field.enum.map((v) => (v === null ? 'null' : JSON.stringify(v))).join(' | ');
-  }
-  switch (base) {
-    case 'string':
-      return field.format === 'date-time' ? 'Date' : 'string';
-    case 'number':
-    case 'integer':
-      return 'number';
-    case 'boolean':
-      return 'boolean';
-    case 'array':
-      return field.items ? `${typeOf(field.items)}[]` : 'string[]';
-    case 'object':
-      return field.properties ? objectTypeOf(field.properties, field.required ?? []) : 'Record<string, unknown>';
-    default:
-      return 'unknown';
-  }
-}
-
-function objectTypeOf(properties: Record<string, FieldDescriptor>, required: readonly string[]): string {
-  const members = Object.entries(properties).map(([name, field]) => {
-    const optional = required.includes(name) ? '' : '?';
-    return `${propertyKey(name)}${optional}: ${typeOf(field)}`;
-  });
-  return `{ ${members.join('; ')} }`;
-}
-
-function propertyKey(name: string): string {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
-}
-
-function docCommentOf(text: string | undefined, indent: string): string {
-  if (!text) return '';
-  return `${indent}/** ${text.replace(/\*\//g, '*\\/')} */\n`;
-}
-
-export interface EntityTypeSourceOptions {
-  name?: string;
-  exported?: boolean;
-}
-
-function shapeTypeOf(descriptor: SchemaDescriptor, indent = ''): string {
-  const entries = Object.entries(descriptor.properties ?? {});
-  if (entries.length === 0) return '{}';
-
-  const lines = entries.map(([key, field]) => {
-    const doc = docCommentOf(field.description, `${indent}  `);
-    return `${doc}${indent}  ${propertyKey(key)}: ${typeOf(field)};`;
-  });
-  return `{\n${lines.join('\n')}\n${indent}}`;
-}
-
-export class EntityTypeSource {
-  private constructor(private readonly descriptor: SchemaDescriptor) {}
-
-  static of(descriptor: SchemaDescriptor): EntityTypeSource {
-    return new EntityTypeSource(descriptor);
-  }
-
-  render(options: EntityTypeSourceOptions = {}): string {
-    const name = identifierOf(options.name ?? upperFirst(this.descriptor.title ?? 'Schema'));
-    const exported = options.exported === false ? '' : 'export ';
-    const card = JSON.stringify(this.descriptor, null, 2)
-      .split('\n')
-      .map((line, i) => (i === 0 ? line : `  ${line}`))
-      .join('\n');
-
-    return `${exported}class ${name} extends Card.fromDescriptor<${shapeTypeOf(this.descriptor)}>(${card}).toSchema() {}`;
-  }
-}
-
-function identifierOf(name: string): string {
-  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) {
-    throw new Error(`'${name}' is not a TypeScript identifier — it cannot name a generated declaration`);
-  }
-  return name;
-}

package/src/card/FacadeTypeSource.ts

@@ -1,55 +0,0 @@
-import type { SchemaDescriptor } from './Descriptor.js';
-
-export interface FacadeTypeSourceOptions {
-  name?: string;
-  exported?: boolean;
-  rowType?: string;
-}
-
-export interface OpDescriptor {
-  name: string;
-  description?: string;
-  output?: SchemaDescriptor;
-  cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
-}
-
-function propertyKey(name: string): string {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
-}
-
-function docCommentOf(text: string | undefined, indent: string): string {
-  if (!text) return '';
-  return `${indent}/** ${text.replace(/\*\//g, '*\\/')} */\n`;
-}
-
-function returnTypeOf(op: OpDescriptor, rowType: string): string {
-  switch (op.cardinality) {
-    case 'many': return `${rowType}[]`;
-    case 'page': return `${rowType}[] & { total?: number; endCursor?: string; hasMore?: boolean }`;
-    case 'maybe': return `${rowType} | undefined`;
-    case 'one': return rowType;
-    case 'none': return 'unknown';
-    default: return 'unknown';
-  }
-}
-
-export class FacadeTypeSource {
-  private constructor(private readonly operations: readonly OpDescriptor[]) {}
-
-  static of(operations: readonly OpDescriptor[]): FacadeTypeSource {
-    return new FacadeTypeSource(operations);
-  }
-
-  render(options: FacadeTypeSourceOptions = {}): string {
-    const name = options.name ?? 'Facade';
-    const exported = options.exported === false ? '' : 'export ';
-    const rowType = options.rowType ?? 'unknown';
-    const members = this.operations.map((operation) => {
-      const doc = docCommentOf(operation.description, '  ');
-      return `${doc}  ${propertyKey(operation.name)}(invocation?: Invocation): Promise<${returnTypeOf(operation, rowType)}>;`;
-    });
-
-    if (members.length === 0) return `${exported}interface ${name} {}`;
-    return `${exported}interface ${name} {\n${members.join('\n')}\n}`;
-  }
-}

package/src/card/admission.ts

@@ -1,25 +0,0 @@
-import type { ValidationError } from '../judge/result.js';
-
-/** A card is refused by naming what is wrong AND the remedy — never by a bare throw. */
-export function refuse(what: string, fix: string): never {
-  throw new Error(`This card cannot be read: ${what}.\n  ${fix}`);
-}
-
-/**
- * A wire value admitted by the axis's OWN judge — legal only where its declared and wire
- * forms are the same value, which `describe: v => v` states.
- */
-export function admitWire(
-  judge: (value: unknown, errors: ValidationError[]) => void,
-  value: unknown,
-  slot: string,
-): void {
-  const errors: ValidationError[] = [];
-  judge(value, errors);
-  if (errors.length) {
-    refuse(
-      `${slot} is malformed — ${errors.map((e) => `${e.path}: ${e.message}`).join('; ')}`,
-      'A card states an axis the way a declaration does.',
-    );
-  }
-}

package/src/constraint/FieldGroup.ts

@@ -1,91 +0,0 @@
-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

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

package/src/fields/Field.ts

@@ -1,80 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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;
-  }
-}