@eltjs/elt-sqlite 0.0.0-stage → 0.1.0

package/dist/sqlite-destination.js

@@ -0,0 +1,67 @@
+import { resolve } from 'node:path';
+import { Destination } from '@eltjs/elt';
+import { openDestination } from './open-destination.js';
+import { SQLiteAppendWriter } from './sqlite-append-writer.js';
+import { SQLiteColumns } from './sqlite-columns.js';
+import { SQLiteDeduplicatingWriter } from './sqlite-deduplicating-writer.js';
+import { SQLiteOverwriteWriter } from './sqlite-overwrite-writer.js';
+import { SQLiteTable } from './sqlite-table.js';
+export class SQLiteDestination extends Destination {
+    supportedDestinationSyncModes = Object.freeze([
+        'overwrite',
+        'append',
+        'append_dedup',
+        'overwrite_dedup',
+    ]);
+    path;
+    constructor({ path }) {
+        super();
+        if (!path)
+            throw new TypeError('SQLite requires a database path');
+        this.path = path === ':memory:' ? path : resolve(path);
+        Object.freeze(this);
+    }
+    location(target) {
+        return target.location;
+    }
+    // Each stream's commit is its own short transaction, so no transaction
+    // stays open while the sources read.
+    async load({ clock, }) {
+        const database = openDestination(this.path);
+        const loadedAt = new Date(clock.Date.now()).toISOString();
+        return {
+            prepare: async (configuration, target, binding) => this.createWriter(configuration, target).prepare(database, binding, loadedAt),
+            [Symbol.asyncDispose]: async () => {
+                try {
+                    if (database.isTransaction)
+                        database.exec('ROLLBACK');
+                }
+                finally {
+                    database.close();
+                }
+            },
+        };
+    }
+    table(name, configure) {
+        return new SQLiteTable(name, configure?.(new SQLiteColumns()));
+    }
+    createWriter(configuration, target) {
+        this.validateConfiguration(configuration, target);
+        if (!(target instanceof SQLiteTable))
+            throw new TypeError('SQLite requires SQLite table targets');
+        if (configuration.syncMode === 'incremental' && this.path === ':memory:')
+            throw new TypeError('Incremental SQLite requires a persistent destination file');
+        const table = target.resolve(configuration.stream);
+        switch (configuration.destinationSyncMode) {
+            case 'append_dedup':
+            case 'overwrite_dedup':
+                return new SQLiteDeduplicatingWriter(configuration, this.path, table);
+            case 'append':
+                return new SQLiteAppendWriter(configuration, this.path, table);
+            case 'overwrite':
+                return new SQLiteOverwriteWriter(configuration, this.path, table);
+            default:
+                throw new TypeError(`Destination does not support ${configuration.destinationSyncMode}`);
+        }
+    }
+}

package/dist/sqlite-file-store.d.ts

@@ -0,0 +1,17 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { FileContent } from '@eltjs/elt';
+import type { SQLiteColumn } from './sqlite-column.ts';
+import type { SQLiteTable } from './sqlite-table.ts';
+export declare class SQLiteFileStore {
+    #private;
+    static readonly chunkSize: number;
+    readonly name: string;
+    constructor(database: DatabaseSync, table: SQLiteTable, column: SQLiteColumn);
+    static tableName(table: SQLiteTable, column: Pick<SQLiteColumn, 'name'>): string;
+    get published(): boolean;
+    stage(): void;
+    save(content: FileContent): Promise<number>;
+    publish(): void;
+    discard(): void;
+    unstage(): void;
+}

package/dist/sqlite-file-store.js

