@abloatai/transaction 0.37.0

package/dist/schema/diff.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Computes the migration plan that turns one schema into another. Given two
+ * serialized schemas — the one currently active and the one being pushed — it
+ * produces an ordered list of {@link MigrationStep}s describing how to evolve the
+ * database, and a {@link MigrationClassification} that separates the risky parts
+ * into warnings (they run, but may lose or risk data on a non-empty table) and
+ * unexecutable steps (they fail on a non-empty table unless a backfill or default
+ * is supplied). This module only plans: it has no database dependency and emits no
+ * SQL, so it can be unit-tested exhaustively and reused by the command-line tools.
+ * Turning a step into SQL and running it happens in the host implementation, which
+ * owns the column-type mapping and row-security rules.
+ *
+ * A few design choices worth knowing about:
+ *  - Renames are supplied as data through {@link RenameHints}, not guessed. Without
+ *    a hint, a removed field plus an added field reads as a drop followed by an add,
+ *    which is the safe (lossy) default; a hint tells the planner they are the same
+ *    field under a new name.
+ *  - Destructive changes fall into two tiers — warnings versus unexecutable — and a
+ *    type change carries its own sub-tier ({@link CastSafety}: safe, risky, or not
+ *    castable) that decides between an in-place `ALTER COLUMN … TYPE` and a lossy
+ *    drop-and-recreate.
+ *  - A single {@link FieldChanges} value records which facets of a column changed
+ *    (type, nullability, enum values, index) so one `alter_field` step covers them
+ *    all instead of several separate steps.
+ *
+ * Steps come back in expand-then-contract order — add before drop, widen before
+ * narrow: create models, rename, add columns (always nullable), alter, drop columns,
+ * drop models. A newly added column is never created `NOT NULL`; making a column
+ * required is a separate nullability change that a backfill must run before.
+ */
+import type { FieldMeta } from './field.js';
+import type { SchemaJSON } from './serialize.js';
+export type FieldType = FieldMeta['type'];
+/** Whether a Postgres `ALTER COLUMN … TYPE` can preserve the existing data. */
+export type CastSafety = 'safe' | 'risky' | 'notCastable';
+/** Records a column's type change and how safely Postgres can carry it out. */
+export interface FieldTypeChange {
+    readonly from: FieldType;
+    readonly to: FieldType;
+    /** How the type change is carried out: `safe` runs a plain `ALTER COLUMN … TYPE`;
+     *  `risky` runs one with a `USING` cast that may fail on some rows; `notCastable`
+     *  drops and recreates the column, losing its data. */
+    readonly cast: CastSafety;
+}
+/** Records a change to whether a field is optional. Going from optional to required
+ *  (`true → false`) is the dangerous direction: it fails if any existing row holds
+ *  a null. */
+export interface NullabilityChange {
+    readonly fromOptional: boolean;
+    readonly toOptional: boolean;
+}
+/** Records which allowed values an enum field gained and lost. Removing a value is
+ *  the risky part — existing rows still holding it violate the new constraint. */
+export interface EnumValuesChange {
+    readonly added: readonly string[];
+    readonly removed: readonly string[];
+}
+/** Records a change to whether a field is indexed (`from` was, `to` will be). */
+export interface IndexChange {
+    readonly from: boolean;
+    readonly to: boolean;
+}
+/** Records a change to the physical database column name backing a field whose
+ *  logical name stayed the same. */
+export interface FieldColumnChange {
+    readonly from: string;
+    readonly to: string;
+}
+/** The set of facets of a single column that changed. Each optional member is
+ *  present only when that facet actually changed, so one `alter_field` step can
+ *  describe several simultaneous changes to the same column. */
+export interface FieldChanges {
+    readonly column?: FieldColumnChange;
+    readonly type?: FieldTypeChange;
+    readonly nullability?: NullabilityChange;
+    readonly enumValues?: EnumValuesChange;
+    readonly indexed?: IndexChange;
+}
+/** One step in a migration plan. The `kind` tag names the operation and the
+ *  remaining fields carry its target and payload. {@link diffSchema} emits these in
+ *  expand-then-contract order, and the host implementation lowers each to SQL. */
+export type MigrationStep = {
+    readonly kind: 'create_model';
+    readonly model: string;
+    readonly tableName: string;
+} | {
+    readonly kind: 'drop_model';
+    readonly model: string;
+    readonly tableName: string;
+} | {
+    readonly kind: 'rename_model';
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly kind: 'add_field';
+    readonly model: string;
+    readonly field: string;
+    readonly meta: FieldMeta;
+} | {
+    readonly kind: 'drop_field';
+    readonly model: string;
+    readonly field: string;
+} | {
+    readonly kind: 'rename_field';
+    readonly model: string;
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly kind: 'alter_field';
+    readonly model: string;
+    readonly field: string;
+    readonly changes: FieldChanges;
+};
+/**
+ * Tells {@link diffSchema} which removed-and-added pairs are really renames. Supply
+ * these as data because the planner cannot safely guess: without a hint, a field
+ * that disappears and a field that appears read as a drop followed by an add, which
+ * loses the column's data. Each field rename names its model by the model's key in
+ * the new schema, after any model rename has been applied.
+ */
+export interface RenameHints {
+    readonly models?: readonly {
+        readonly from: string;
+        readonly to: string;
+    }[];
+    readonly fields?: readonly {
+        readonly model: string;
+        readonly from: string;
+        readonly to: string;
+    }[];
+}
+/** Reports how safely a field's type can change from `from` to `to`. The same type
+ *  in and out is always safe; anything else is looked up in the cast-safety matrix
+ *  and defaults to `notCastable` when no entry exists. */
+export declare function classifyCast(from: FieldType, to: FieldType): CastSafety;
+/**
+ * Diff two serialized schemas into an ordered, expand→contract migration plan.
+ * `prev` is the active schema (`null` for a first push → all creates). Rename
+ * decisions are supplied via {@link RenameHints}; anything not hinted reads as
+ * drop+add.
+ */
+export declare function diffSchema(prev: SchemaJSON | null, next: SchemaJSON, hints?: RenameHints): MigrationStep[];
+/**
+ * Why a migration step is flagged as a warning — a change that runs but may lose or
+ * risk data on a non-empty table. Each code corresponds to one destructive step
+ * kind that {@link classifyMigration} recognizes.
+ */
+export type WarningCode = 'drop_model' | 'drop_field' | 'risky_cast' | 'lossy_recreate' | 'enum_value_removed'
+/** A model stops being served to readers even though no table is dropped. This is
+ *  raised when a push is accepted, not by {@link classifyMigration}, and the loss
+ *  is visibility, not data — the underlying rows are left untouched. */
+ | 'remove_model';
+/** Why a migration step is unexecutable — it fails on a non-empty table unless a
+ *  default or backfill is supplied. Both cases introduce a requirement that existing
+ *  rows might not satisfy. */
+export type BlockerCode = 'required_field_added' | 'made_required';
+/**
+ * One flagged change in a classified migration plan. {@link code} says what kind of
+ * risk it is, {@link model} and the optional {@link field} say where, and
+ * {@link detail} is a human-readable explanation suitable for showing to a
+ * developer.
+ */
+export interface MigrationSignal {
+    readonly code: WarningCode | BlockerCode;
+    readonly model: string;
+    readonly field?: string;
+    readonly detail: string;
+    /**
+     * Extra context for a removal signal: the previously active schema this push was
+     * compared against. Tools use it to show which baseline made the push look
+     * incompatible — its version and when it was pushed — so the warning is not a
+     * mystery.
+     */
+    readonly shadowed?: {
+        readonly environment: string;
+        readonly version: number;
+        /** ISO 8601 timestamp when the compared-against schema was pushed, or null. */
+        readonly pushedAt: string | null;
+        /** Who pushed the compared-against schema, or null. */
+        readonly pushedBy: string | null;
+    };
+}
+/** The result of classifying a migration plan: its flagged changes split by
+ *  severity. Produced by {@link classifyMigration} and read by
+ *  {@link isAutoApplicable} and {@link unresolvedBlockers}. */
+export interface MigrationClassification {
+    /** Changes that run but may lose or risk data on a non-empty table. */
+    readonly warnings: readonly MigrationSignal[];
+    /** Changes that fail on a non-empty table unless a default or backfill is supplied. */
+    readonly unexecutable: readonly MigrationSignal[];
+}
+/**
+ * Sorts a plan's steps into {@link MigrationClassification.warnings} and
+ * {@link MigrationClassification.unexecutable}. Because a step carries no per-field
+ * default, adding a required field is treated conservatively as unexecutable — the
+ * classifier cannot prove a default exists, so a backfill or default must resolve
+ * it. The classification is derived from the schema alone; whoever runs the plan can
+ * still downgrade a flagged step to a no-op once it finds the target table is empty.
+ */
+export declare function classifyMigration(steps: readonly MigrationStep[]): MigrationClassification;
+/** Whether a plan is safe to apply automatically — true when it has no unexecutable
+ *  steps. Warnings do not block auto-apply; only unexecutable steps do. */
+export declare function isAutoApplicable(classification: MigrationClassification): boolean;
+/**
+ * A constant value to write into existing rows so an otherwise-unexecutable step can
+ * run: a required field added to a non-empty table, or a field made required while
+ * some rows hold null. This is intentionally a single constant, not an SQL
+ * expression — it covers the common "new column defaults to X" case; anything more
+ * elaborate is out of scope.
+ */
+export interface BackfillValue {
+    readonly model: string;
+    readonly field: string;
+    readonly value: string | number | boolean;
+}
+/**
+ * Reports whether a supplied backfill resolves this blocker. Only the two
+ * row-dependent blockers — `required_field_added` and `made_required` — can be
+ * resolved with a backfill; a data-loss warning cannot, and must be accepted
+ * explicitly instead.
+ */
+export declare function isBlockerResolved(signal: MigrationSignal, backfills: readonly BackfillValue[]): boolean;
+/** The unexecutable signals that the supplied backfills do not cover. An empty
+ *  result means no blocker remains, though any warnings are still gated separately. */
+export declare function unresolvedBlockers(classification: MigrationClassification, backfills: readonly BackfillValue[]): readonly MigrationSignal[];
+//# sourceMappingURL=diff.d.ts.map

