mikser-io 9.50.0 → 9.50.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikser-io",
-  "version": "9.50.0",
+  "version": "9.50.2",
   "description": "<p align=\"center\">   <img src=\"mikser-lockup-stacked.svg\" alt=\"mikser\" width=\"198\" /> </p>",
   "main": "index.js",
   "exports": {

package/src/changeset.js

@@ -61,7 +61,13 @@ registerSchema('change_sets', `
         -- permanent failure and a pending commit look identical, and both
         -- read as a null commit forever.
         commit_error TEXT,
-        commit_attempts INTEGER NOT NULL DEFAULT 0
+        commit_attempts INTEGER NOT NULL DEFAULT 0,
+        -- How the set finished. A claimed set had exactly two exits,
+        -- committed or failed, and a set whose changes cancel out qualifies
+        -- for neither: there is genuinely nothing to write, which is not an
+        -- error. Without a third outcome it was re-claimed every pass forever
+        -- and reported a null commit that looked like a fault.
+        outcome TEXT
     );
     CREATE INDEX IF NOT EXISTS idx_mikser_change_sets_created
         ON mikser_change_sets (created_at DESC);
@@ -222,6 +228,7 @@ function rowsToSets(handle, rows) {
             recordedAs: row.recorded_as ?? null,
             commitError: row.commit_error ?? null,
             commitAttempts: row.commit_attempts ?? 0,
+            outcome: row.outcome ?? null,
             paths: paths.map(p => p.path),
             deletions: paths.filter(p => p.operation === 'delete').map(p => p.path),
         }
@@ -241,6 +248,7 @@ function memorySets(filter = () => true) {
         recordedAs: set.recordedAs ?? null,
         commitError: set.commitError ?? null,
         commitAttempts: set.commitAttempts ?? 0,
+        outcome: set.outcome ?? null,
         paths: [...set.paths.keys()],
         deletions: [...set.paths.entries()].filter(([, op]) => op === 'delete').map(([p]) => p),
     }))
@@ -375,13 +383,20 @@ export function markChangeSetsRecorded(ids = [], recordedAs = null) {
     const at = Date.now()
     for (const id of ids) {
         const set = memory.get(id)
-        if (set) { set.recordedAt = at; set.recordedAs = recordedAs; set.commitError = null }
+        if (set) {
+            set.recordedAt = at
+            set.recordedAs = recordedAs
+            set.commitError = null
+            set.outcome = 'committed'
+        }
     }
     const handle = db()
     if (!handle) return
     try {
         const stmt = handle.prepare(
-            'UPDATE mikser_change_sets SET recorded_at = ?, recorded_as = ?, commit_error = NULL WHERE id = ?')
+            `UPDATE mikser_change_sets
+             SET recorded_at = ?, recorded_as = ?, commit_error = NULL, outcome = 'committed'
+             WHERE id = ?`)
         for (const id of ids) stmt.run(at, recordedAs, id)
     } catch { /* memory still holds it */ }
 }
@@ -416,6 +431,33 @@ export function markChangeSetFailed(id, error) {
     }
 }
 
+// Finish a set that produced no commit, because there was nothing to write.
+//
+// The third outcome. A set whose adds and removals cancel out — an undo of a
+// create, a probe that added and then deleted its own files — leaves an empty
+// diff, and git correctly makes no commit for it. It is not pending and it did
+// not fail: it is DONE, and saying so is what stops it being re-claimed every
+// pass forever while a column of nulls suggests a broken pipeline.
+//
+// `outcome` keeps the distinction that matters to undo: reverting a set that
+// never produced a commit is not the same operation as reverting one that did.
+export function markChangeSetSettled(id, outcome = 'empty') {
+    const at = Date.now()
+    const set = memory.get(id)
+    if (set) { set.recordedAt = at; set.recordedAs = null; set.outcome = outcome }
+    const handle = db()
+    if (!handle) return
+    try {
+        handle.prepare(`
+            UPDATE mikser_change_sets
+            SET recorded_at = COALESCE(recorded_at, ?), outcome = COALESCE(outcome, ?)
+            WHERE id = ?
+        `).run(at, outcome, id)
+    } catch (err) {
+        reportChangeSetFailure(err)
+    }
+}
+
 export function forgetAllChangeSets() {
     memory.clear()
     const handle = db()

package/src/database/index.js

@@ -104,26 +104,45 @@ let db = null
 // duplicate detection. Same name twice = the later registration wins
 // (with a warning). Convention: `<owner>` matching the table prefix
 // (`catalog`, `manifest`, `vector`, etc.).
+// Comments removed, so nothing downstream ever parses prose as DDL.
+//
+// Done to the WHOLE script before anything splits or counts, because both
+// operations are wrong on a comment: a comma inside one ends a clause, and a
+// bracket inside one unbalances the walk that finds a table body. Stripping
+// per-clause after the split cannot work — by then the damage is done, and the
+// fragment after the comma no longer starts with `--` so it never gets
+// stripped at all. That produced real columns named `and`, `a` and `which` on
+// a live deployment, from the prose of the schema's own comments, while the
+// columns that comment described were silently omitted.
+function stripSqlComments(sqlScript) {
+    return String(sqlScript ?? '')
+        // Block comments first: one may span the `--` of a line comment.
+        .replace(/\/\*[\s\S]*?\*\//g, ' ')
+        // To end of line, while the newlines are still there to end at.
+        .replace(/--[^\n]*/g, '')
+}
+
 // Column names a CREATE TABLE body declares, in order.
 //
 // Only the leading identifier of each top-level comma-separated clause, and
 // only when it is not a table constraint. Good enough for the schemas this
 // engine registers, and deliberately not a SQL parser.
 function columnsFrom(sqlScript, table) {
+    const clean = stripSqlComments(sqlScript)
     const re = new RegExp(
         `CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?[\`"'\\[]?${table}[\`"'\\]]?\\s*\\(`, 'i')
-    const m = re.exec(sqlScript)
+    const m = re.exec(clean)
     if (!m) return []
     // Walk to the matching close paren so nested types and CHECK(...) do not
     // end the body early.
     let depth = 1
     let i = m.index + m[0].length
     const start = i
-    for (; i < sqlScript.length && depth > 0; i++) {
-        if (sqlScript[i] === '(') depth++
-        else if (sqlScript[i] === ')') depth--
+    for (; i < clean.length && depth > 0; i++) {
+        if (clean[i] === '(') depth++
+        else if (clean[i] === ')') depth--
     }
-    const body = sqlScript.slice(start, i - 1)
+    const body = clean.slice(start, i - 1)
 
     const clauses = []
     let current = ''
@@ -137,9 +156,9 @@ function columnsFrom(sqlScript, table) {
 
     const CONSTRAINTS = new Set(['primary', 'unique', 'foreign', 'check', 'constraint'])
     return clauses
-        .map(clause => clause.replace(/--[^\n]*/g, '').trim())
+        .map(clause => clause.trim())
         .filter(Boolean)
-        .map(clause => clause.split(/\s+/)[0].replace(/["`\[\]]/g, ''))
+        .map(clause => clause.split(/\s+/)[0].replace(/["\`\[\]]/g, ''))
         .filter(name => name && !CONSTRAINTS.has(name.toLowerCase()))
 }
 
@@ -161,7 +180,8 @@ function migrateDurableColumns(handle, schemas, logger) {
                 existing = new Set(handle.prepare(`PRAGMA table_info("${table}")`).all().map(c => c.name))
             } catch { continue }
             if (!existing.size) continue
-            for (const column of columnsFrom(sql, table)) {
+            const declared = columnsFrom(sql, table)
+            for (const column of declared) {
                 if (existing.has(column)) continue
                 // Only ever ADD. Dropping or retyping a column in a durable
                 // table would discard data the whole flag exists to keep.
@@ -169,9 +189,28 @@ function migrateDurableColumns(handle, schemas, logger) {
                     handle.exec(`ALTER TABLE "${table}" ADD COLUMN "${column}"`)
                     logger?.info('Durable table %s gained column %s', table, column)
                 } catch (err) {
-                    logger?.warn('Could not add column %s to %s: %s', column, table, err.message)
+                    logger?.error('Could not add column %s to %s: %s', column, table, err.message)
                 }
             }
+
+            // Verify, rather than assume the loop above was enough.
+            //
+            // Silence was the dangerous half of the last bug here: the
+            // migration logged what it ADDED and never what it failed to find,
+            // so a parser that quietly omitted a column produced a clean-
+            // looking upgrade and a write that failed days later on a
+            // deployment. A declared column that is still missing after this
+            // runs is a fault in the migration itself, and has to say so here
+            // rather than surface as "no such column" at the first write.
+            const after = new Set(
+                handle.prepare(`PRAGMA table_info("${table}")`).all().map(c => c.name))
+            const missing = declared.filter(column => !after.has(column))
+            if (missing.length) {
+                logger?.error(
+                    'Durable table %s is missing declared column(s): %s. Writes naming them will fail — this is a '
+                    + 'fault in the schema migration, not in the caller.',
+                    table, missing.join(', '))
+            }
         }
     }
 }
@@ -189,9 +228,12 @@ function schemaEntry(value) {
 
 function tableNamesFrom(sqlScript) {
     const names = []
+    // Comments stripped for the same reason columnsFrom strips them: a
+    // comment that happens to mention CREATE TABLE would otherwise register a
+    // table that does not exist.
     const re = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"'\[]?([A-Za-z_][\w$]*)/gi
     let m
-    while ((m = re.exec(sqlScript))) names.push(m[1])
+    while ((m = re.exec(stripSqlComments(sqlScript)))) names.push(m[1])
     return names
 }