@fougere/schema 0.3.0-alpha.0 → 0.4.0-alpha.0

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);

package/src/judge/ValueJudge.ts

@@ -0,0 +1,72 @@
+import { Validator, format as engineFormats } from '@cfworker/json-schema';
+import { Formats, type FormatPredicate } from '../axis/shape/Formats.js';
+import { Anatomy, type Shape } from '../axis/shape/Shape.js';
+import type { Field } from '../fields/Field.js';
+import type { Checked } from './result.js';
+
+interface ShapePlan {
+  validator: Validator;
+  custom?: FormatPredicate;
+  formatName?: string;
+}
+
+export class ValueJudge {
+  private static readonly plans = new WeakMap<object, ShapePlan>();
+
+  private constructor(private readonly field: Field) {}
+
+  static of(field: Field): ValueJudge {
+    return new ValueJudge(field);
+  }
+
+  check(value: unknown): Checked {
+    const shape = this.field.shape;
+    const base = Anatomy.of(shape).base;
+    if (value !== null) {
+      if (base?.type === 'object' && !base.properties) return { value };
+      if (base?.type === 'string' && base.format === 'date-time' && value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? { error: 'Invalid date' } : { value };
+      }
+      if (
+        (base?.type === 'number' || base?.type === 'integer') &&
+        typeof value === 'number' &&
+        Number.isNaN(value)
+      ) {
+        return { error: 'Expected a number' };
+      }
+    }
+    const plan = ValueJudge.planFor(shape);
+    const result = plan.validator.validate(value);
+    if (!result.valid) return { error: result.errors[0]?.error ?? 'Invalid value' };
+    if (plan.custom && typeof value === 'string' && !plan.custom(value)) {
+      return { error: `String does not match format "${plan.formatName}".` };
+    }
+    return { value };
+  }
+
+  private static planFor(shape: Shape): ShapePlan {
+    let plan = this.plans.get(shape);
+    if (!plan) {
+      const base = Anatomy.of(shape).base;
+      const formatName = base?.type === 'string' ? base.format : undefined;
+      plan = {
+        validator: new Validator(shape as object, '2020-12', true),
+        custom: formatName === undefined ? undefined : this.customFormatOf(formatName),
+        formatName,
+      };
+      this.plans.set(shape, plan);
+    }
+    return plan;
+  }
+
+  private static customFormatOf(name: string): FormatPredicate | undefined {
+    const custom = Formats.resolve(name);
+    if (!custom && !(name in engineFormats)) {
+      throw new Error(
+        `Unknown format: '${name}'. Register it with Formats.register('${name}', …) — ` +
+          `the engine judges ${Object.keys(engineFormats).length} formats natively and this is not one of them.`,
+      );
+    }
+    return custom;
+  }
+}

package/src/judge/options.ts

@@ -0,0 +1,3 @@
+export interface ValidateOptions {
+  patch?: boolean;
+}

package/src/judge/result.ts

@@ -0,0 +1,10 @@
+export interface ValidationError {
+  path: string;
+  message: string;
+}
+
+export type ValidationResult<T> =
+  | { success: true; data: T }
+  | { success: false; errors: ValidationError[] };
+
+export type Checked = { value: unknown } | { error: string };

package/src/projection/SchemaOrCard.ts

@@ -0,0 +1,18 @@
+import type { Fields } from '../fields/Field.js';
+import type { SchemaView } from '../schema/SchemaView.js';
+import type { SchemaDescriptor } from '../card/Descriptor.js';
+import { Card } from '../card/Card.js';
+
+export type SchemaOrCard = SchemaView | SchemaDescriptor;
+
+function isDescriptor(source: SchemaOrCard): source is SchemaDescriptor {
+  return typeof (source as SchemaView).getFields !== 'function';
+}
+
+export function schemaOf(source: SchemaOrCard): SchemaView {
+  return isDescriptor(source) ? Card.fromDescriptor(source).toSchema() : source;
+}
+
+export function fieldsOf(source: SchemaOrCard): Fields {
+  return schemaOf(source).getFields();
+}

package/src/projection/Visibility.ts