@@ -0,0 +1,82 @@
+import { createHash } from 'node:crypto';
+import { identifiers } from './sqlite-identifiers.js';
+const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+const tablePrefix = '_elt_files_';
+const chunks = '("file" INTEGER NOT NULL, "n" INTEGER NOT NULL, "bytes" BLOB NOT NULL, PRIMARY KEY ("file", "n")) STRICT';
+// A file column's bytes, in ordered chunks: SQLite caps one BLOB at 1e9 bytes
+// and a whole-file BLOB would hold the file in memory. The row keeps the
+// file's id; triggers drop a row's chunks in the same transaction as the row.
+// A load stages chunks in a connection-private TEMP table and publishes them
+// inside a commit, so a load holds no transaction while it reads files.
+export class SQLiteFileStore {
+    static chunkSize = 4 * 1024 * 1024;
+    name;
+    #database;
+    #table;
+    #column;
+    #staged;
+    constructor(database, table, column) {
+        this.#database = database;
+        this.#table = table;
+        this.#column = column;
+        this.name = SQLiteFileStore.tableName(table, column);
+        this.#staged = quote(`${tablePrefix}stage_${this.name.slice(tablePrefix.length)}`);
+    }
+    // A hash of the table and column, as SQLite compares them: joined as text,
+    // table a_b with column c and table a with column b_c would share chunks
+    // and prune each other's.
+    static tableName(table, column) {
+        const key = createHash('sha256')
+            .update(JSON.stringify([table.location, identifiers.key(column.name)]))
+            .digest('hex')
+            .slice(0, 40);
+        return `${tablePrefix}${key}`;
+    }
+    #exists(location) {
+        return (this.#database
+            .prepare(`SELECT 1 FROM sqlite_schema WHERE "type" = 'table' AND lower("name") = ?`)
+            .get(location) !== undefined);
+    }
+    get published() {
+        return this.#exists(this.name);
+    }
+    stage() {
+        this.#database.exec(`DROP TABLE IF EXISTS temp.${this.#staged}`);
+        this.#database.exec(`CREATE TEMP TABLE ${this.#staged} ${chunks}`);
+    }
+    // An empty file still stores one empty chunk, so its id stays reserved. Ids
+    // continue after both the published and the staged chunks.
+    async save(content) {
+        const highest = (table) => Number(this.#database
+            .prepare(`SELECT coalesce(max("file"), 0) AS "file" FROM ${table}`)
+            .get()?.file);
+        const file = Math.max(this.published ? highest(quote(this.name)) : 0, highest(`temp.${this.#staged}`)) + 1;
+        const insert = this.#database.prepare(`INSERT INTO temp.${this.#staged} ("file", "n", "bytes") VALUES (?, ?, ?)`);
+        let n = 0;
+        for await (const chunk of content.chunks(SQLiteFileStore.chunkSize))
+            insert.run(file, n++, chunk);
+        if (n === 0)
+            insert.run(file, 0, new Uint8Array());
+        return file;
+    }
+    // Moves the staged chunks into the store, inside a commit, and attaches the
+    // triggers to the target once it exists. A reload swaps in a table without
+    // them, which its next commit attaches again.
+    publish() {
+        const table = quote(this.name);
+        const column = this.#column.quotedName;
+        this.#database.exec(`CREATE TABLE IF NOT EXISTS ${table} ${chunks}`);
+        if (this.#exists(this.#table.location)) {
+            this.#database.exec(`CREATE TRIGGER IF NOT EXISTS ${quote(`${this.name}_delete`)} AFTER DELETE ON ${this.#table.quotedName} BEGIN DELETE FROM ${table} WHERE "file" = old.${column}; END`);
+            this.#database.exec(`CREATE TRIGGER IF NOT EXISTS ${quote(`${this.name}_update`)} AFTER UPDATE OF ${column} ON ${this.#table.quotedName} WHEN old.${column} IS NOT new.${column} BEGIN DELETE FROM ${table} WHERE "file" = old.${column}; END`);
+        }
+        this.#database.exec(`INSERT INTO ${table} SELECT * FROM temp.${this.#staged}`);
+        this.discard();
+    }
+    discard() {
+        this.#database.exec(`DELETE FROM temp.${this.#staged}`);
+    }
+    unstage() {
+        this.#database.exec(`DROP TABLE IF EXISTS temp.${this.#staged}`);
+    }
+}

package/dist/sqlite-identifiers.d.ts

@@ -0,0 +1,8 @@
+import { Identifiers } from '@eltjs/elt';
+declare class SQLiteIdentifiers extends Identifiers {
+    protected readonly maxBytes: number;
+    protected readonly ownColumns: string[];
+    key(name: string): string;
+}
+export declare const identifiers: Readonly<SQLiteIdentifiers>;
+export {};

package/dist/sqlite-identifiers.js

@@ -0,0 +1,11 @@
+import { Identifiers } from '@eltjs/elt';
+// SQLite holds a name of any length and compares two without ASCII case: it
+// folds A-Z only, so `É` and `é` stay two names.
+class SQLiteIdentifiers extends Identifiers {
+    maxBytes = Infinity;
+    ownColumns = ['loaded_at'];
+    key(name) {
+        return name.replaceAll(/[A-Z]/g, (letter) => letter.toLowerCase());
+    }
+}
+export const identifiers = Object.freeze(new SQLiteIdentifiers());