package/dist/schema/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/schema/diff.ts"],"names":[],"mappings":"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"}

package/dist/schema/diff.js

@@ -0,0 +1,290 @@
+/**
+ * Computes the migration plan that turns one schema into another. Given two
+ * serialized schemas — the one currently active and the one being pushed — it
+ * produces an ordered list of {@link MigrationStep}s describing how to evolve the
+ * database, and a {@link MigrationClassification} that separates the risky parts
+ * into warnings (they run, but may lose or risk data on a non-empty table) and
+ * unexecutable steps (they fail on a non-empty table unless a backfill or default
+ * is supplied). This module only plans: it has no database dependency and emits no
+ * SQL, so it can be unit-tested exhaustively and reused by the command-line tools.
+ * Turning a step into SQL and running it happens in the host implementation, which
+ * owns the column-type mapping and row-security rules.
+ *
+ * A few design choices worth knowing about:
+ *  - Renames are supplied as data through {@link RenameHints}, not guessed. Without
+ *    a hint, a removed field plus an added field reads as a drop followed by an add,
+ *    which is the safe (lossy) default; a hint tells the planner they are the same
+ *    field under a new name.
+ *  - Destructive changes fall into two tiers — warnings versus unexecutable — and a
+ *    type change carries its own sub-tier ({@link CastSafety}: safe, risky, or not
+ *    castable) that decides between an in-place `ALTER COLUMN … TYPE` and a lossy
+ *    drop-and-recreate.
+ *  - A single {@link FieldChanges} value records which facets of a column changed
+ *    (type, nullability, enum values, index) so one `alter_field` step covers them
+ *    all instead of several separate steps.
+ *
+ * Steps come back in expand-then-contract order — add before drop, widen before
+ * narrow: create models, rename, add columns (always nullable), alter, drop columns,
+ * drop models. A newly added column is never created `NOT NULL`; making a column
+ * required is a separate nullability change that a backfill must run before.
+ */
+// ── Cast safety matrix ────────────────────────────────────────────────────────
+// Keyed `${from}->${to}` over the 6 sync field types. Targets that map to TEXT
+// (`string`) accept any scalar losslessly; tightening into an `enum` adds a CHECK
+// that existing rows may violate (risky); narrowing into number/bool/date/json
+// is risky (USING cast can fail per-row) or impossible (notCastable).
+const CAST = {
+    // → string (TEXT): always safe
+    'number->string': 'safe', 'boolean->string': 'safe', 'date->string': 'safe',
+    'enum->string': 'safe', 'json->string': 'safe',
+    // → enum (TEXT + CHECK): constraint over existing data is risky
+    'string->enum': 'risky', 'number->enum': 'risky', 'boolean->enum': 'risky',
+    'date->enum': 'risky', 'json->enum': 'notCastable',
+    // → number (DOUBLE PRECISION)
+    'string->number': 'risky', 'enum->number': 'risky', 'boolean->number': 'notCastable',
+    'date->number': 'notCastable', 'json->number': 'notCastable',
+    // → boolean
+    'string->boolean': 'risky', 'enum->boolean': 'risky', 'number->boolean': 'risky',
+    'date->boolean': 'notCastable', 'json->boolean': 'notCastable',
+    // → date (TIMESTAMPTZ)
+    'string->date': 'risky', 'enum->date': 'risky', 'number->date': 'notCastable',
+    'boolean->date': 'notCastable', 'json->date': 'notCastable',
+    // → json (JSONB)
+    'string->json': 'risky', 'enum->json': 'risky', 'number->json': 'notCastable',
+    'boolean->json': 'notCastable', 'date->json': 'notCastable',
+};
+/** Reports how safely a field's type can change from `from` to `to`. The same type
+ *  in and out is always safe; anything else is looked up in the cast-safety matrix
+ *  and defaults to `notCastable` when no entry exists. */
+export function classifyCast(from, to) {
+    if (from === to)
+        return 'safe';
+    return CAST[`${from}->${to}`] ?? 'notCastable';
+}
+// ── Diff ──────────────────────────────────────────────────────────────────────
+function diffEnumValues(from, to) {
+    const a = new Set(from ?? []);
+    const b = new Set(to ?? []);
+    const added = [...b].filter((v) => !a.has(v));
+    const removed = [...a].filter((v) => !b.has(v));
+    if (added.length === 0 && removed.length === 0)
+        return undefined;
+    return { added, removed };
+}
+function camelToSnake(identifier) {
+    return identifier.replace(/[A-Z]/g, (ch) => `_${ch.toLowerCase()}`);
+}
+function columnNameOf(fieldName, meta) {
+    return meta.column ?? camelToSnake(fieldName);
+}
+function diffField(prevFieldName, nextFieldName, prev, next) {
+    const changes = {};
+    const prevColumn = columnNameOf(prevFieldName, prev);
+    const nextColumn = columnNameOf(nextFieldName, next);
+    if (prevColumn !== nextColumn) {
+        changes.column = { from: prevColumn, to: nextColumn };
+    }
+    if (prev.type !== next.type) {
+        changes.type = { from: prev.type, to: next.type, cast: classifyCast(prev.type, next.type) };
+    }
+    if (prev.isOptional !== next.isOptional) {
+        changes.nullability = { fromOptional: prev.isOptional, toOptional: next.isOptional };
+    }
+    // Enum value drift only matters while the field is (still) an enum; a type
+    // change away from enum is already captured by `type`.
+    if (prev.type === 'enum' && next.type === 'enum') {
+        const ev = diffEnumValues(prev.enumValues, next.enumValues);
+        if (ev)
+            changes.enumValues = ev;
+    }
+    if (prev.isIndexed !== next.isIndexed) {
+        changes.indexed = { from: prev.isIndexed, to: next.isIndexed };
+    }
+    return Object.keys(changes).length === 0 ? null : changes;
+}
+function tableNameOf(model, key) {
+    return model.tableName ?? key;
+}
+function diffModelFields(model, prev, next, fieldRenames) {
+    const steps = [];
+    const renameByNewName = new Map(fieldRenames.map((r) => [r.to, r.from]));
+    const renamedFromNames = new Set(fieldRenames.map((r) => r.from));
+    // Renames first (so subsequent alter steps reference the new name).
+    for (const { from, to } of fieldRenames) {
+        if (from in prev.fields && to in next.fields) {
+            steps.push({ kind: 'rename_field', model, from, to });
+        }
+    }
+    // Added (present in next, not in prev, and not the target of a rename).
+    for (const [name, meta] of Object.entries(next.fields)) {
+        if (name in prev.fields)
+            continue;
+        if (renameByNewName.has(name))
+            continue;
+        steps.push({ kind: 'add_field', model, field: name, meta });
+    }
+    // Altered: every field present in both (directly or via rename).
+    for (const [name, nextMeta] of Object.entries(next.fields)) {
+        const prevName = renameByNewName.get(name) ?? name;
+        const prevMeta = prev.fields[prevName];
+        if (!prevMeta)
+            continue;
+        const changes = diffField(prevName, name, prevMeta, nextMeta);
+        if (changes?.column && renameByNewName.has(name)) {
+            // A hinted logical field rename already emits `rename_field`, whose
+            // lowering renames the physical column when needed. Do not emit a
+            // second `alter_field.column` for the same transition.
+            delete changes.column;
+        }
+        if (changes && Object.keys(changes).length > 0) {
+            steps.push({ kind: 'alter_field', model, field: name, changes });
+        }
+    }
+    // Dropped (present in prev, not in next, and not renamed away).
+    for (const name of Object.keys(prev.fields)) {
+        if (name in next.fields)
+            continue;
+        if (renamedFromNames.has(name))
+            continue;
+        steps.push({ kind: 'drop_field', model, field: name });
+    }
+    return steps;
+}
+/**
+ * Diff two serialized schemas into an ordered, expand→contract migration plan.
+ * `prev` is the active schema (`null` for a first push → all creates). Rename
+ * decisions are supplied via {@link RenameHints}; anything not hinted reads as
+ * drop+add.
+ */
+export function diffSchema(prev, next, hints = {}) {
+    if (!prev) {
+        // First push: every model is created, with its fields carried in the
+        // create (no per-field add steps — the table is born with them).
+        return Object.entries(next.models).map(([model, def]) => ({
+            kind: 'create_model',
+            model,
+            tableName: tableNameOf(def, model),
+        }));
+    }
+    const modelRenames = hints.models ?? [];
+    const renameByNewModel = new Map(modelRenames.map((r) => [r.to, r.from]));
+    const renamedFromModels = new Set(modelRenames.map((r) => r.from));
+    const fieldHints = hints.fields ?? [];
+    const creates = [];
+    const renames = [];
+    const fieldSteps = [];
+    const drops = [];
+    // New + renamed models, and per-model field diffs.
+    for (const [model, nextDef] of Object.entries(next.models)) {
+        const prevModelKey = renameByNewModel.get(model) ?? model;
+        const prevDef = prev.models[prevModelKey];
+        if (!prevDef) {
+            creates.push({ kind: 'create_model', model, tableName: tableNameOf(nextDef, model) });
+            continue;
+        }
+        if (renameByNewModel.has(model)) {
+            renames.push({ kind: 'rename_model', from: prevModelKey, to: model });
+        }
+        const myFieldRenames = fieldHints
+            .filter((f) => f.model === model)
+            .map((f) => ({ from: f.from, to: f.to }));
+        fieldSteps.push(...diffModelFields(model, prevDef, nextDef, myFieldRenames));
+    }
+    // Dropped models (in prev, not in next, not renamed away).
+    for (const [model, prevDef] of Object.entries(prev.models)) {
+        if (model in next.models)
+            continue;
+        if (renamedFromModels.has(model))
+            continue;
+        drops.push({ kind: 'drop_model', model, tableName: tableNameOf(prevDef, model) });
+    }
+    // Expand → contract ordering. Within fieldSteps the per-model helper already
+    // emits rename → add → alter → drop_field, which preserves the same invariant.
+    return [...creates, ...renames, ...fieldSteps, ...drops];
+}
+/**
+ * Sorts a plan's steps into {@link MigrationClassification.warnings} and
+ * {@link MigrationClassification.unexecutable}. Because a step carries no per-field
+ * default, adding a required field is treated conservatively as unexecutable — the
+ * classifier cannot prove a default exists, so a backfill or default must resolve
+ * it. The classification is derived from the schema alone; whoever runs the plan can
+ * still downgrade a flagged step to a no-op once it finds the target table is empty.
+ */
+export function classifyMigration(steps) {
+    const warnings = [];
+    const unexecutable = [];
+    for (const step of steps) {
+        switch (step.kind) {
+            case 'drop_model':
+                warnings.push({ code: 'drop_model', model: step.model, detail: `drops table for "${step.model}" (data loss)` });
+                break;
+            case 'drop_field':
+                warnings.push({ code: 'drop_field', model: step.model, field: step.field, detail: `drops column "${step.field}" (data loss)` });
+                break;
+            case 'add_field':
+                if (!step.meta.isOptional) {
+                    unexecutable.push({
+                        code: 'required_field_added',
+                        model: step.model,
+                        field: step.field,
+                        detail: `adds required column "${step.field}" — needs a default or backfill on a non-empty table`,
+                    });
+                }
+                break;
+            case 'alter_field': {
+                const { changes } = step;
+                if (changes.nullability && changes.nullability.fromOptional && !changes.nullability.toOptional) {
+                    unexecutable.push({
+                        code: 'made_required',
+                        model: step.model,
+                        field: step.field,
+                        detail: `makes "${step.field}" required — fails if existing rows are NULL`,
+                    });
+                }
+                if (changes.type) {
+                    if (changes.type.cast === 'risky') {
+                        warnings.push({ code: 'risky_cast', model: step.model, field: step.field, detail: `${changes.type.from} → ${changes.type.to} may fail per-row` });
+                    }
+                    else if (changes.type.cast === 'notCastable') {
+                        warnings.push({ code: 'lossy_recreate', model: step.model, field: step.field, detail: `${changes.type.from} → ${changes.type.to} requires drop-and-recreate (data loss)` });
+                    }
+                }
+                if (changes.enumValues && changes.enumValues.removed.length > 0) {
+                    warnings.push({
+                        code: 'enum_value_removed',
+                        model: step.model,
+                        field: step.field,
+                        detail: `removes enum value(s) ${changes.enumValues.removed.join(', ')} — rows using them violate the new CHECK`,
+                    });
+                }
+                break;
+            }
+            // create_model, rename_model, rename_field, add optional field: non-destructive.
+            default:
+                break;
+        }
+    }
+    return { warnings, unexecutable };
+}
+/** Whether a plan is safe to apply automatically — true when it has no unexecutable
+ *  steps. Warnings do not block auto-apply; only unexecutable steps do. */
+export function isAutoApplicable(classification) {
+    return classification.unexecutable.length === 0;
+}
+/**
+ * Reports whether a supplied backfill resolves this blocker. Only the two
+ * row-dependent blockers — `required_field_added` and `made_required` — can be
+ * resolved with a backfill; a data-loss warning cannot, and must be accepted
+ * explicitly instead.
+ */
+export function isBlockerResolved(signal, backfills) {
+    if (signal.code !== 'required_field_added' && signal.code !== 'made_required')
+        return false;
+    return backfills.some((b) => b.model === signal.model && b.field === signal.field);
+}
+/** The unexecutable signals that the supplied backfills do not cover. An empty
+ *  result means no blocker remains, though any warnings are still gated separately. */
+export function unresolvedBlockers(classification, backfills) {
+    return classification.unexecutable.filter((s) => !isBlockerResolved(s, backfills));
+}
+//# sourceMappingURL=diff.js.map

package/dist/schema/diff.js.map

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