@braidlabs/skew 0.1.1

package/src/lib/versioned.d.ts

@@ -0,0 +1,242 @@
+import { SkewResult } from './result.js';
+import { MigrationContext } from './context.js';
+import { LensOp } from './lens.js';
+/**
+ * Anything that crosses a version boundary is wrapped with the version it was
+ * *authored* under.
+ *
+ * The version sits outside the payload deliberately: a reader can determine the
+ * shape without parsing, validating, or trusting the payload.
+ */
+export interface VersionedEnvelope<T = unknown> {
+    /** Schema version the payload was written under. */
+    readonly v: number;
+    readonly payload: T;
+    /**
+     * Contract name the payload belongs to. Optional on the wire — hand-written
+     * envelopes and older builds omit it — but written by every `write()`, and
+     * checked on read: an envelope naming a *different* contract is refused as
+     * `invalid` instead of being silently misread through the wrong chain.
+     */
+    readonly n?: string;
+    /**
+     * Optional build identity of the writer. Not used for migration decisions —
+     * it exists so a stale read can be attributed to a specific deployment when
+     * debugging.
+     */
+    readonly b?: string;
+}
+/**
+ * A single step in a migration chain, from version `to - 1` to version `to`.
+ *
+ * `up` is mandatory — it is what "declaring the next version" means. `down`
+ * is the optional inverse: a projection back onto the older shape, honest but
+ * usually lossy. Steps authored as ops (see {@link LensOp}) get `down`,
+ * `derives`, and `lossy` computed; steps authored as code declare them.
+ */
+export interface MigrationStep<TFrom = unknown, TTo = unknown> {
+    readonly to: number;
+    readonly description: string;
+    readonly up: (previous: TFrom, ctx: MigrationContext) => TTo;
+    readonly down?: (next: TTo, ctx: MigrationContext) => TFrom;
+    /** Paths `up` fills with guesses rather than writer-reported data. */
+    readonly derives?: readonly string[];
+    /** Paths `down` fills with guesses (e.g. a restored default). */
+    readonly downDerives?: readonly string[];
+    /** Paths `down` discards — the price of projecting onto the older shape. */
+    readonly lossy?: readonly string[];
+    /** The declarative ops this step was authored from, when it was. */
+    readonly ops?: readonly LensOp[];
+}
+/** A code-authored step: an up migration, optionally its down inverse. */
+export interface CodeStepSpec<TFrom, TTo> {
+    readonly up: (previous: TFrom, ctx: MigrationContext) => TTo;
+    readonly down?: (next: TTo, ctx: MigrationContext) => TFrom;
+    readonly derives?: readonly string[];
+    readonly downDerives?: readonly string[];
+    readonly lossy?: readonly string[];
+}
+/** An ops-authored step: everything else is computed from the ops. */
+export interface OpsStepSpec {
+    readonly ops: readonly LensOp[];
+}
+export interface VersionedOptions<T> {
+    /**
+     * Shape check applied *after* migration completes. Bring your own validator
+     * (zod, valibot, a hand-written guard) — core stays dependency-free.
+     */
+    readonly validate?: (value: unknown) => value is T;
+    /**
+     * Version to assume for data that carries no envelope, i.e. records written
+     * before this schema was adopted. Defaults to 1, which makes adoption
+     * seamless: declare your *existing* shape as v1 and legacy rows migrate
+     * forward from there without a backfill.
+     */
+    readonly assumeLegacyVersion?: number;
+    /**
+     * The version of the schema's base shape (`TBase`). Defaults to 1.
+     *
+     * Raising the base is how a chain is eventually *cleaned up*. Chains are
+     * append-only at the top and trim-only at the bottom: once telemetry
+     * (`migratedFrom`, ideally with the store's `rewriteOnRead` shrinking the
+     * tail) shows a version no longer arrives, re-declare the schema with the
+     * oldest surviving shape as its base and delete the retired steps:
+     *
+     * ```ts
+     * // before: versioned<V1>('draft').next<V2>(…).next<V3>(…).next<V4>(…)
+     * export const Draft = versioned<V3>('draft', { base: 3 }).next<V4>(…);
+     * ```
+     *
+     * Version numbers are never reused or renumbered — v4 is still v4. Reads of
+     * data below the base fail with `reason: 'retired'` (a policy outcome whose
+     * remedy is discard/refetch/reset), never `gap` (a bug) — unless another
+     * bundle or a resolved contract still supplies the missing steps via the
+     * shared registry, in which case the read simply succeeds.
+     *
+     * Bare (un-enveloped) data is still assumed to be `assumeLegacyVersion`
+     * (default 1), so with a raised base it surfaces as `retired` — the safe
+     * default, since pre-adoption records carry the retired v1 shape. Set
+     * `assumeLegacyVersion: base` only when bare data is known to carry the
+     * base shape.
+     */
+    readonly base?: number;
+}
+/** Per-call options for {@link VersionedSchema.read}. */
+export interface ReadOptions {
+    /**
+     * Version of bare (un-enveloped) data, when the caller learned it out of
+     * band — a URL (`/v2/funds`), a header, a media type. Most HTTP APIs carry
+     * the version there rather than in the body; this is how you tell `read`
+     * to trust that instead of `assumeLegacyVersion`. Ignored when the data
+     * carries an envelope — the envelope is the writer's own statement.
+     */
+    readonly assumeVersion?: number;
+    /** Clock and seed for the migrations this read runs. Pin it in tests. */
+    readonly context?: MigrationContext;
+}
+/** Options object form for {@link VersionedSchema.write}. */
+export interface WriteOptions {
+    /** Stamped onto the envelope for attribution. */
+    readonly buildId?: string;
+    /**
+     * Target version to write at, when addressing a reader known to be older —
+     * writer-makes-right. Requires every intervening step to declare `down`;
+     * throws otherwise, because a writer's own chain is statically known and
+     * asking for an unreachable version is a programming error, not data skew.
+     */
+    readonly as?: number;
+    /** Clock and seed for any down-migrations this write runs. */
+    readonly context?: MigrationContext;
+}
+/**
+ * A versioned schema: the single place a type's current version, its history,
+ * and the functions that move data between them are declared.
+ *
+ * ```ts
+ * export const WeeklyContent = versioned<V1>('weekly-content')
+ *   .next<V2>('rename themeQuote to scriptureOfWeek', (p) => ({
+ *     id: p.id,
+ *     scriptureOfWeek: p.themeQuote,
+ *   }))
+ *   .next<V3>('introduce orderOfWorship', {
+ *     up: (p) => ({ ...p, orderOfWorship: { setting: '', hymns: [] } }),
+ *     down: ({ orderOfWorship, ...rest }) => rest,
+ *     derives: ['orderOfWorship'],
+ *     lossy: ['orderOfWorship'],
+ *   });
+ *
+ * const result = WeeklyContent.read(rawFromStorage);
+ * if (result.ok) render(result.value);
+ * ```
+ *
+ * ## The one rule
+ *
+ * A migration must never import your current application types or services.
+ * Close each step over its own snapshot types (`V1`, `V2`, …). The moment a
+ * migration references a live interface, it silently changes meaning the next
+ * time that interface is edited — and your old migrations start lying.
+ *
+ * ## The second rule
+ *
+ * Migrations are deterministic. Take the clock (and any uniqueness seed) from
+ * the {@link MigrationContext} argument, never from `new Date()` or
+ * `Math.random()` — a migration whose output varies between runs breaks
+ * replays, retries, and tests in ways that surface far from the cause.
+ */
+export interface VersionedSchema<TCurrent> {
+    readonly name: string;
+    /** Current version — the base (default 1) plus the number of `next()` steps declared. */
+    readonly version: number;
+    /** Declared history, oldest first. Useful for tooling and diagnostics. */
+    readonly steps: readonly MigrationStep[];
+    /**
+     * Content fingerprint of the whole chain (name, version, per-step
+     * identity). Two builds whose fingerprints match agree about what this
+     * contract means; the registry uses this to detect builds that do not.
+     */
+    readonly fingerprint: string;
+    /**
+     * Reads possibly-stale data and migrates it to the current version — in
+     * either direction.
+     *
+     * Older data migrates **up** through the chain (`migratedFrom` set, guessed
+     * fields listed in `derivedPaths`). Newer data migrates **down** when every
+     * intervening step — from this chain or contributed to the shared registry
+     * by a newer bundle or a resolved contract — declares a `down`
+     * (`downgradedFrom` set, discarded fields listed in `lossyPaths`).
+     * Otherwise the read refuses with `ahead`, exactly as before.
+     *
+     * Accepts an envelope, or bare legacy data (see
+     * {@link VersionedOptions.assumeLegacyVersion} and
+     * {@link ReadOptions.assumeVersion}).
+     */
+    read(raw: unknown, options?: ReadOptions): SkewResult<TCurrent>;
+    /**
+     * Wraps a value for storage or transport.
+     *
+     * With no options, writes the current version. With `{ as }`, down-migrates
+     * first and writes the older envelope — the polite move when the reader is
+     * known to be older than this build.
+     */
+    write(value: TCurrent, buildId?: string): VersionedEnvelope<TCurrent>;
+    write(value: TCurrent, options: WriteOptions): VersionedEnvelope;
+    /**
+     * Extends the schema with the next version. The description is required —
+     * it is the human-owned identity of the step, and the only part of a code
+     * step that two independent builds can be compared by.
+     *
+     * The returned schema is fully usable — there is no terminal `build()` call,
+     * so the chain reads as a single declaration.
+     */
+    next<TNext>(description: string, migrate: (previous: TCurrent, ctx: MigrationContext) => TNext): VersionedSchema<TNext>;
+    next<TNext>(description: string, spec: CodeStepSpec<TCurrent, TNext>): VersionedSchema<TNext>;
+    next<TNext>(description: string, spec: OpsStepSpec): VersionedSchema<TNext>;
+}
+/** True when `value` looks like a {@link VersionedEnvelope}. */
+export declare function isEnvelope(value: unknown): value is VersionedEnvelope;
+/**
+ * Reads the version off raw data without migrating it.
+ * Returns `null` for data that carries no envelope.
+ */
+export declare function peekVersion(raw: unknown): number | null;
+/**
+ * Begins a versioned schema declaration.
+ *
+ * @param name Stable identifier, used in diagnostics and by storage keys.
+ * @typeParam TBase The shape at version 1 — for an existing codebase, this is
+ *                  your *current* shape, so adoption requires no backfill.
+ */
+export declare function versioned<TBase>(name: string, options?: VersionedOptions<any>): VersionedSchema<TBase>;
+/**
+ * Constructs a schema from an explicit step list — the loader's entry point,
+ * used by tooling that assembles steps from a contract document rather than
+ * declaring them fluently.
+ *
+ * The list is indexed by target version (`steps[0]` migrates to v2) and MAY
+ * contain holes: a hole is a transition this build knows *of* but cannot
+ * *run* — a contract's named code step whose implementation this bundle does
+ * not carry. Reads that need a missing step fail with `gap` (or fall back to
+ * a registry contribution), which is the loud degradation the contract format
+ * promises. Application code should prefer {@link versioned}.
+ */
+export declare function versionedFromSteps<TCurrent>(name: string, steps: readonly (MigrationStep | undefined)[], options?: VersionedOptions<any>): VersionedSchema<TCurrent>;