@@ -0,0 +1,47 @@
+import { Boundary } from '../axis/boundary/Boundary.js';
+import { Lifecycle } from '../axis/lifecycle/Lifecycle.js';
+import { Role } from '../axis/role/Role.js';
+import type { Fields } from '../fields/Field.js';
+
+export class Visibility {
+  private constructor(private readonly fields: Fields) {}
+
+  static of(fields: Fields): Visibility {
+    return new Visibility(fields);
+  }
+
+  get input(): Fields {
+    const result: Fields = {};
+    for (const [name, field] of Object.entries(this.fields)) {
+      const role = Role.of(field);
+      if (role.isPrimary) continue;
+      if (Lifecycle.of(field).create === 'now') continue;
+      if (role.isCollection) continue;
+      if (Boundary.of(field).readOnly) continue;
+      result[name] = field;
+    }
+    return result;
+  }
+
+  get output(): Fields {
+    const result: Fields = {};
+    for (const [name, field] of Object.entries(this.fields)) {
+      if (Boundary.of(field).writeOnly) continue;
+      result[name] = field;
+    }
+    return result;
+  }
+
+  encode(record: Record<string, unknown>): Record<string, unknown> {
+    const out: Record<string, unknown> = { ...record };
+    for (const [key, field] of Object.entries(this.fields)) {
+      if (!(key in record)) continue;
+      const boundary = Boundary.of(field);
+      if (boundary.writeOnly) { delete out[key]; continue; }
+      const value = record[key];
+      if (value === null || value === undefined) continue;
+      out[key] = boundary.encode(value);
+    }
+    return out;
+  }
+}

package/src/projection/standard.ts

@@ -0,0 +1,47 @@
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardSchemaV1 {
+  interface Props<Input = unknown, Output = Input> {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (
+      value: unknown,
+    ) => Result<Output> | Promise<Result<Output>>;
+    readonly types?: Types<Input, Output> | undefined;
+  }
+
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+
+  interface SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+  }
+
+  interface FailureResult {
+    readonly issues: readonly Issue[];
+  }
+
+  interface Issue {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | PathSegment)[] | undefined;
+  }
+
+  interface PathSegment {
+    readonly key: PropertyKey;
+  }
+
+  interface Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+  }
+
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<
+    Schema['~standard']['types']
+  >['input'];
+
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<
+    Schema['~standard']['types']
+  >['output'];
+}

package/src/schema/Schema.ts