package/dist/sqlite-overwrite-writer.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { CopyConfiguration } from '@eltjs/elt';
+import type { SQLiteTable } from './sqlite-table.ts';
+import { SQLiteWriter } from './sqlite-writer.ts';
+export declare class SQLiteOverwriteWriter extends SQLiteWriter {
+    constructor(configuration: CopyConfiguration, path: string, table: SQLiteTable);
+    protected get replaces(): boolean;
+    protected merge(database: DatabaseSync, stage: string, loadedAt: string, into: string): void;
+}

package/dist/sqlite-overwrite-writer.js

@@ -0,0 +1,13 @@
+import { SQLiteWriter } from './sqlite-writer.js';
+export class SQLiteOverwriteWriter extends SQLiteWriter {
+    constructor(configuration, path, table) {
+        super(configuration, path, table);
+        Object.freeze(this);
+    }
+    get replaces() {
+        return true;
+    }
+    merge(database, stage, loadedAt, into) {
+        this.append(database, stage, loadedAt, into);
+    }
+}

package/dist/sqlite-passes.d.ts

@@ -0,0 +1,39 @@
+import type { FailureType, SyncStatus } from '@eltjs/elt';
+export type PassState = SyncStatus | 'running';
+type Started = {
+    readonly startedAt: string;
+    readonly lastSucceededAt: string | null;
+    readonly currentAsOf: string | null;
+};
+export type PassStatus = (Started & {
+    readonly state: 'running';
+    readonly completedAt: null;
+    readonly error: null;
+    readonly failureType: null;
+}) | (Started & {
+    readonly state: 'succeeded';
+    readonly completedAt: string;
+    readonly error: null;
+    readonly failureType: null;
+}) | (Started & {
+    readonly state: 'cancelled';
+    readonly completedAt: string;
+    readonly error: string;
+    readonly failureType: null;
+}) | (Started & {
+    readonly state: 'partial' | 'failed';
+    readonly completedAt: string;
+    readonly error: string;
+    readonly failureType: FailureType;
+});
+export type StreamPassStatus = {
+    readonly stream: string;
+    readonly state: PassState;
+    readonly lastSucceededAt: string | null;
+    readonly currentAsOf: string | null;
+};
+export declare function readPassStatus(path: string): {
+    readonly pass: PassStatus | null;
+    readonly streams: readonly StreamPassStatus[];
+};
+export {};

package/dist/sqlite-passes.js