package/src/lib/versioned.js

@@ -0,0 +1,275 @@
+import { err, ok } from './result.js';
+import { defaultMigrationContext } from './context.js';
+import { compileLens } from './lens.js';
+import { chainFingerprint } from './fingerprint.js';
+import { registryStep } from './registry.js';
+import { isSkewDisabled } from './disabled.js';
+import { emitSkewTrace } from './devtools.js';
+/** True when `value` looks like a {@link VersionedEnvelope}. */
+export function isEnvelope(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.v === 'number' &&
+        'payload' in value);
+}
+/**
+ * Reads the version off raw data without migrating it.
+ * Returns `null` for data that carries no envelope.
+ */
+export function peekVersion(raw) {
+    return isEnvelope(raw) ? raw.v : null;
+}
+/**
+ * Begins a versioned schema declaration.
+ *
+ * @param name Stable identifier, used in diagnostics and by storage keys.
+ * @typeParam TBase The shape at version 1 — for an existing codebase, this is
+ *                  your *current* shape, so adoption requires no backfill.
+ */
+export function versioned(name, options = {}) {
+    return build(name, [], options);
+}
+/**
+ * Constructs a schema from an explicit step list — the loader's entry point,
+ * used by tooling that assembles steps from a contract document rather than
+ * declaring them fluently.
+ *
+ * The list is indexed by target version (`steps[0]` migrates to v2) and MAY
+ * contain holes: a hole is a transition this build knows *of* but cannot
+ * *run* — a contract's named code step whose implementation this bundle does
+ * not carry. Reads that need a missing step fail with `gap` (or fall back to
+ * a registry contribution), which is the loud degradation the contract format
+ * promises. Application code should prefer {@link versioned}.
+ */
+export function versionedFromSteps(name, steps, options = {}) {
+    return build(name, steps, options);
+}
+function build(name, steps, options) {
+    var _a, _b;
+    const base = (_a = options.base) !== null && _a !== void 0 ? _a : 1;
+    if (!Number.isInteger(base) || base < 1) {
+        throw new TypeError(`[${name}] base must be a positive integer, got ${base}`);
+    }
+    const version = base + steps.length;
+    const legacyVersion = (_b = options.assumeLegacyVersion) !== null && _b !== void 0 ? _b : 1;
+    let fingerprint = null;
+    /** Steps below the base were retired; the local chain starts above it. */
+    const localStep = (to) => to > base ? steps[to - base - 1] : undefined;
+    /** Local chain first; the shared registry covers what this build lacks. */
+    const stepFor = (to) => { var _a; return (_a = localStep(to)) !== null && _a !== void 0 ? _a : registryStep(name, to); };
+    const schema = {
+        name,
+        version,
+        steps,
+        get fingerprint() {
+            return (fingerprint !== null && fingerprint !== void 0 ? fingerprint : (fingerprint = chainFingerprint(name, version, steps)));
+        },
+        write(value, buildIdOrOptions) {
+            var _a, _b;
+            const opts = typeof buildIdOrOptions === 'string' || buildIdOrOptions === undefined
+                ? { buildId: buildIdOrOptions }
+                : buildIdOrOptions;
+            const target = (_a = opts.as) !== null && _a !== void 0 ? _a : version;
+            const ctx = (_b = opts.context) !== null && _b !== void 0 ? _b : defaultMigrationContext;
+            if (!Number.isInteger(target) || target < 1 || target > version) {
+                throw new TypeError(`[${name}] cannot write at v${target}: this build knows v${base} through v${version}`);
+            }
+            if (target < base) {
+                throw new TypeError(`[${name}] cannot write at v${target}: versions below v${base} are retired — ` +
+                    `this build's chain starts at its base, v${base}`);
+            }
+            let payload = value;
+            for (let from = version; from > target; from--) {
+                const step = localStep(from);
+                if (!(step === null || step === void 0 ? void 0 : step.down)) {
+                    throw new TypeError(`[${name}] cannot write at v${target}: step v${from - 1} → v${from}` +
+                        (step
+                            ? ` ("${step.description}") declares no down-migration`
+                            : ' is missing'));
+                }
+                payload = step.down(payload, ctx);
+            }
+            const envelope = {
+                v: target,
+                n: name,
+                payload,
+            };
+            if (opts.buildId !== undefined)
+                envelope.b = opts.buildId;
+            emitSkewTrace({
+                kind: 'write',
+                schema: name,
+                from: version,
+                to: target,
+                ok: true,
+                ts: Date.now(),
+            });
+            return envelope;
+        },
+        read(raw, readOptions = {}) {
+            var _a;
+            const result = readImpl(raw, readOptions);
+            emitSkewTrace(Object.assign(Object.assign({ kind: 'read', schema: name, from: isEnvelope(raw)
+                    ? raw.v
+                    : ((_a = readOptions.assumeVersion) !== null && _a !== void 0 ? _a : legacyVersion), to: version, ok: result.ok }, (result.ok
+                ? {
+                    migratedFrom: result.migratedFrom,
+                    downgradedFrom: result.downgradedFrom,
+                    derivedPaths: result.derivedPaths,
+                    lossyPaths: result.lossyPaths,
+                }
+                : { reason: result.reason })), { ts: Date.now() }));
+            return result;
+        },
+        next(description, migrateOrSpec) {
+            var _a;
+            if (typeof description !== 'string' || description.length === 0) {
+                throw new TypeError(`[${name}] next() requires a description — it is the step's identity, ` +
+                    `and the only thing two independent builds can compare a code step by`);
+            }
+            let step;
+            if (typeof migrateOrSpec === 'function') {
+                step = {
+                    to: version + 1,
+                    description,
+                    up: migrateOrSpec,
+                };
+            }
+            else if (migrateOrSpec !== null &&
+                typeof migrateOrSpec === 'object' &&
+                'ops' in migrateOrSpec) {
+                const lens = compileLens(migrateOrSpec.ops);
+                step = {
+                    to: version + 1,
+                    description,
+                    up: lens.up,
+                    down: (_a = lens.down) !== null && _a !== void 0 ? _a : undefined,
+                    derives: lens.derivedUp,
+                    downDerives: lens.derivedDown,
+                    lossy: lens.lossyDown,
+                    ops: migrateOrSpec.ops,
+                };
+            }
+            else if (migrateOrSpec !== null &&
+                typeof migrateOrSpec === 'object' &&
+                typeof migrateOrSpec.up === 'function') {
+                const spec = migrateOrSpec;
+                step = {
+                    to: version + 1,
+                    description,
+                    up: spec.up,
+                    down: spec.down,
+                    derives: spec.derives,
+                    downDerives: spec.downDerives,
+                    lossy: spec.lossy,
+                };
+            }
+            else {
+                throw new TypeError(`[${name}] next() requires a migration function, a { up, down? } spec, or { ops }`);
+            }
+            return build(name, [...steps, step], options);
+        },
+    };
+    function readImpl(raw, readOptions) {
+        var _a, _b;
+        // Not public API — see `disabled.ts`. Reproduces `raw as TCurrent`: no
+        // envelope check, no version comparison, no migration. Data from a newer
+        // build is handed back as though it were current, which is precisely the
+        // failure this function exists to prevent.
+        if (isSkewDisabled())
+            return ok(raw);
+        if (raw === null || raw === undefined) {
+            return err('invalid', 0, version, `[${name}] no data to read`);
+        }
+        const ctx = (_a = readOptions.context) !== null && _a !== void 0 ? _a : defaultMigrationContext;
+        const enveloped = isEnvelope(raw);
+        const found = enveloped
+            ? raw.v
+            : ((_b = readOptions.assumeVersion) !== null && _b !== void 0 ? _b : legacyVersion);
+        let data = enveloped ? raw.payload : raw;
+        if (enveloped && typeof raw.n === 'string' && raw.n !== name) {
+            return err('invalid', found, version, `[${name}] envelope belongs to contract "${raw.n}", not "${name}" — ` +
+                `reading it through this schema would migrate the wrong data`);
+        }
+        if (!Number.isInteger(found) || found < 1) {
+            return err('invalid', found, version, `[${name}] envelope carries a non-version: ${found}`);
+        }
+        const derivedPaths = [];
+        const lossyPaths = [];
+        if (found > version) {
+            // Data from the future. It can still be read *if* every intervening
+            // step is known — locally or via the shared registry — and declares a
+            // down-migration; the result is an honest, lossy projection. When any
+            // step is missing or one-way, refuse exactly as before: guessing
+            // would discard data silently.
+            const descending = [];
+            for (let to = version + 1; to <= found; to++) {
+                const step = stepFor(to);
+                if (!(step === null || step === void 0 ? void 0 : step.down)) {
+                    return err('ahead', found, version, `[${name}] data was written by a newer build (v${found}) than this one (v${version})` +
+                        (step
+                            ? `, and step v${to - 1} → v${to} ("${step.description}") declares no down-migration. `
+                            : `, and no loaded bundle or resolved contract knows the v${to - 1} → v${to} step. `) +
+                        `Refetch, resolve the contract, or update the client — guessing would discard data.`);
+                }
+                descending.push(step);
+            }
+            for (let i = descending.length - 1; i >= 0; i--) {
+                const step = descending[i];
+                try {
+                    data = step.down(data, ctx);
+                }
+                catch (cause) {
+                    return err('threw', found, version, `[${name}] down-migration from v${step.to} ("${step.description}") failed`, cause);
+                }
+                if (step.lossy)
+                    lossyPaths.push(...step.lossy);
+                if (step.downDerives)
+                    derivedPaths.push(...step.downDerives);
+            }
+        }
+        if (found < version) {
+            for (let target = found + 1; target <= version; target++) {
+                const step = stepFor(target);
+                if (!step) {
+                    if (found < base) {
+                        // Below the declared floor, and nothing on the page supplies the
+                        // missing step. Unlike `gap` this is not a bug: the steps were
+                        // deliberately retired (see VersionedOptions.base). Distinct
+                        // reason, distinct remedy — discard/refetch/reset, not "report".
+                        return {
+                            ok: false,
+                            reason: 'retired',
+                            found,
+                            expected: version,
+                            floor: base,
+                            message: `[${name}] data at v${found} is below this build's retired floor (v${base}), ` +
+                                `and no loaded bundle or resolved contract supplies the v${target - 1} → v${target} step. ` +
+                                `This is a cleanup-policy outcome, not a bug: discard and refetch, or offer a reset.`,
+                        };
+                    }
+                    return err('gap', found, version, `[${name}] no migration declared for v${target - 1} → v${target}`);
+                }
+                try {
+                    data = step.up(data, ctx);
+                }
+                catch (cause) {
+                    return err('threw', found, version, `[${name}] migration to v${target} ("${step.description}") failed`, cause);
+                }
+                if (step.derives)
+                    derivedPaths.push(...step.derives);
+            }
+        }
+        if (options.validate && !options.validate(data)) {
+            return err('invalid', found, version, `[${name}] value failed validation after migrating v${found} → v${version}`);
+        }
+        return ok(data, {
+            migratedFrom: found < version ? found : null,
+            downgradedFrom: found > version ? found : null,
+            derivedPaths,
+            lossyPaths,
+        });
+    }
+    return schema;
+}
+//# sourceMappingURL=versioned.js.map

package/src/lib/versioned.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioned.js","sourceRoot":"","sources":["../../../../../libs/skew/src/lib/versioned.ts"],"names":[],"mappings":"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"}