@eltjs/elt-sqlite 0.1.2 → 0.2.0

package/README.md

@@ -197,7 +197,8 @@ At each refresh, the computed dataset compares the inputs with the output rows.
 ## When something fails
 
 - **A rule failure** gives an output row with the status `failed` and the reason in `error`. The run continues, and the refresh after the next pass tries the input again.
-- **A dataset failure**, for example a query that SQLite refuses, rejects the run, or it stops the watch.
+- **A dataset failure**, for example a query that SQLite refuses, rejects the run, or it stops the watch, with a `DerivedDatasetError` that names the dataset.
+- **A table that is gone**, for example one that a person dropped by hand, is no failure. A computed dataset that reads it waits and keeps its output rows. When the copy loads the table again, the dataset asks the rule only for inputs that changed.
 - **A copy that failed** keeps its last committed rows. The derived datasets read those rows.
 
 ## Recipes

package/dist/computed-dataset.js

@@ -1,4 +1,4 @@
-import { createHash } from 'node:crypto';
+import { hash } from 'node:crypto';
 import { Declaration } from '@zukhruf/sqlite-drift';
 import { open } from '@zukhruf/sqlite-open';
 import { transaction } from '@zukhruf/sqlite-transaction';
@@ -78,6 +78,8 @@ export class ComputedDataset extends DerivedDataset {
     }
     async refresh({ connections, signal, trigger, }) {
         const inputs = this.#inputs(connections);
+        if (inputs === null)
+            return;
         using database = openDestination(this.#into.path);
         const key = this.#rule.key.name;
         const stored = transaction(database, () => {
@@ -119,9 +121,7 @@ export class ComputedDataset extends DerivedDataset {
         for (const [id, input] of inputs) {
             if (signal?.aborted)
                 return;
-            const inputHash = createHash('sha256')
-                .update(JSON.stringify(input))
-                .digest('hex');
+            const inputHash = hash('sha256', JSON.stringify(input));
             const rule = await this.#rule.identity(input);
             const before = stored.get(id);
             // A rule that does not handle the input keeps what it made before.
@@ -190,6 +190,10 @@ export class ComputedDataset extends DerivedDataset {
     // Each input by key, from the rows of each relation of from that exists
     // yet: what the copies loaded, or what a view before this dataset gives. A
     // key read twice keeps its first input.
+    // null while a relation reads a table that is gone, such as one a person
+    // dropped by hand: its copy loads it again, and the dataset waits with what it
+    // made, as a view waits. Read as no rows, it would delete every output, and the
+    // reload would pay the rule for each again.
     #inputs(connections) {
         const inputs = new Map();
         for (const target of this.#from) {
@@ -206,9 +210,16 @@ export class ComputedDataset extends DerivedDataset {
                 .prepare('SELECT 1 FROM sqlite_schema WHERE lower("name") = lower(?)')
                 .get(relation) === undefined)
                 continue;
-            for (const row of database
-                .prepare(`SELECT * FROM ${quote(relation)}`)
-                .all()) {
+            let rows;
+            try {
+                rows = database.prepare(`SELECT * FROM ${quote(relation)}`).all();
+            }
+            catch (error) {
+                if (Error.isError(error) && error.message.startsWith('no such table: '))
+                    return null;
+                throw error;
+            }
+            for (const row of rows) {
                 const read = this.#rule.read(row);
                 if (read !== null && !inputs.has(read.key))
                     inputs.set(read.key, read.input);

package/dist/sqlite-deduplicating-writer.js

@@ -1,4 +1,4 @@
-import { createHash } from 'node:crypto';
+import { hash } from 'node:crypto';
 import { SQLiteColumns } from './sqlite-columns.js';
 import { SQLiteWriter, op, seq } from './sqlite-writer.js';
 export class SQLiteDeduplicatingWriter extends SQLiteWriter {
@@ -29,9 +29,7 @@ export class SQLiteDeduplicatingWriter extends SQLiteWriter {
     // Named after the table and its key, so a changed key builds a new index
     // and an unchanged one is never rebuilt.
     get #dedupIndex() {
-        return `_elt_dedup_${createHash('sha256')
-            .update(JSON.stringify([this.table.name, this.keys.map((key) => key.name)]))
-            .digest('hex')}`;
+        return `_elt_dedup_${hash('sha256', JSON.stringify([this.table.name, this.keys.map((key) => key.name)]))}`;
     }
     // A stored table the load merges into must hold keys and cursors of the
     // stream's types, none null, and no key twice, which its index forbids once

package/dist/sqlite-file-store.js

@@ -1,4 +1,4 @@
-import { createHash } from 'node:crypto';
+import { hash } from 'node:crypto';
 import { identifiers } from './sqlite-identifiers.js';
 const quote = (name) => `"${name.replaceAll('"', '""')}"`;
 const tablePrefix = '_elt_files_';
@@ -26,10 +26,7 @@ export class SQLiteFileStore {
     // 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);
+        const key = hash('sha256', JSON.stringify([table.location, identifiers.key(column.name)])).slice(0, 40);
         return `${tablePrefix}${key}`;
     }
     #exists(location) {

package/dist/sqlite-writer.js

@@ -1,4 +1,4 @@
-import { createHash } from 'node:crypto';
+import { hash } 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';
@@ -71,7 +71,7 @@ export class SQLiteWriter extends Writer {
         database.exec(`DELETE FROM ${this.table.quotedName}`);
     }
     get hash() {
-        return createHash('sha256').update(this.table.location).digest('hex');
+        return hash('sha256', this.table.location);
     }
     get fields() {
         return [

package/dist/view.js

@@ -33,7 +33,7 @@ export class View extends DerivedDataset {
             database.prepare(this.#view.query);
         }
         catch (error) {
-            const missing = error instanceof Error
+            const missing = Error.isError(error)
                 ? /^no such table: (?:main\.)?(.+)$/.exec(error.message)?.[1]
                 : undefined;
             const missingName = missing?.toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eltjs/elt-sqlite",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "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": {
@@ -39,7 +39,7 @@
     "node": ">=24"
   },
   "dependencies": {
-    "@eltjs/elt": "^0.1.2",
+    "@eltjs/elt": "^0.2.0",
     "@zukhruf/mutex": "^0.8.10",
     "@zukhruf/sqlite-drift": "^0.8.10",
     "@zukhruf/sqlite-open": "^0.8.10",