@zukhruf/sqlite-drift 0.0.0-stage → 0.3.31

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ezzabuzaid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,176 @@
-# Temporary Holding Version
+# @zukhruf/sqlite-drift
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A package keeps tables, indexes, views and triggers in a SQLite database. A later version of the package can declare them otherwise, for example with one more column. The database still stores the objects as the earlier version made them, and the new code fails on them, for example with `no such column`. This package compares the stored objects with their declaration, and makes the database store them as declared. No person keeps a version number. This is also known as declarative schema management, and the difference that it finds is known as schema drift.
+
+The words in these documents have one meaning each. See the glossary in [CONTEXT.md](./CONTEXT.md).
+
+## Use it
+
+This project is an experiment. It uses only `node:sqlite`.
+
+```sh
+npm install @zukhruf/sqlite-drift
+```
+
+```ts
+import { mkdtempDisposable } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+import { Declaration } from '@zukhruf/sqlite-drift';
+
+await using scratch = await mkdtempDisposable(join(tmpdir(), 'drift-'));
+using database = new DatabaseSync(join(scratch.path, 'app.sqlite'));
+// An earlier version made the table without failed_at.
+database.exec(`CREATE TABLE failures (directory TEXT PRIMARY KEY, error TEXT NOT NULL);
+  INSERT INTO failures VALUES ('/data/notes', 'denied')`);
+
+const failures = new Declaration(
+  [
+    'CREATE TABLE failures (directory TEXT PRIMARY KEY, error TEXT NOT NULL, failed_at TEXT NOT NULL)',
+  ],
+  { rows: 'replace' },
+);
+console.log(failures.drift(database));
+failures.apply(database);
+console.log(failures.drift(database));
+console.log(database.prepare('SELECT count(*) AS rows FROM failures').get());
+```
+
+Output:
+
+```
+stale
+fits
+[Object: null prototype] { rows: 0 }
+```
+
+## A declaration compares the text that SQLite stores
+
+- `new Declaration(statements, { rows })` makes the objects once in an empty database in memory, and keeps the text that SQLite stores for each one. [ADR 0001](./docs/adr/0001-compare-the-text-that-sqlite-stores.md) tells why.
+- `rows` is `'replace'` or `'keep'`. It tells `apply` what to do with the rows of a stale table. It has no default, so no caller loses rows because it forgot an option.
+- `drift(database)` gives `missing` when the database stores none of the objects, `fits` when it stores each one as declared, and `stale` for all other cases. It only reads, so it also works on a database opened read-only.
+- Each change to a CREATE statement is drift: a column, a type, a CHECK, STRICT, the query of a view.
+- A change of meaning with no change of text is not drift. When the meaning of a column changes, change its name too.
+- SQLite takes names that are different only in ASCII case as one name.
+
+## Apply makes the database store the declaration
+
+- `apply(database)` does nothing when the drift is `fits`.
+- When no stored object is stale, `apply` makes each missing object, and the other objects keep their rows.
+- With `rows: 'replace'`, when one stored object is stale, `apply` replaces every object of the declaration, and their rows are gone. [ADR 0002](./docs/adr/0002-a-stale-object-replaces-the-whole-declaration.md) tells why.
+- With `rows: 'keep'`, `apply` rebuilds each stale table and keeps its rows. See [Keep the rows](#keep-the-rows).
+- `apply` does not drop an object that the declaration does not name.
+- In a transaction of the caller, `apply` works in a savepoint, and a rollback of the caller removes its changes. With no transaction, `apply` writes in its own `BEGIN IMMEDIATE` transaction. [`@zukhruf/sqlite-transaction`](../transaction) does this work, so when SQLite ends the transaction itself, `apply` throws the original error.
+
+## Keep the rows
+
+With `rows: 'keep'`, `apply` keeps the rows of each stale table. It replaces a stale index, trigger or view, because these have no rows. It rebuilds each stale table, in the order of the declaration:
+
+1. It renames the stored table to a temporary name, with `PRAGMA legacy_alter_table` on. Thus the references of other tables, views and triggers stay on the name of the table.
+2. It makes the table from its declared text, so SQLite stores the declared text.
+3. It copies the columns that both tables have, by name. SQLite takes names that are different only in ASCII case as one name.
+4. It drops the old table, and makes again the indexes and triggers on the table that the declaration does not name.
+5. It runs `PRAGMA foreign_key_check`. When a kept row breaks a foreign key, `apply` fails.
+
+[ADR 0003](./docs/adr/0003-keep-rows-rebuilds-a-table-and-keeps-its-references.md) tells why.
+
+```ts
+import { mkdtempDisposable } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+import { Declaration } from '@zukhruf/sqlite-drift';
+
+await using scratch = await mkdtempDisposable(join(tmpdir(), 'drift-'));
+using database = new DatabaseSync(join(scratch.path, 'app.sqlite'));
+// An earlier version made runs without status. Cases refer to runs.
+database.exec(`CREATE TABLE runs (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
+  CREATE TABLE cases (run INTEGER NOT NULL REFERENCES runs (id) ON DELETE CASCADE);
+  INSERT INTO runs VALUES (1, 'nightly');
+  INSERT INTO cases VALUES (1)`);
+
+const runs = new Declaration(
+  [
+    "CREATE TABLE runs (id INTEGER PRIMARY KEY, name TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'done')",
+  ],
+  { rows: 'keep' },
+);
+console.log(runs.drift(database));
+runs.apply(database);
+console.log(runs.drift(database));
+console.log(database.prepare('SELECT * FROM runs').all());
+console.log(database.prepare('SELECT count(*) AS cases FROM cases').get());
+```
+
+Output:
+
+```
+stale
+fits
+[ [Object: null prototype] { id: 1, name: 'nightly', status: 'done' } ]
+[Object: null prototype] { cases: 1 }
+```
+
+- A column that only the declaration has gets its default.
+- A column that only the stored table has is discarded, with its values.
+- `apply` does not find a renamed column. A new name reads as one column dropped and one column added, so the values of the old column are discarded. To keep them, copy them yourself before `apply`.
+- `apply` does not fill values and does not remove rows. When a stored row does not fit the declaration (NOT NULL, CHECK, a foreign key, STRICT), `apply` fails with the error of SQLite, and the table and its rows stay as they were. To keep such rows, change them with your own SQL before `apply`.
+- When foreign keys are on and a table refers to a stale table (also the stale table to itself), `apply` must turn foreign keys off. SQLite ignores `PRAGMA foreign_keys` in a transaction. Thus `apply` turns foreign keys off before its own transaction, and on again after it. In a transaction of the caller, `apply` fails before it changes the database. Call `apply` outside a transaction, or turn foreign keys off before it.
+- When no table refers to the stale table, `apply` also works in a transaction of the caller, with foreign keys on.
+- After a rebuild, `PRAGMA legacy_alter_table` has its old value again, also when `apply` fails.
+
+## Write a declaration
+
+- List a table before the tables that refer to it.
+- A declaration must stand alone in an empty database. Do not declare a trigger or an index on a table that the declaration does not name, and do not use a function that only your connection registers.
+- With `rows: 'replace'`, give each table its own declaration when it must keep its rows while another table changes.
+
+## Errors
+
+| Error                                                                               | When                                                                                                                              |
+| ----------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| The error of SQLite                                                                 | `new Declaration` fails when a statement does not run in an empty database.                                                       |
+| `database is locked`                                                                | `apply` with no transaction waits for the busy timeout of the connection, then fails.                                             |
+| The error of a statement                                                            | `apply` fails, and the database stays as it was.                                                                                  |
+| `Keeping the rows of a table that other tables reference needs foreign keys off, …` | `rows: 'keep'`, in a transaction of the caller, with foreign keys on, and another table refers to a stale table. Nothing changes. |
+| The error of SQLite, for example `NOT NULL constraint failed: runs.name`            | `rows: 'keep'`, and a stored row does not fit the declared table. The table and its rows stay as they were.                       |
+| `The kept rows break a foreign key: …`                                              | `rows: 'keep'`, and `PRAGMA foreign_key_check` finds a kept row that refers to no row. The database stays as it was.              |
+
+## The same concepts in other systems
+
+| System                               | What it does                                                                                                                                                                                                                                                          |
+| ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Röthlisberger's SQLite migrator      | It makes the declaration in memory and compares `sqlite_schema`. It changes a stale table with the 12 steps of SQLite and keeps the rows.                                                                                                                             |
+| SQLite's 12 steps                    | "Making Other Kinds Of Table Schema Changes" in [the ALTER TABLE page](https://www.sqlite.org/lang_altertable.html): make a new table, copy the rows, drop the old table, rename the new one. `rows: 'keep'` renames the old table first instead. ADR 0003 tells why. |
+| sqlite-utils `table.transform()`     | It rebuilds a table with the 12 steps and keeps the rows. A caller gives a map of renamed columns. `rows: 'keep'` has no such map.                                                                                                                                    |
+| Airbyte destinations                 | Each sync compares the final table with the stream (`existingSchemaMatchesStreamConfig`), and a soft reset makes a stale table again.                                                                                                                                 |
+| Drizzle Kit `push`, Prisma `db push` | They compare a declaration in TypeScript or in the Prisma language with the database, and change the database.                                                                                                                                                        |
+| Android Room                         | It keeps a version number for migrations, and a hash of the declaration that finds a number that a person forgot to raise.                                                                                                                                            |
+| Kubernetes controllers               | Each loop compares the desired state with the state that exists, and changes what is different.                                                                                                                                                                       |
+
+## Documentation
+
+- [0001 Compare the text that SQLite stores](./docs/adr/0001-compare-the-text-that-sqlite-stores.md)
+- [0002 A stale object replaces the whole declaration](./docs/adr/0002-a-stale-object-replaces-the-whole-declaration.md)
+- [0003 Keep rows rebuilds a table and keeps its references](./docs/adr/0003-keep-rows-rebuilds-a-table-and-keeps-its-references.md)
+
+## Development
+
+This package is part of the [zukhruf](../../../README.md) workspace. Run the commands from the workspace root.
+
+```sh
+npm install
+npx nx run sqlite-drift:test        # builds, then runs the tests in src/
+npx nx run sqlite-drift:typecheck   # formats, lints, then type checks
+npx nx run sqlite-drift:build       # compiles src/ to dist/
+```
+
+```
+src/
+  index.ts               the exports
+  declaration.ts         Declaration and Drift
+  declaration.test.ts    the tests, on real SQLite files
+```

package/dist/declaration.d.ts

@@ -0,0 +1,12 @@
+import { DatabaseSync } from 'node:sqlite';
+export type Drift = 'missing' | 'stale' | 'fits';
+export type Rows = 'replace' | 'keep';
+export declare class Declaration {
+    #private;
+    constructor(statements: readonly string[], options: {
+        readonly rows: Rows;
+    });
+    drift(database: DatabaseSync): Drift;
+    apply(database: DatabaseSync): void;
+}
+//# sourceMappingURL=declaration.d.ts.map

package/dist/declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaration.d.ts","sourceRoot":"","sources":["../src/declaration.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAM3C,MAAM,MAAM,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;AAIjD,MAAM,MAAM,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC;AAgBtC,qBAAa,WAAW;;gBAIV,UAAU,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;KAAE;IAgB3E,KAAK,CAAC,QAAQ,EAAE,YAAY,GAAG,KAAK;IAkBpC,KAAK,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;CAuHpC"}

package/dist/declaration.js

@@ -0,0 +1,169 @@
+import { randomUUID } from 'node:crypto';
+import { DatabaseSync } from 'node:sqlite';
+import { transaction } from '@zukhruf/sqlite-transaction';
+// The tables, indexes, views and triggers a caller owns in a SQLite database,
+// by the CREATE statements that make them. SQLite keeps the text of each
+// CREATE in sqlite_schema. A declaration makes its objects once in an empty
+// database in memory, so the declared text and the stored text both come from
+// SQLite, and they compare as they are.
+export class Declaration {
+    #objects;
+    #rows;
+    constructor(statements, options) {
+        using blank = new DatabaseSync(':memory:');
+        for (const statement of statements)
+            blank.exec(statement);
+        this.#objects = blank
+            .prepare('SELECT "type", "name", "sql" FROM sqlite_schema WHERE "sql" IS NOT NULL ORDER BY rowid')
+            .all()
+            .map(({ type, name, sql }) => ({
+            type: String(type),
+            name: String(name),
+            sql: String(sql),
+        }));
+        this.#rows = options.rows;
+    }
+    drift(database) {
+        const pairs = this.#objects.map((object) => ({
+            object,
+            found: stored(database, object.name),
+        }));
+        if (pairs.every(({ found }) => found === undefined))
+            return 'missing';
+        return pairs.every(({ object, found }) => found?.sql === object.sql)
+            ? 'fits'
+            : 'stale';
+    }
+    // Creates the objects the database does not store. When any stored object
+    // differs from its declaration, rows 'replace' replaces every object of the
+    // declaration, with its rows: a table can refer to another, and SQLite drops
+    // a table only after nothing refers to its rows. Rows 'keep' makes each stale
+    // object again, and moves the rows of a stale table into the new one (ADR
+    // 0003). Works inside the caller's transaction, or in a write of its own.
+    // Objects the declaration does not name stay.
+    apply(database) {
+        if (this.drift(database) === 'fits')
+            return;
+        // SQLite ignores PRAGMA foreign_keys in a transaction. With foreign keys
+        // on, the rename of a referenced table changes the references to the old
+        // table, and its drop then deletes the rows that refer to it.
+        const unchecked = this.#rows === 'keep' &&
+            Number(database.prepare('PRAGMA foreign_keys').get()?.foreign_keys) ===
+                1 &&
+            this.#stale(database).some(({ object, found }) => object.type === 'table' &&
+                found.type === 'table' &&
+                referenced(database, found.name));
+        if (unchecked) {
+            if (database.isTransaction)
+                throw new Error('Keeping the rows of a table that other tables reference needs foreign keys off, which SQLite cannot change inside a transaction. Call apply outside a transaction, or turn foreign keys off before it.');
+            database.exec('PRAGMA foreign_keys = OFF');
+        }
+        try {
+            transaction(database, () => {
+                const stale = this.#stale(database);
+                if (this.#rows === 'keep')
+                    this.#keep(database, stale);
+                else if (stale.length > 0)
+                    for (const object of this.#objects.toReversed()) {
+                        const found = stored(database, object.name);
+                        if (found !== undefined)
+                            drop(database, found);
+                    }
+                for (const object of this.#objects)
+                    if (stored(database, object.name) === undefined)
+                        database.exec(object.sql);
+            }, { mode: 'immediate' });
+        }
+        finally {
+            if (unchecked)
+                database.exec('PRAGMA foreign_keys = ON');
+        }
+    }
+    #stale(database) {
+        return this.#objects.flatMap((object) => {
+            const found = stored(database, object.name);
+            return found !== undefined && found.sql !== object.sql
+                ? [{ object, found }]
+                : [];
+        });
+    }
+    // Drops each stale index, trigger and view, and rebuilds each stale table.
+    // SQLite keeps PRAGMA legacy_alter_table after a rollback, so the old value
+    // comes back in any case.
+    #keep(database, stale) {
+        const tables = stale.filter(({ object, found }) => object.type === 'table' && found.type === 'table');
+        for (const entry of stale)
+            if (!tables.includes(entry))
+                drop(database, entry.found);
+        if (tables.length === 0)
+            return;
+        const legacy = Number(database.prepare('PRAGMA legacy_alter_table').get()?.legacy_alter_table);
+        database.exec('PRAGMA legacy_alter_table = ON');
+        try {
+            for (const { object, found } of tables)
+                this.#rebuild(database, object, found);
+        }
+        finally {
+            database.exec(`PRAGMA legacy_alter_table = ${legacy}`);
+        }
+        const broken = database.prepare('PRAGMA foreign_key_check').get();
+        if (broken !== undefined)
+            throw new Error(`The kept rows break a foreign key: row ${String(broken.rowid)} of ${String(broken.table)} refers to a row of ${String(broken.parent)} that does not exist.`);
+    }
+    // Renames the stored table away, makes it from its declared text, and copies
+    // the columns that both have, by name. With legacy_alter_table on, the
+    // rename leaves the references of other tables, views and triggers to the
+    // name. A column only the declaration has gets its default, and a column
+    // only the stored table has is discarded. The indexes and triggers on the
+    // table go with the old table, so those the declaration does not name are
+    // made again here, and the others when apply makes the missing objects.
+    #rebuild(database, object, found) {
+        const declared = new Set(this.#objects.map(({ name }) => name.toLowerCase()));
+        const undeclared = database
+            .prepare(`SELECT "name", "sql" FROM sqlite_schema WHERE lower("tbl_name") = lower(?) AND "type" IN ('index', 'trigger') AND "sql" IS NOT NULL`)
+            .all(found.name)
+            .filter(({ name }) => !declared.has(String(name).toLowerCase()))
+            .map(({ sql }) => String(sql));
+        const old = `${found.name}_${randomUUID().replaceAll('-', '')}`;
+        database.exec(`ALTER TABLE ${quote(found.name)} RENAME TO ${quote(old)}`);
+        database.exec(object.sql);
+        const columns = new Set(names(database, object.name).map((name) => name.toLowerCase()));
+        const shared = names(database, old)
+            .filter((name) => columns.has(name.toLowerCase()))
+            .map(quote)
+            .join(', ');
+        if (shared !== '')
+            database.exec(`INSERT INTO ${quote(object.name)} (${shared}) SELECT ${shared} FROM ${quote(old)}`);
+        database.exec(`DROP TABLE ${quote(old)}`);
+        for (const sql of undeclared)
+            database.exec(sql);
+    }
+}
+// SQLite takes names that differ only in ASCII case for one object.
+function stored(database, name) {
+    const row = database
+        .prepare('SELECT "type", "name", "sql" FROM sqlite_schema WHERE lower("name") = lower(?)')
+        .get(name);
+    return row === undefined
+        ? undefined
+        : { type: String(row.type), name: String(row.name), sql: String(row.sql) };
+}
+function quote(name) {
+    return `"${name.replaceAll('"', '""')}"`;
+}
+function drop(database, object) {
+    database.exec(`DROP ${object.type.toUpperCase()} ${quote(object.name)}`);
+}
+function names(database, table) {
+    return database
+        .prepare('SELECT "name" FROM pragma_table_info(?)')
+        .all(table)
+        .map(({ name }) => String(name));
+}
+// Whether a table, the same one too, has a foreign key to the table.
+function referenced(database, table) {
+    return (database
+        .prepare(`SELECT 1 FROM sqlite_schema AS "s", pragma_foreign_key_list("s"."name") AS "f" WHERE "s"."type" = 'table' AND lower("f"."table") = lower(?)`)
+        .get(table) !== undefined);
+}
+//# sourceMappingURL=declaration.js.map

package/dist/declaration.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { Declaration, type Drift, type Rows } from './declaration.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,KAAK,EAAE,KAAK,IAAI,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Declaration } from "./declaration.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAyB,MAAM,kBAAkB,CAAC"}

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@zukhruf/sqlite-drift",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.31",
+  "description": "Declarative schema management for SQLite. A declaration lists the CREATE statements of the tables, indexes, views and triggers that one caller owns. The package compares them with the text that SQLite stores, gives the drift (missing, fits or stale), and makes the database store each object as declared. No person keeps a version number.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JanuaryLabs/zukhruf",
+    "directory": "packages/sqlite/drift"
+  },
+  "bugs": {
+    "url": "https://github.com/JanuaryLabs/zukhruf/issues"
+  },
+  "homepage": "https://github.com/JanuaryLabs/zukhruf/tree/main/packages/sqlite/drift#readme",
+  "keywords": [
+    "sqlite",
+    "node-sqlite",
+    "schema",
+    "schema-drift",
+    "declarative-schema",
+    "migration",
+    "sqlite-schema",
+    "ddl"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@zukhruf/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/spec/**",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@zukhruf/sqlite-transaction": "^0.3.31"
+  }
+}