@eltjs/elt-sqlite 0.0.0-stage → 0.1.1

package/dist/sqlite-writer.js

@@ -0,0 +1,483 @@
+import { createHash } from 'node:crypto';
+import { Declaration } from '@zukhruf/sqlite-drift';
+import { transaction } from '@zukhruf/sqlite-transaction';
+import { FileContent, TargetOwnedError, Writer, describeTarget, errorMessage, reloadMode, } from '@eltjs/elt';
+import { openDestination } from './open-destination.js';
+import { describe } from './sqlite-descriptions.js';
+import { SQLiteFileStore } from './sqlite-file-store.js';
+import { identifiers } from './sqlite-identifiers.js';
+const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+const writersTable = new Declaration([
+    'CREATE TABLE "_elt_writers" ("target" TEXT PRIMARY KEY, "writer" TEXT NOT NULL) STRICT',
+], { rows: 'replace' });
+export const seq = '"_elt_seq"';
+export const op = '"_elt_op"';
+// One stream's load. Operations, and the chunks of their files, wait in
+// connection-private TEMP tables, so another stream's commit never publishes
+// them and a crash leaves nothing behind. As in Postgres, no transaction stays
+// open between commits: prepare only refuses and stages, and each commit is
+// one transaction that merges the stage with the result of applying its
+// operations one at a time, the first also creating the target.
+export class SQLiteWriter extends Writer {
+    configuration;
+    path;
+    table;
+    #description;
+    constructor(configuration, path, table) {
+        super(configuration.stream);
+        this.configuration = configuration;
+        this.path = path;
+        this.table = table;
+        this.#description = describeTarget(configuration, table.columns, (column) => `Integer reference to the source file's original bytes. Join ${quote(SQLiteFileStore.tableName(table, column))} on file = this value and concatenate bytes in order of n. NULL when the source file is unavailable.`);
+        if (table.readerView === undefined)
+            return;
+        const { missing } = this.#description;
+        if (missing.length > 0)
+            throw new TypeError(`Reader view ${table.readerView} needs JSON Schema descriptions for ${missing.join(', ')} of stream ${this.stream.name}`);
+    }
+    // What the target needs at its first commit, before its first merge.
+    // replacing: that commit replaces the target, so its rows are moot. A mode
+    // without a key releases the index a deduplicating mode made.
+    initialize(database, _replacing) {
+        this.dropDedupIndexes(database, null);
+    }
+    // Drops the deduplication indexes this library made on the target, except
+    // kept.
+    dropDedupIndexes(database, kept) {
+        for (const { name } of database
+            .prepare(String.raw `SELECT "name" FROM sqlite_schema WHERE "type" = 'index' AND "tbl_name" = ? AND "name" LIKE '\_elt\_dedup\_%' ESCAPE '\'`)
+            .all(this.table.name))
+            if (name !== kept)
+                database.exec(`DROP INDEX ${quote(String(name))}`);
+    }
+    // Refuses, before anything is read, stored rows the load cannot keep.
+    inspect(_database) { }
+    // What a reload's hidden target needs once it is created, before the first
+    // merge fills it, and once it takes the target's name.
+    build(_database, _into) { }
+    adopt(_database) { }
+    // Inserts each staged record, in order.
+    append(database, stage, loadedAt, into) {
+        database
+            .prepare(`INSERT INTO ${into} (${this.fields.join(', ')}) SELECT ${this.table.columns.map((column) => column.quotedName).join(', ')}, ? FROM ${stage} WHERE ${op} = 'R' ORDER BY ${seq}`)
+            .run(loadedAt);
+    }
+    // An overwrite replaces the target at its first commit.
+    get replaces() {
+        return false;
+    }
+    // Empties the target a replacing commit is about to fill.
+    replace(database) {
+        database.exec(`DELETE FROM ${this.table.quotedName}`);
+    }
+    get hash() {
+        return createHash('sha256').update(this.table.location).digest('hex');
+    }
+    get fields() {
+        return [
+            ...this.table.columns.map((column) => column.quotedName),
+            '"loaded_at"',
+        ];
+    }
+    encode(record) {
+        return this.table.columns.map((column) => column.encode(record));
+    }
+    // Only a load that identifies rows by key can remove one.
+    deletionKeys(_key) {
+        throw new TypeError('Only deduplicating loads can apply deletions');
+    }
+    // The owner lives beside the table it guards. A dropped table releases it,
+    // since nothing it held remains, and so does a table of owners another
+    // version declared otherwise, which is replaced empty.
+    writers(database) {
+        writersTable.apply(database);
+    }
+    // Refuses, before anything is read, a target another writer owns.
+    #refuse(database, writer) {
+        if (!this.exists(database, '_elt_writers'))
+            return;
+        const owner = database
+            .prepare(`SELECT "writer" FROM "_elt_writers" WHERE "target" = ? AND "target" IN (SELECT lower("name") FROM sqlite_schema WHERE "type" = 'table')`)
+            .get(this.table.location)?.writer;
+        if (owner !== undefined && owner !== writer)
+            throw new TargetOwnedError(this.table.name, String(owner), writer);
+    }
+    // Records the owner with the target's first commit; prepare refused any
+    // other.
+    own(database, writer) {
+        this.writers(database);
+        database.exec(`DELETE FROM "_elt_writers" WHERE "target" NOT IN (SELECT lower("name") FROM sqlite_schema WHERE "type" = 'table')`);
+        database
+            .prepare('INSERT INTO "_elt_writers" ("target", "writer") VALUES (?, ?) ON CONFLICT ("target") DO NOTHING')
+            .run(this.table.location, writer);
+    }
+    exists(database, location) {
+        return (database
+            .prepare(`SELECT 1 FROM sqlite_schema WHERE "type" = 'table' AND lower("name") = ?`)
+            .get(location) !== undefined);
+    }
+    // The field's values in each of the tables, which while a reload is open
+    // are the target and its hidden target: both rows still refer to files.
+    values(database, tables) {
+        const { table } = this;
+        return async function* (field) {
+            const column = table.columns.find((column) => column.field === field);
+            if (column === undefined)
+                throw new TypeError(`Unknown target field: ${field}`);
+            for (const name of tables()) {
+                // clear also accepts a target or a declared column that was never loaded.
+                if (!database
+                    .prepare('SELECT 1 FROM pragma_table_info(?) WHERE name = ? COLLATE NOCASE')
+                    .get(name, column.name))
+                    continue;
+                for (const row of database
+                    .prepare(`SELECT ${column.quotedName} AS value FROM ${quote(name)}`)
+                    .iterate())
+                    yield row.value;
+            }
+        };
+    }
+    async clear(writer, committed) {
+        using database = openDestination(this.path);
+        database.exec('BEGIN IMMEDIATE');
+        try {
+            this.writers(database);
+            const owner = database
+                .prepare('SELECT "writer" FROM "_elt_writers" WHERE "target" = ?')
+                .get(this.table.location)?.writer;
+            if (owner !== undefined && owner !== writer)
+                throw new TargetOwnedError(this.table.name, String(owner), writer);
+            // Emptied, not dropped: views built on the table keep working. With no
+            // rows left, no stored chunk is referenced, including those a failed
+            // stream left behind that the file triggers never see.
+            if (this.exists(database, this.table.location)) {
+                database.exec(`DELETE FROM ${this.table.quotedName}`);
+                // Clearing a copy also abandons the reload it left open.
+                database.exec(`DROP TABLE IF EXISTS ${quote(this.#hiddenName)}`);
+                // A file column declared after the table's last load has no chunks.
+                for (const column of this.table.columns) {
+                    const chunks = SQLiteFileStore.tableName(this.table, column);
+                    if (column.storesFile && this.exists(database, chunks))
+                        database.exec(`DELETE FROM ${quote(chunks)}`);
+                }
+            }
+            database
+                .prepare('DELETE FROM "_elt_writers" WHERE "target" = ?')
+                .run(this.table.location);
+            database.exec('COMMIT');
+            database.exec('BEGIN IMMEDIATE');
+            await committed?.(this.values(database, () => [this.table.name]));
+            database.exec('ROLLBACK');
+        }
+        catch (error) {
+            if (database.isTransaction)
+                database.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    // What the table, its reader view and their columns say to readers,
+    // rewritten with every load so they follow the stream's schema.
+    describe(database) {
+        const dataTypes = new Map([
+            ...this.table.columns.map(({ name, dataType }) => [name, dataType]),
+            ['loaded_at', 'timestamp'],
+        ]);
+        const columns = Object.fromEntries(Object.entries(this.#description.columns).map(([name, description]) => [
+            name,
+            { description, dataType: dataTypes.get(name) },
+        ]));
+        describe(database, this.table.name, this.#description.table, columns);
+        if (this.table.readerView !== undefined)
+            describe(database, this.table.readerView, this.#description.table, columns);
+    }
+    #viewDefinition(view) {
+        return `CREATE VIEW ${quote(view)} AS SELECT ${this.fields.join(', ')} FROM ${this.table.quotedName}`;
+    }
+    // Refuses, before anything is read, a view of other columns or another
+    // table, rather than adopting it. A stale table's view still selects the
+    // stored columns, which evolving the table replaces.
+    #refuseReaderView(database, view, stale) {
+        const existing = database
+            .prepare('SELECT "type", "sql" FROM sqlite_schema WHERE lower("name") = lower(?)')
+            .get(view);
+        if (existing === undefined)
+            return;
+        const sql = String(existing.sql);
+        const ours = stale
+            ? sql.startsWith(`CREATE VIEW ${quote(view)} AS SELECT `) &&
+                sql.endsWith(` FROM ${this.table.quotedName}`)
+            : sql === this.#viewDefinition(view);
+        if (existing.type !== 'view' || !ours)
+            throw new TypeError(`${quote(view)} is not a view of exactly ${this.table.quotedName}; drop it or delete the database`);
+    }
+    // Created only when absent and never replaced by a commit: replacing a view
+    // readers can see would lock them out. prepare refused any view not this
+    // load's own.
+    installReaderView(database, view) {
+        if (database
+            .prepare('SELECT 1 FROM sqlite_schema WHERE lower("name") = lower(?)')
+            .get(view) === undefined)
+            database.exec(this.#viewDefinition(view));
+    }
+    // The target as its first commit makes it: its owner, the table and the
+    // index its mode owns, its reader view and its descriptions.
+    #create(database, writer, replacing) {
+        this.own(database, writer);
+        database.exec(this.table.createTableSQL);
+        this.initialize(database, replacing);
+        if (this.table.readerView !== undefined)
+            this.installReaderView(database, this.table.readerView);
+        this.describe(database);
+    }
+    // The rows of one partition, or every row when the stream is not
+    // partitioned, as a WHERE clause over the target's or the stage's columns.
+    #scope(partition) {
+        if (partition === null)
+            return ['', []];
+        const columns = Object.keys(partition).map((field) => {
+            const column = this.table.columns.find((column) => column.field === field);
+            if (column === undefined)
+                throw new TypeError(`Resetting a partition requires destination column ${field}`);
+            return column;
+        });
+        return [
+            ` WHERE ${columns.map((column) => `${column.quotedName} = ?`).join(' AND ')}`,
+            columns.map((column) => column.encode(partition)),
+        ];
+    }
+    // A reload's hidden target, beside the target and invisible to readers.
+    get #hiddenName() {
+        return `_elt_next_${this.hash}`;
+    }
+    // The table the stream needs under the name, by the text SQLite keeps of
+    // its CREATE TABLE, which a CHECK alone can change. Evolving it keeps its
+    // rows.
+    #declaration(name) {
+        return new Declaration([`CREATE TABLE ${this.table.definition(quote(name))}`], { rows: 'keep' });
+    }
+    // Drops the chunks of every stored column that is no longer one of the
+    // target's file columns, and the triggers that delete them, before the table
+    // is replaced: no row of the table that takes its place refers to them.
+    #dropRetiredChunks(database) {
+        const files = new Set(this.table.columns
+            .filter(({ storesFile }) => storesFile)
+            .map(({ name }) => identifiers.key(name)));
+        for (const { name } of database
+            .prepare('SELECT "name" FROM pragma_table_info(?)')
+            .all(this.table.name))
+            if (!files.has(identifiers.key(String(name)))) {
+                const chunks = SQLiteFileStore.tableName(this.table, {
+                    name: String(name),
+                });
+                database.exec(`DROP TABLE IF EXISTS ${quote(chunks)}`);
+                for (const trigger of ['delete', 'update'])
+                    database.exec(`DROP TRIGGER IF EXISTS ${quote(`${chunks}_${trigger}`)}`);
+            }
+    }
+    // Brings a stored table the stream no longer fits to its shape, keeping
+    // every row: drift rebuilds it from the new definition and copies the
+    // columns both have, by name, a column the stream added taking its default
+    // (NULL) and one it dropped left behind. A value the new definition refuses
+    // fails the load, naming the column, and the transaction leaves the table as
+    // it was. The reader view selects the stored columns, and the mode index
+    // can cover a dropped key, so both are made again for the new shape.
+    #evolve(database) {
+        if (this.table.readerView !== undefined)
+            database.exec(`DROP VIEW IF EXISTS ${quote(this.table.readerView)}`);
+        this.dropDedupIndexes(database, null);
+        this.#dropRetiredChunks(database);
+        try {
+            this.#declaration(this.table.name).apply(database);
+        }
+        catch (cause) {
+            throw new TypeError(`The rows stored in ${this.table.quotedName} do not fit the new shape of stream ${this.stream.name}: ${errorMessage(cause)}. Clear the copy to load it again, or change the stream so they fit.`, { cause });
+        }
+        this.initialize(database, false);
+        if (this.table.readerView !== undefined)
+            this.installReaderView(database, this.table.readerView);
+        this.describe(database);
+    }
+    // Refuses, in one short transaction, a target another writer owns, a
+    // reader view not its own and stored rows it cannot keep, evolves a stored
+    // table the stream no longer fits unless the load overwrites it, and stages
+    // in TEMP. Nothing else reaches the database until a commit. A load into the
+    // target creates it, or adopts the stored one, at its first commit; a reload
+    // leaves it to readers as it is, merges into a hidden target from its first
+    // commit, and swaps that in at complete().
+    prepare(database, { writer, reloading }, loadedAt) {
+        const name = quote(`_elt_stage_${this.hash}`);
+        const stage = `temp.${name}`;
+        const hidden = quote(this.#hiddenName);
+        const stores = this.table.columns
+            .filter((column) => column.storesFile)
+            .map((column) => ({
+            column,
+            store: new SQLiteFileStore(database, this.table, column),
+        }));
+        let mode;
+        const open = (at) => at === 'reload' || at === 'continue';
+        const into = () => (open(mode) ? hidden : this.table.quotedName);
+        const tables = () => [this.table.name, ...(open(mode) ? [this.#hiddenName] : [])].filter((table) => this.exists(database, identifiers.key(table)));
+        // Every stored file a row of the tables refers to.
+        // With no table yet, no row refers to a file: a query of no rows.
+        const referenced = (column) => {
+            const selects = tables().map((table) => `SELECT ${column.quotedName} FROM ${quote(table)} WHERE ${column.quotedName} IS NOT NULL`);
+            return selects.length === 0
+                ? 'SELECT NULL WHERE 0'
+                : selects.join(' UNION ');
+        };
+        // Drops the chunks of files no row of the tables refers to.
+        const prune = () => {
+            for (const { column, store } of stores)
+                if (store.published)
+                    database.exec(`DELETE FROM ${quote(store.name)} WHERE "file" NOT IN (${referenced(column)})`);
+        };
+        mode = transaction(database, () => {
+            this.#refuse(database, writer);
+            const target = this.#declaration(this.table.name).drift(database);
+            let next = reloadMode({
+                reloading,
+                destinationSyncMode: this.configuration.destinationSyncMode,
+                target,
+                hidden: this.#declaration(this.#hiddenName).drift(database),
+            });
+            // A hidden target no reload continues is a leftover readers never saw.
+            if (next !== 'continue')
+                database.exec(`DROP TABLE IF EXISTS ${hidden}`);
+            if (!open(next) && this.table.readerView !== undefined)
+                this.#refuseReaderView(database, this.table.readerView, target === 'stale');
+            if (next === 'evolve') {
+                this.#evolve(database);
+                next = 'load';
+            }
+            if (next === 'load' && !this.replaces)
+                this.inspect(database);
+            database.exec(`DROP TABLE IF EXISTS ${stage}`);
+            database.exec(`CREATE TEMP TABLE ${name} (${seq} INTEGER PRIMARY KEY, ${op} TEXT NOT NULL, ${this.table.columns.map((column) => `${column.quotedName} ${column.storageType}`).join(', ')})`);
+            for (const { store } of stores)
+                store.stage();
+            return next;
+        }, { mode: 'immediate' });
+        const fresh = mode === 'create' || mode === 'reload';
+        const columns = this.table.columns.map((column) => column.quotedName);
+        const record = database.prepare(`INSERT INTO ${stage} (${op}, ${columns.join(', ')}) VALUES ('R', ${columns.map(() => '?').join(', ')})`);
+        const staged = (column) => `SELECT ${column.quotedName} FROM ${stage} WHERE ${column.quotedName} IS NOT NULL`;
+        // Partitions the stage dropped, which the next commit empties in the
+        // table it merges into.
+        let resets = [];
+        // Files staged but never merged, and files a merge did not keep.
+        const drop = () => {
+            for (const { column, store } of stores) {
+                if (store.published)
+                    database.exec(`DELETE FROM ${quote(store.name)} WHERE "file" IN (${staged(column)}) AND "file" NOT IN (${referenced(column)})`);
+                store.discard();
+            }
+            database.exec(`DELETE FROM ${stage}`);
+            resets = [];
+        };
+        // The first commit claims the target: it owns the hidden target of a
+        // reload, or creates or adopts the table. Later commits find it claimed.
+        const claimTarget = () => {
+            if (open(mode)) {
+                this.own(database, writer);
+                return;
+            }
+            this.#create(database, writer, this.replaces);
+            if (this.replaces)
+                this.replace(database);
+        };
+        const claimed = () => { };
+        let claim = claimTarget;
+        return {
+            fresh,
+            get reloading() {
+                return open(mode);
+            },
+            values: this.values(database, tables),
+            apply: async (operation) => {
+                if (operation.type === 'RESET') {
+                    const { partition } = operation;
+                    if (partition === null) {
+                        // The whole stream starts over in a new hidden target.
+                        drop();
+                        mode = 'reload';
+                        return;
+                    }
+                    const [rows, values] = this.#scope(partition);
+                    database.prepare(`DELETE FROM ${stage}${rows}`).run(...values);
+                    resets.push(partition);
+                    return;
+                }
+                if (operation.type === 'DELETE') {
+                    const [keys, values] = this.deletionKeys(operation.key);
+                    database
+                        .prepare(`INSERT INTO ${stage} (${op}, ${keys.map((column) => column.quotedName).join(', ')}) VALUES ('D', ${keys.map(() => '?').join(', ')})`)
+                        .run(...values);
+                    return;
+                }
+                // Each file is read here, before the source advances past it.
+                let data = operation.data;
+                for (const { column, store } of stores) {
+                    const content = Reflect.get(Object(data), column.field);
+                    if (content instanceof FileContent)
+                        data = {
+                            ...Object(data),
+                            [column.field]: await store.save(content),
+                        };
+                }
+                record.run(...this.encode(data));
+            },
+            // Each commit is one transaction; a failed one leaves the database as
+            // the last commit left it.
+            commit: async () => {
+                transaction(database, () => {
+                    if (mode === 'reload') {
+                        database.exec(`DROP TABLE IF EXISTS ${hidden}`);
+                        database.exec(`CREATE TABLE ${this.table.definition(hidden)}`);
+                        this.build(database, hidden);
+                    }
+                    claim();
+                    for (const partition of resets) {
+                        const [rows, values] = this.#scope(partition);
+                        database.prepare(`DELETE FROM ${into()}${rows}`).run(...values);
+                    }
+                    for (const { store } of stores)
+                        store.publish();
+                    this.merge(database, stage, loadedAt, into());
+                    // Files of the rows a reset emptied, and of staged rows it dropped.
+                    if (resets.length > 0)
+                        prune();
+                    drop();
+                }, { mode: 'immediate' });
+                claim = claimed;
+                // Its first commit made the hidden target, so the reload continues.
+                if (mode === 'reload')
+                    mode = 'continue';
+            },
+            complete: async () => {
+                if (!open(mode))
+                    return;
+                transaction(database, () => {
+                    if (this.table.readerView !== undefined)
+                        database.exec(`DROP VIEW IF EXISTS ${quote(this.table.readerView)}`);
+                    this.#dropRetiredChunks(database);
+                    database.exec(`DROP TABLE IF EXISTS ${this.table.quotedName}`);
+                    database.exec(`ALTER TABLE ${hidden} RENAME TO ${this.table.quotedName}`);
+                    this.adopt(database);
+                    if (this.table.readerView !== undefined)
+                        this.installReaderView(database, this.table.readerView);
+                    this.describe(database);
+                    mode = 'load';
+                    prune();
+                }, { mode: 'immediate' });
+            },
+            discard: async () => drop(),
+            [Symbol.asyncDispose]: async () => {
+                drop();
+                database.exec(`DROP TABLE ${stage}`);
+                for (const { store } of stores)
+                    store.unstage();
+            },
+        };
+    }
+}

package/dist/view.d.ts

@@ -0,0 +1,20 @@
+import { type Connection, DerivedDataset } from '@eltjs/elt';
+import { SQLiteDestination } from './sqlite-destination.ts';
+import type { SQLiteTable } from './sqlite-table.ts';
+export declare class View extends DerivedDataset<SQLiteTable> {
+    #private;
+    readonly name: string;
+    readonly into: SQLiteDestination;
+    constructor({ into, name, description, columns, sql, }: {
+        into: SQLiteDestination;
+        name: string;
+        description: string;
+        columns: Readonly<Record<string, string>>;
+        sql: string;
+    });
+    validate(connections: readonly Connection<SQLiteTable>[]): void;
+    refresh({ connections, earlier, }: {
+        readonly connections: readonly Connection<SQLiteTable>[];
+        readonly earlier: readonly DerivedDataset<SQLiteTable>[];
+    }): Promise<void>;
+}

package/dist/view.js

@@ -0,0 +1,59 @@
+import { DerivedDataset } from '@eltjs/elt';
+import { openDestination } from './open-destination.js';
+import { SQLiteDestination } from './sqlite-destination.js';
+import { publishSQLiteViews } from './sqlite-views.js';
+// A view over what the pipeline loads into one SQLite file: derived data
+// that SQLite computes on each read, as a dbt model materialized as a view
+// is. Its inputs are the relations its SQL reads, so it names none of them.
+// It appears once its query compiles, so a reader never finds a view that
+// fails; until a copy of the pipeline has made each table it reads, and each
+// derived dataset before it that it reads has appeared, it waits, as dbt
+// skips a model whose upstream model was skipped. Any other error of its
+// query is the view's own failure.
+export class View extends DerivedDataset {
+    name;
+    // The SQLite file the view lives in, where a computed dataset after it
+    // reads it.
+    into;
+    #view;
+    constructor({ into, name, description, columns, sql, }) {
+        super();
+        this.name = name;
+        this.into = into;
+        this.#view = { name, description, columns, query: sql };
+        Object.freeze(this);
+    }
+    validate(connections) {
+        if (this.#made(connections).has(this.name.toLowerCase()))
+            throw new TypeError(`View ${this.name} has the name of a table or reader view a copy makes`);
+    }
+    async refresh({ connections, earlier, }) {
+        using database = openDestination(this.into.path);
+        try {
+            database.prepare(this.#view.query);
+        }
+        catch (error) {
+            const missing = error instanceof Error
+                ? /^no such table: (?:main\.)?(.+)$/.exec(error.message)?.[1]
+                : undefined;
+            const missingName = missing?.toLowerCase();
+            if (missingName !== undefined &&
+                (this.#made(connections).has(missingName) ||
+                    earlier.some(({ name }) => name.toLowerCase() === missingName)))
+                return;
+            throw error;
+        }
+        publishSQLiteViews(database, { views: [this.#view] });
+    }
+    // The tables and reader views the pipeline's copies make in this view's
+    // file, in lower case, as SQLite compares names.
+    #made(connections) {
+        return new Set(connections
+            .filter(({ destination }) => destination instanceof SQLiteDestination &&
+            destination.path === this.into.path)
+            .flatMap(({ steps }) => steps)
+            .flatMap(({ to }) => [to.name, to.readerView])
+            .filter((name) => name !== undefined)
+            .map((name) => name.toLowerCase()));
+    }
+}

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@eltjs/elt-sqlite",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "The SQLite destination of elt: each stream is a raw table in one SQLite file, with a reader view over it and a catalog of each table, view and column.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ezzabuzaid/elt",
+    "directory": "packages/destinations/sqlite"
+  },
+  "bugs": {
+    "url": "https://github.com/ezzabuzaid/elt/issues"
+  },
+  "homepage": "https://github.com/ezzabuzaid/elt/tree/main/packages/destinations/sqlite#readme",
+  "keywords": [
+    "elt",
+    "sqlite",
+    "destination",
+    "pipeline"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/spec/**",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@eltjs/elt": "^0.1.1",
+    "@zukhruf/mutex": "^0.8.10",
+    "@zukhruf/sqlite-drift": "^0.8.10",
+    "@zukhruf/sqlite-open": "^0.8.10",
+    "@zukhruf/sqlite-transaction": "^0.8.10"
+  },
+  "devDependencies": {
+    "@sinonjs/fake-timers": "15.4.0",
+    "@zukhruf/async": "^0.8.10",
+    "@zukhruf/snapshot-differential": "^0.8.10",
+    "@zukhruf/testing": "^0.8.10"
+  }
+}