@@ -0,0 +1,174 @@
+import { UnavailableError, open } from '@zukhruf/sqlite-open';
+import { busyTimeout } from './open-destination.js';
+import { syncHistory } from './sqlite-sync-history-schema.js';
+// The latest pass of a SQLite destination file and each stream's latest
+// outcome, as its sync history records them; null and empty until the history
+// recorded a pass, and while the history in the file is one another version
+// installed, and while no file is at the path. A file that several
+// connections load reads as one pass, made of the latest pass of each
+// connection.
+export function readPassStatus(path) {
+    using data = reader(path);
+    if (data === null || syncHistory.drift(data) !== 'fits')
+        return { pass: null, streams: [] };
+    const [first, ...others] = data
+        .prepare('SELECT status, started_at, completed_at, error, failure_type, last_successful_sync_at, current_as_of FROM sync_status')
+        .all()
+        .map((row) => recorded(row, passState(row.status)));
+    return {
+        pass: first === undefined ? null : combined([first, ...others]),
+        streams: data
+            .prepare('SELECT stream, status, last_successful_sync_at, current_as_of FROM stream_status ORDER BY stream')
+            .all()
+            .map((row) => ({
+            stream: String(row.stream),
+            state: passState(row.status),
+            lastSucceededAt: text(row.last_successful_sync_at),
+            currentAsOf: text(row.current_as_of),
+        })),
+    };
+}
+// A reader of the file, or null while no file is at the path.
+function reader(path) {
+    try {
+        return open(path, { readOnly: true, timeout: busyTimeout });
+    }
+    catch (error) {
+        if (error instanceof UnavailableError)
+            return null;
+        throw error;
+    }
+}
+// A sync_status row as the pass it records: the history completes every pass
+// that ended, and gives an error to each that did not load completely.
+function recorded(row, state) {
+    const started = {
+        startedAt: String(row.started_at),
+        lastSucceededAt: text(row.last_successful_sync_at),
+        currentAsOf: text(row.current_as_of),
+    };
+    switch (state) {
+        case 'running':
+            return {
+                ...started,
+                state,
+                completedAt: null,
+                error: null,
+                failureType: null,
+            };
+        case 'succeeded':
+            return {
+                ...started,
+                state,
+                completedAt: String(row.completed_at),
+                error: null,
+                failureType: null,
+            };
+        case 'cancelled':
+            return {
+                ...started,
+                state,
+                completedAt: String(row.completed_at),
+                error: String(row.error),
+                failureType: null,
+            };
+        default:
+            return {
+                ...started,
+                state,
+                completedAt: String(row.completed_at),
+                error: String(row.error),
+                failureType: failureType(row.failure_type),
+            };
+    }
+}
+// The latest passes of the connections of one file as one pass, which is only
+// as good as its worst connection: it runs while any of them runs, began when
+// the first began, ended when the last ended, and is current only as of the
+// least current. A failure of one connection makes the pass partial, not
+// succeeded, and its error keeps the error of each connection that did not
+// succeed, as Go's errors.Join does, one on each line.
+function combined(passes) {
+    const started = {
+        startedAt: earliest(passes.map(({ startedAt }) => startedAt)),
+        lastSucceededAt: earliestOfAll(passes.map(({ lastSucceededAt }) => lastSucceededAt)),
+        currentAsOf: earliestOfAll(passes.map(({ currentAsOf }) => currentAsOf)),
+    };
+    const ended = passes.filter((pass) => pass.state !== 'running');
+    if (ended.length < passes.length)
+        return {
+            ...started,
+            state: 'running',
+            completedAt: null,
+            error: null,
+            failureType: null,
+        };
+    const completedAt = latest(ended.map(({ completedAt }) => completedAt));
+    const error = ended
+        .flatMap((pass) => (pass.error === null ? [] : [pass.error]))
+        .join('\n');
+    if (ended.some(({ state }) => state === 'cancelled'))
+        return {
+            ...started,
+            state: 'cancelled',
+            completedAt,
+            error,
+            failureType: null,
+        };
+    if (ended.every(({ state }) => state === 'succeeded'))
+        return {
+            ...started,
+            state: 'succeeded',
+            completedAt,
+            error: null,
+            failureType: null,
+        };
+    return {
+        ...started,
+        state: ended.every(({ state }) => state === 'failed')
+            ? 'failed'
+            : 'partial',
+        completedAt,
+        error,
+        failureType: ended.some(({ failureType }) => failureType === 'config')
+            ? 'config'
+            : 'system',
+    };
+}
+function earliest(instants) {
+    return instants.reduce((first, next) => Date.parse(next) < Date.parse(first) ? next : first);
+}
+function latest(instants) {
+    return instants.reduce((last, next) => Date.parse(next) > Date.parse(last) ? next : last);
+}
+// The earliest instant, or null when any of them is null.
+function earliestOfAll(instants) {
+    const known = instants.filter((instant) => instant !== null);
+    return known.length < instants.length ? null : earliest(known);
+}
+function failureType(value) {
+    switch (value) {
+        case 'config':
+        case 'system':
+            return value;
+        default:
+            throw new TypeError(`Unknown failure type ${String(value)}`);
+    }
+}
+function passState(status) {
+    switch (status) {
+        case 'running':
+        case 'succeeded':
+        case 'partial':
+        case 'failed':
+        case 'cancelled':
+            return status;
+        default:
+            throw new TypeError(`Unknown pass status ${String(status)}`);
+    }
+}
+function text(value) {
+    if (value === undefined)
+        throw new TypeError('A sync history view lacks a column it declares');
+    return value === null ? null : String(value);
+}

package/dist/sqlite-sync-history-schema.d.ts

@@ -0,0 +1,8 @@
+import { Declaration } from '@zukhruf/sqlite-drift';
+import { type SQLiteView } from './sqlite-views.ts';
+export declare const attempts = "\"_elt_sync_attempts\"";
+export declare const coverage = "\"_elt_extraction_coverage\"";
+export declare const checks = "\"_elt_stream_checks\"";
+export declare const syncHistoryTables: Declaration;
+export declare const syncHistoryViews: readonly SQLiteView[];
+export declare const syncHistory: Declaration;

package/dist/sqlite-sync-history-schema.js