@@ -0,0 +1,167 @@
+import { Boundary } from '../axis/boundary/Boundary.js';
+import { type Fields } from '../fields/Field.js';
+import { type PreviousNames } from '../EntityDeclarations.js';
+import { type EntityAdapters } from '../EntityAdapters.js';
+import { FieldGroup } from '../constraint/FieldGroup.js';
+import { Unique } from '../constraint/Unique.js';
+import { type CompositeUnique } from '../EntityDeclarations.js';
+import { RowJudge } from '../judge/RowJudge.js';
+import { SchemaDerivation } from './SchemaDerivation.js';
+import { SchemaDefinition } from './SchemaDefinition.js';
+import { type ValidateOptions } from '../judge/options.js';
+import type { StandardSchemaV1 } from '../projection/standard.js';
+import type { PartialRow, Row, SchemaView } from './SchemaView.js';
+
+export const ANONYMOUS_SCHEMA_NAME = "Schema";
+
+export interface SchemaConstructor<TFields extends Fields> extends SchemaView<TFields> {
+  new (data: PartialRow<TFields>): Row<TFields>;
+  readonly "~standard": StandardSchemaV1.Props<Record<string, unknown>, Row<TFields>>;
+  readonly derivation?: SchemaDerivation;
+  readonly previous?: PreviousNames<TFields>;
+  from(data: Record<string, unknown>): Row<TFields>;
+  pick<K extends string & keyof TFields>(...keys: K[]): SchemaConstructor<Pick<TFields, K>>;
+  omit<K extends string & keyof TFields>(...keys: K[]): SchemaConstructor<Omit<TFields, K>>;
+  partial(): SchemaConstructor<TFields>;
+  extend<E extends Fields>(extra: E): SchemaConstructor<TFields & E>;
+  named(name: string): SchemaConstructor<TFields>;
+  rename(mapping: Partial<Record<string & keyof TFields, string>>): SchemaConstructor<Fields>;
+}
+
+export class Schema {
+  /** The one place a schema holds what it is. The five readings below are its projections. */
+  static definition: SchemaDefinition = SchemaDefinition.stated({ fields: {} });
+
+  static get fields(): Fields { return this.definition.fields; }
+  static get adapters(): EntityAdapters<Fields> | undefined { return this.definition.adapters; }
+  static get opts(): ValidateOptions { return this.definition.opts; }
+  static get derivation(): SchemaDerivation | undefined { return this.definition.derivation; }
+  static get previous(): PreviousNames<Fields> | undefined { return this.definition.previous; }
+
+  constructor(data?: Record<string, unknown>) {
+    if (!data) return;
+    for (const [key, value] of Object.entries(data)) {
+      Object.defineProperty(this, key, { value, writable: true, enumerable: true, configurable: true });
+    }
+  }
+
+  static getFields() { return this.fields; }
+  static getAdapters() { return this.adapters; }
+  static getUnique(): CompositeUnique<Fields> | undefined {
+    const groups = FieldGroup.groupsOf(this.fields, Unique);
+    return groups.length ? groups.map((group) => [...group.members]) : undefined;
+  }
+  static getOpts() { return this.opts; }
+
+  static validate(input: unknown) {
+    return RowJudge.of(this.fields, this.opts).check(input);
+  }
+
+  static from(data: Record<string, unknown>) {
+    const out: Record<string, unknown> = {};
+    for (const [key, field] of Object.entries(this.fields)) {
+      if (!(key in data)) continue;
+      const value = data[key];
+      if (value === null || value === undefined) { out[key] = value; continue; }
+      const decoded = Boundary.of(field).decode(value);
+      out[key] = "error" in decoded ? value : decoded.value;
+    }
+    return out;
+  }
+
+  static get ["~standard"](): StandardSchemaV1.Props<Record<string, unknown>> {
+    const { fields, opts } = this;
+    return {
+      version: 1,
+      vendor: "fougere",
+      validate(value: unknown) {
+        const result = RowJudge.of(fields, opts).check(value);
+        if (result.success) return { value: result.data };
+        return {
+          issues: result.errors.map((e) => ({
+            message: e.message,
+            path: e.path && e.path !== "." ? [{ key: e.path }] : undefined,
+          })),
+        };
+      },
+    };
+  }
+
+  static pick(...keys: string[]) {
+    assertKnownKeys("pick", keys, this.fields);
+    const picked: Fields = {};
+    for (const key of keys) if (this.fields[key]) picked[key] = this.fields[key];
+    return this.derive(picked, (k) => (keys.includes(k) ? k : undefined));
+  }
+
+  static omit(...keys: string[]) {
+    assertKnownKeys("omit", keys, this.fields);
+    const kept: Fields = {};
+    for (const [key, field] of Object.entries(this.fields)) if (!keys.includes(key)) kept[key] = field;
+    return this.derive(kept, (k) => (keys.includes(k) ? undefined : k));
+  }
+
+  static rename(mapping: Record<string, string>) {
+    assertKnownKeys("rename", Object.keys(mapping), this.fields);
+    const renamed: Fields = {};
+    for (const [key, field] of Object.entries(this.fields)) renamed[mapping[key] ?? key] = field;
+    return this.derive(renamed, (k) => mapping[k] ?? k);
+  }
+
+  static partial() {
+    return Schema.subclass(this.definition.patched(this));
+  }
+
+  static extend(extra: Fields) {
+    return Schema.subclass(this.definition.extended(extra, this));
+  }
+
+  static named(name: string) {
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) {
+      throw new Error(`named(): \`${name}\` is not a valid class name.`);
+    }
+    if (this.name !== ANONYMOUS_SCHEMA_NAME) {
+      throw new Error(`named(): \`${this.name}\` is already named by its class declaration.`);
+    }
+    Object.defineProperty(this, "name", { value: name, configurable: true });
+    return this;
+  }
+
+  static compose<T extends SchemaView[]>(...sources: T): SchemaConstructor<Merged<T>> {
+    return Schema.subclass(SchemaDefinition.merged(sources)) as unknown as SchemaConstructor<Merged<T>>;
+  }
+
+  static of<TFields extends Fields>(stated: {
+    fields: TFields;
+    derivation?: SchemaDerivation;
+    adapters?: EntityAdapters<TFields>;
+    opts?: ValidateOptions;
+    previous?: PreviousNames<TFields>;
+  }): SchemaConstructor<TFields> {
+    return Schema.subclass(SchemaDefinition.stated(stated)) as unknown as SchemaConstructor<TFields>;
+  }
+
+  /** The class a definition becomes. The one place a Schema subclass is born. */
+  private static subclass(definition: SchemaDefinition): SchemaConstructor<Fields> {
+    class Derived extends Schema {}
+    Derived.definition = definition;
+    Object.defineProperty(Derived, "name", { value: ANONYMOUS_SCHEMA_NAME, configurable: true });
+    return Derived as unknown as SchemaConstructor<Fields>;
+  }
+
+  private static derive(fields: Fields, survives: (key: string) => string | undefined) {
+    return Schema.subclass(this.definition.cut(fields, survives, this));
+  }
+}
+
+function assertKnownKeys(operation: string, keys: string[], fields: Fields): void {
+  const strangers = keys.filter((key) => !(key in fields));
+  if (strangers.length === 0) return;
+  throw new Error(
+    `${operation}(): unknown field ${strangers.map((s) => `\`${s}\``).join(", ")}. ` +
+      `This schema carries ${Object.keys(fields).join(", ")}.`,
+  );
+}
+
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type Merged<T extends SchemaView[]> = UnionToIntersection<T[number] extends { getFields(): infer F } ? F : Fields> & Fields;