@@ -0,0 +1,94 @@
+import { Declaration } from '@zukhruf/sqlite-drift';
+import { syncHistoryRelations } from '@eltjs/elt';
+import { viewDefinition } from './sqlite-views.js';
+export const attempts = '"_elt_sync_attempts"';
+export const coverage = '"_elt_extraction_coverage"';
+export const checks = '"_elt_stream_checks"';
+const status = `"status" TEXT NOT NULL DEFAULT 'running' CHECK ("status" IN ('running', 'succeeded', 'partial', 'failed', 'cancelled'))`;
+const tables = [
+    `CREATE TABLE ${attempts} (
+    "id" INTEGER PRIMARY KEY,
+    "connector" TEXT NOT NULL CHECK (trim("connector") <> ''), "source" TEXT NOT NULL,
+    "started_at" TEXT NOT NULL, "completed_at" TEXT, ${status}, "error" TEXT,
+    "failure_type" TEXT CHECK ("failure_type" IN ('config', 'system')),
+    CHECK (("status" = 'running') = ("completed_at" IS NULL)),
+    CHECK (("status" IN ('partial', 'failed')) = ("failure_type" IS NOT NULL))
+  ) STRICT`,
+    `CREATE INDEX "_elt_sync_attempts_connector" ON ${attempts} ("connector", "id" DESC)`,
+    `CREATE TABLE ${coverage} (
+    "attempt_id" INTEGER NOT NULL REFERENCES ${attempts}("id"),
+    "stream" TEXT NOT NULL, "target_schema" TEXT NOT NULL, "target_table" TEXT NOT NULL,
+    "sync_mode" TEXT NOT NULL, "destination_sync_mode" TEXT NOT NULL,
+    "description" TEXT NOT NULL CHECK (trim("description") <> ''),
+    "selection" TEXT NOT NULL CHECK (json_valid("selection")), ${status},
+    "written_count" INTEGER CHECK ("written_count" >= 0),
+    "deleted_count" INTEGER CHECK ("deleted_count" >= 0),
+    "failures" TEXT NOT NULL DEFAULT '[]' CHECK (json_valid("failures")),
+    "upstream_current_as_of" TEXT,
+    PRIMARY KEY ("attempt_id", "stream")
+  ) STRICT`,
+    // Each stream's latest check by a watch that found it unchanged.
+    `CREATE TABLE ${checks} (
+    "connector" TEXT NOT NULL, "stream" TEXT NOT NULL, "checked_at" TEXT NOT NULL,
+    PRIMARY KEY ("connector", "stream")
+  ) STRICT`,
+];
+// The history's tables, which install() brings to this declaration.
+export const syncHistoryTables = new Declaration(tables, { rows: 'replace' });
+// When each declared stream last matched its upstream: the start of its last
+// successful pass, or a later check that found it unchanged, each no later
+// than when the source said the upstream itself was last current.
+const currency = `"stream_success" AS (
+        SELECT a."connector", c."stream", min(a."started_at", coalesce(c."upstream_current_as_of", a."started_at")) AS "current_as_of",
+          row_number() OVER (PARTITION BY a."connector", c."stream" ORDER BY a."completed_at" DESC, a."id" DESC) AS "rank"
+        FROM ${coverage} c JOIN ${attempts} a ON a."id" = c."attempt_id" WHERE c."status" = 'succeeded'
+      ), "currency" AS (
+        SELECT d."connector", d."stream",
+          CASE WHEN s."current_as_of" IS NULL THEN NULL ELSE max(s."current_as_of", coalesce(k."checked_at", s."current_as_of")) END AS "current_as_of"
+        FROM (SELECT DISTINCT a."connector", c."stream" FROM ${coverage} c JOIN ${attempts} a ON a."id" = c."attempt_id") d
+        LEFT JOIN "stream_success" s ON s."connector" = d."connector" AND s."stream" = d."stream" AND s."rank" = 1
+        LEFT JOIN ${checks} k ON k."connector" = d."connector" AND k."stream" = d."stream"
+      )`;
+// The same relations Postgres publishes; SQLite ranks with window functions
+// where Postgres uses DISTINCT ON and LATERAL.
+const queries = {
+    sync_attempts: `SELECT "id" AS "attempt_id", "connector", "source", "started_at", "completed_at", "status", "error", "failure_type" FROM ${attempts}`,
+    extraction_coverage: `SELECT c."attempt_id", a."connector", a."source", a."started_at", a."completed_at",
+      c."stream", c."target_schema", c."target_table",
+      EXISTS (SELECT 1 FROM sqlite_schema t WHERE t."type" = 'table' AND lower(t."name") = lower(c."target_table")) AS "target_exists",
+      c."sync_mode", c."destination_sync_mode", c."description", c."selection",
+      c."status", c."written_count", c."deleted_count", c."failures"
+      FROM ${coverage} c JOIN ${attempts} a ON a."id" = c."attempt_id"`,
+    sync_status: `WITH ${currency}, "success" AS (
+        SELECT "connector", "id", "completed_at", row_number() OVER (PARTITION BY "connector" ORDER BY "completed_at" DESC, "id" DESC) AS "rank"
+        FROM ${attempts} WHERE "status" = 'succeeded'
+      ), "latest" AS (
+        SELECT *, row_number() OVER (PARTITION BY "connector" ORDER BY "id" DESC) AS "rank" FROM ${attempts}
+      )
+      SELECT a."connector", a."id" AS "latest_attempt_id", a."started_at", a."completed_at", a."status", a."error", a."failure_type",
+        s."id" AS "last_successful_attempt_id", s."completed_at" AS "last_successful_sync_at",
+        (SELECT CASE WHEN count(*) = count(c."current_as_of") THEN min(c."current_as_of") END FROM "currency" c WHERE c."connector" = a."connector") AS "current_as_of"
+      FROM "latest" a LEFT JOIN "success" s ON s."connector" = a."connector" AND s."rank" = 1
+      WHERE a."rank" = 1 ORDER BY a."connector"`,
+    stream_status: `WITH ${currency}, "declared" AS (
+        SELECT a."connector", c."stream", c."target_schema", c."target_table", a."id", a."started_at", a."completed_at", c."status",
+          row_number() OVER (PARTITION BY a."connector", c."stream" ORDER BY a."id" DESC) AS "rank"
+        FROM ${coverage} c JOIN ${attempts} a ON a."id" = c."attempt_id"
+      ), "success" AS (
+        SELECT a."connector", c."stream", a."id", a."completed_at",
+          row_number() OVER (PARTITION BY a."connector", c."stream" ORDER BY a."completed_at" DESC, a."id" DESC) AS "rank"
+        FROM ${coverage} c JOIN ${attempts} a ON a."id" = c."attempt_id" WHERE c."status" = 'succeeded'
+      )
+      SELECT d."connector", d."stream", d."target_schema", d."target_table",
+        d."id" AS "latest_attempt_id", d."started_at", d."completed_at", d."status",
+        s."id" AS "last_successful_attempt_id", s."completed_at" AS "last_successful_sync_at", c."current_as_of"
+      FROM "declared" d LEFT JOIN "success" s ON s."connector" = d."connector" AND s."stream" = d."stream" AND s."rank" = 1
+      LEFT JOIN "currency" c ON c."connector" = d."connector" AND c."stream" = d."stream"
+      WHERE d."rank" = 1 ORDER BY d."connector", d."stream"`,
+};
+// How readers see the sync history: what each pass declared and loaded.
+export const syncHistoryViews = Object.values(syncHistoryRelations).map((relation) => ({ ...relation, query: queries[relation.name] }));
+// The whole history as this version reads it: a file whose tables or views
+// another version installed has no history this version can read until its
+// next pass installs it again.
+export const syncHistory = new Declaration([...tables, ...syncHistoryViews.map(viewDefinition)], { rows: 'replace' });

package/dist/sqlite-sync-history.d.ts

@@ -0,0 +1,12 @@
+import { type Connection, type DeclaredCopy, type RecordedPass, type StreamCheck, SyncHistory } from '@eltjs/elt';
+import type { SQLiteTable } from './sqlite-table.ts';
+export declare class SQLiteSyncHistory extends SyncHistory<SQLiteTable> {
+    #private;
+    constructor(options?: {
+        readonly soleWriter?: boolean;
+    });
+    validate(connection: Connection<SQLiteTable>): void;
+    protected recordChecks(connection: Connection<SQLiteTable>, streamChecks: readonly StreamCheck[]): Promise<void>;
+    begin(connection: Connection<SQLiteTable>, copies: readonly DeclaredCopy<SQLiteTable>[], at: Date): Promise<RecordedPass<SQLiteTable>>;
+    install(connections: readonly Connection<SQLiteTable>[], at: Date): Promise<void>;
+}