@nuxodin/item 0.6.4 → 0.6.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxodin/item",
-  "version": "0.6.4",
+  "version": "0.6.7",
   "description": "Reactive state library",
   "type": "module",
   "license": "MIT",

package/tools/schema/db/mysql/from-db.js

@@ -1,11 +1,11 @@
 // mysql/from-db.js
 import { schemaFromDb as _schemaFromDb } from '../shared/from-db.js'
-import { quoteId } from '../shared/sql.js'
+import { queryRows, quoteId } from '../shared/sql.js'
 import { schemaFromField } from './from-field.js'
 
 const dialect = {
-    tables:    async (query) => (await query('SHOW TABLES')).map(r => Object.values(r)[0]),
-    fields:    async (query, table) => query(`SHOW FULL FIELDS FROM ${quoteId(table)}`),
+    tables:    async (query) => (await queryRows(query, 'SHOW TABLES')).map(r => Object.values(r)[0]),
+    fields:    async (query, table) => queryRows(query, `SHOW FULL FIELDS FROM ${quoteId(table)}`),
     fromField: (row) => ({
         name:       row.Field,
         prop:       schemaFromField(row),

package/tools/schema/db/mysql/from-field.js

@@ -90,7 +90,7 @@ export function schemaFromField(row) {
     };
   } else prop.type = "string";
 
-  if (row.Default != null) prop.default = row.Default;
+  if (row.Default != null) prop.default = parseDefault(row.Default, prop.type);
   if (row.Comment) prop["$comment"] = row.Comment;
   if (row.Key === "PRI") prop["x-index"] = "primary";
   if (row.Key === "UNI") prop["x-index"] = "unique";
@@ -99,3 +99,12 @@ export function schemaFromField(row) {
 
   return prop;
 }
+
+/** SHOW FULL FIELDS hands the default back as text — read it as the value the schema would declare. */
+function parseDefault(value, type) {
+  const v = String(value);
+  const n = Number(v);
+  if (type === "boolean") return v !== "0";
+  if ((type === "integer" || type === "number") && !isNaN(n)) return n;
+  return v;
+}

package/tools/schema/db/mysql/to-db.js

@@ -2,6 +2,7 @@
 import { schemaFromDb } from "./from-db.js";
 import { quoteId, toFieldDef } from "./to-field.js";
 import { schemaDiff } from "../../diff.js";
+import { fieldNeedsDdl } from "../shared/needs-ddl.js";
 
 function tableData(tableSchema) {
   const row = tableSchema.additionalProperties ?? {};
@@ -14,26 +15,10 @@ function primaryFields(fields) {
   return fields.filter(([, f]) => f["x-index"] === "primary").map(([n]) => n);
 }
 
-const columnProps = new Set([
-  "type", "format", "contentEncoding", "maxLength", "minLength",
-  "minimum", "maximum", "multipleOf", "$comment",
-]);
-
 function hasOwn(obj, key) {
   return Object.prototype.hasOwnProperty.call(obj, key);
 }
 
-function fieldChanged(diffs, table, field, prop) {
-  return diffs.some(d =>
-    d.path[0] === "properties" &&
-    d.path[1] === table &&
-    d.path[2] === "additionalProperties" &&
-    d.path[3] === "properties" &&
-    d.path[4] === field &&
-    (columnProps.has(d.property) || d.property === "default" && hasOwn(prop, "default"))
-  );
-}
-
 function preserveDefault(prop, currProp) {
   return hasOwn(prop, "default") || !hasOwn(currProp, "default")
     ? prop
@@ -153,7 +138,8 @@ export async function schemaToDb(
       const { fields: currFieldEntries, required: currRequired } = tableData(
         current.properties[table],
       );
-      const currFields = Object.keys(Object.fromEntries(currFieldEntries));
+      const currFields = new Map(currFieldEntries);
+      const nextFieldNames = new Set(fields.map(([n]) => n));
       const indexStmts = await indexStatements(
         query,
         table,
@@ -165,20 +151,21 @@ export async function schemaToDb(
       const autoAfter = new Map();
       for (const [name, prop] of fields) {
         const isRequired = required.has(name);
-        const curr = currFieldEntries.find(([n]) => n === name);
-        const propWithDefault = curr ? preserveDefault(prop, curr[1]) : prop;
+        const currProp = currFields.get(name);
+        const propWithDefault = currProp ? preserveDefault(prop, currProp) : prop;
         const fieldProp = propWithDefault["x-autoincrement"] ? { ...propWithDefault, "x-autoincrement": false } : propWithDefault;
         const fieldDef = toFieldDef(name, fieldProp, { required: isRequired });
-        if (!currFields.includes(name)) {
+        if (!currProp) {
           stmts.push(`ALTER TABLE ${tableId} ADD COLUMN ${fieldDef};`);
           if (prop["x-autoincrement"]) autoAfter.set(name, prop);
         } else {
-          const hasAuto = !!curr?.[1]["x-autoincrement"];
+          const hasAuto = !!currProp["x-autoincrement"];
           const wantsAuto = !!prop["x-autoincrement"];
-          const wantsChange = fieldChanged(diffs, table, name, prop) ||
+          // AUTO_INCREMENT is added and dropped by its own statements below, so it stays out of here
+          const wantsChange = fieldNeedsDdl(fieldProp, { ...currProp, "x-autoincrement": false }, ["multipleOf", "$comment"]) ||
             isRequired !== currRequired.has(name) ||
             hasAuto && !wantsAuto;
-          const changed = wantsChange && fieldDef !== toFieldDef(name, curr[1], { required: currRequired.has(name) });
+          const changed = wantsChange && fieldDef !== toFieldDef(name, currProp, { required: currRequired.has(name) });
           if (changed) {
             stmts.push(`ALTER TABLE ${tableId} MODIFY COLUMN ${fieldDef};`);
           }
@@ -186,8 +173,8 @@ export async function schemaToDb(
         }
       }
       if (!patch) {
-        for (const name of currFields) {
-          if (!fields.find(([n]) => n === name)) {
+        for (const name of currFields.keys()) {
+          if (!nextFieldNames.has(name)) {
             stmts.push(`ALTER TABLE ${tableId} DROP COLUMN ${quoteId(name)};`);
           }
         }

package/tools/schema/db/pg/from-field.js

@@ -46,7 +46,7 @@ export function schemaFromField(row) {
     } else if (type === 'json' || type === 'jsonb') prop.type = 'object'
     else prop.type = 'string'
 
-    const def = defaultValue(row.column_default, prop)
+    const def = parseDefault(row.column_default, prop.type)
     if (def !== undefined) prop.default = def
     if (row.comment) prop['$comment'] = row.comment
     if (row.is_primary) prop['x-index'] = 'primary'
@@ -56,16 +56,13 @@ export function schemaFromField(row) {
     return prop
 }
 
-function defaultValue(value, prop) {
+/** information_schema hands the default back as an SQL literal — read it as the value the schema would declare. */
+function parseDefault(value, type) {
     if (value == null || /^nextval\(/i.test(value) || /\b(current_|now\()/i.test(value)) return undefined
     let v = String(value).replace(/::[\w\s.[\]"]+$/i, '')
     if (/^'.*'$/.test(v)) v = v.slice(1, -1).replace(/''/g, "'")
-    if (prop.type === 'boolean') return /^(true|t|1)$/i.test(v)
-    if (prop.type === 'integer') return numberOr(v, Number.parseInt(v, 10))
-    if (prop.type === 'number') return numberOr(v, Number(v))
+    const n = Number(v)
+    if (type === 'boolean') return /^(true|t|1)$/i.test(v)
+    if ((type === 'integer' || type === 'number') && !isNaN(n)) return n
     return v
 }
-
-function numberOr(fallback, value) {
-    return Number.isNaN(value) ? fallback : value
-}

package/tools/schema/db/pg/to-db.js

@@ -3,6 +3,7 @@ import { schemaFromDb } from './from-db.js'
 import { queryRows } from '../shared/sql.js'
 import { defaultLiteral, quoteId, quoteLit, toFieldDef, typeSql } from './to-field.js'
 import { schemaDiff } from '../../diff.js'
+import { fieldNeedsDdl } from '../shared/needs-ddl.js'
 
 function tableData(tableSchema) {
     const row = tableSchema.additionalProperties ?? {}
@@ -15,11 +16,6 @@ function primaryFields(fields) {
     return fields.filter(([, f]) => f['x-index'] === 'primary').map(([n]) => n)
 }
 
-const columnProps = new Set([
-    'type', 'format', 'contentEncoding', 'maxLength', 'minLength',
-    'minimum', 'maximum', 'multipleOf',
-])
-
 function hasOwn(obj, key) {
     return Object.prototype.hasOwnProperty.call(obj, key)
 }
@@ -30,14 +26,6 @@ function setEqual(a, b) {
     return true
 }
 
-function fieldChanged(diffs, table, field, prop) {
-    return diffs.some(d => {
-        const [a, b, c, e, f] = d.path
-        return a === 'properties' && b === table && c === 'additionalProperties' && e === 'properties' && f === field &&
-            (columnProps.has(d.property) || d.property === 'default' && hasOwn(prop, 'default') || d.property === 'x-autoincrement')
-    })
-}
-
 function preserveDefault(prop, currProp) {
     return hasOwn(prop, 'default') || !hasOwn(currProp, 'default')
         ? prop
@@ -163,7 +151,8 @@ export async function schemaToDb(schema, query, { force = false, patch = false }
                     continue
                 }
                 const propWithDefault = preserveDefault(prop, currProp)
-                const changed = fieldChanged(diffs, table, name, prop) || isRequired !== currRequired.has(name) || propWithDefault['$comment'] !== currProp['$comment']
+                const changed = fieldNeedsDdl(propWithDefault, currProp, ['multipleOf', '$comment']) ||
+                    isRequired !== currRequired.has(name)
                 if (changed) stmts.push(...alterFieldStmts(table, name, propWithDefault, currProp, isRequired, currRequired.has(name), changed))
             }
             if (!patch) {

package/tools/schema/db/shared/needs-ddl.js

@@ -0,0 +1,28 @@
+// shared/needs-ddl.js — does the existing column still satisfy the schema?
+//
+// The schema travels with the database and holds what no DDL expresses (pattern, enum, required,
+// x-*). Reconstructing a schema from the database is lossy, so comparing the two for equality
+// turns every gap into a change and rebuilds every table forever. Each property gets the question
+// that fits it: capacity asks whether the column still holds what the schema wants (widen only),
+// structural asks for equality, everything else is enforced by the application alone.
+import { schemaType } from './sql.js'
+
+const capacity = {
+    maximum:   (need, have) => have >= need,
+    minimum:   (need, have) => have <= need,
+    maxLength: (need, have) => have >= need,
+}
+
+const structural = ['format', 'contentEncoding', 'x-index', 'default']
+
+/** @param dialectStructural properties this dialect renders too, e.g. 'multipleOf' on MySQL. */
+export function fieldNeedsDdl(next, curr, dialectStructural = []) {
+    for (const [prop, holds] of Object.entries(capacity)) {
+        const need = next[prop], have = curr[prop]
+        // no requirement, or a bound the database never reported — nothing to widen towards
+        if (need !== undefined && have !== undefined && !holds(need, have)) return true
+    }
+    if (schemaType(next) !== schemaType(curr)) return true
+    if (!!next['x-autoincrement'] !== !!curr['x-autoincrement']) return true
+    return [...structural, ...dialectStructural].some(prop => next[prop] !== curr[prop])
+}

package/tools/schema/db/sqlite/from-db.js

@@ -1,14 +1,14 @@
 // sqlite/from-db.js
 import { schemaFromDb as _schemaFromDb } from '../shared/from-db.js'
-import { quoteId } from '../shared/sql.js'
+import { queryRows, quoteId } from '../shared/sql.js'
 import { schemaFromField } from './from-field.js'
 
 /** Single-column, non-constraint indexes: [{ name, column, unique }]. */
 export async function singleColumnIndexes(query, table) {
     const out = []
-    for (const row of await query(`PRAGMA index_list(${quoteId(table)})`)) {
+    for (const row of await queryRows(query, `PRAGMA index_list(${quoteId(table)})`)) {
         if (row.origin && row.origin !== 'c') continue
-        const cols = await query(`PRAGMA index_info(${quoteId(row.name)})`)
+        const cols = await queryRows(query, `PRAGMA index_info(${quoteId(row.name)})`)
         if (cols.length === 1) out.push({ name: row.name, column: cols[0].name, unique: !!row.unique })
     }
     return out
@@ -22,11 +22,15 @@ async function indexes(query, table) {
 }
 
 const dialect = {
-    tables:    async (query) => (await query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")).map(r => r.name),
+    tables:    async (query) => (await queryRows(query, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")).map(r => r.name),
     fields:    async (query, table) => {
         const ix = await indexes(query, table)
-        return (await query(`PRAGMA table_info(${quoteId(table)})`)).map(row =>
-            row.pk || !ix.has(row.name) ? row : { ...row, index: ix.get(row.name) }
+        // AUTOINCREMENT survives only in the stored DDL — no PRAGMA reports it
+        const [master] = await queryRows(query, `SELECT sql FROM sqlite_master WHERE type='table' AND name='${table.replaceAll("'", "''")}'`)
+        const auto = /\bautoincrement\b/i.test(master?.sql ?? '')
+        return (await queryRows(query, `PRAGMA table_info(${quoteId(table)})`)).map(row =>
+            row.pk ? { ...row, autoincrement: auto }
+                   : ix.has(row.name) ? { ...row, index: ix.get(row.name) } : row
         )
     },
     fromField: (row) => ({

package/tools/schema/db/sqlite/from-field.js

@@ -2,14 +2,11 @@
 // PRAGMA table_info returns: cid, name, type, notnull, dflt_value, pk
 // SQLite lengths are in characters — no byte conversion needed
 
-const intRanges = {
-    tinyint:   { signed: [-128, 127]                           },
-    smallint:  { signed: [-32768, 32767]                       },
-    mediumint: { signed: [-8388608, 8388607]                   },
-    int:       { signed: [-2147483648, 2147483647]             },
-    integer:   { signed: [-2147483648, 2147483647]             },
-    bigint:    { signed: [-9007199254740991, 9007199254740991] }, // JS safe
-}
+// SQLite does not enforce a declared integer width — a TINYINT column happily stores 5000.
+// So every spelling reports the same, real bound: the INTEGER storage class, capped where a
+// JS number stops being exact.
+const intTypes = new Set(['tinyint', 'smallint', 'mediumint', 'int', 'integer', 'bigint'])
+const intMax = 9007199254740991
 
 export function schemaFromField(row) {
     const prop = {}
@@ -18,9 +15,8 @@ export function schemaFromField(row) {
     const type = m?.[1]?.toLowerCase() ?? 'text'
     const len  = m?.[2] ? parseInt(m[2]) : null
 
-    if (type in intRanges) {
-        const [min, max] = intRanges[type].signed
-        prop.type = 'integer'; prop.minimum = min; prop.maximum = max
+    if (intTypes.has(type)) {
+        prop.type = 'integer'; prop.minimum = -intMax; prop.maximum = intMax
 
     } else if (type === 'boolean' || type === 'bool') { prop.type = 'boolean'
     } else if (type === 'real' || type === 'float' || type === 'double') { prop.type = 'number'
@@ -41,9 +37,20 @@ export function schemaFromField(row) {
         prop.type = 'string'
     }
 
-    if (row.dflt_value != null) prop.default    = row.dflt_value
+    if (row.dflt_value != null) prop.default    = parseDefault(row.dflt_value, prop.type)
     if (row.pk)                 prop['x-index'] = 'primary'
     else if (row.index)         prop['x-index'] = row.index
+    if (row.autoincrement)      prop['x-autoincrement'] = true
 
     return prop
 }
+
+/** PRAGMA hands back the raw SQL literal — read it as the value the schema would declare. */
+function parseDefault(raw, type) {
+    const v = String(raw).trim()
+    const n = Number(v)
+    if (/^'[\s\S]*'$/.test(v)) return v.slice(1, -1).replaceAll("''", "'")
+    if (type === 'boolean') return v !== '0'
+    if ((type === 'integer' || type === 'number') && !isNaN(n)) return n
+    return v
+}

package/tools/schema/db/sqlite/to-db.js

@@ -4,6 +4,7 @@ import { schemaFromDb, singleColumnIndexes } from './from-db.js'
 import { toFieldDef }   from './to-field.js'
 import { quoteId, schemaType } from '../shared/sql.js'
 import { schemaDiff }   from '../../diff.js'
+import { fieldNeedsDdl } from '../shared/needs-ddl.js'
 
 function tableFields(tableSchema) {
     return Object.entries(tableSchema.additionalProperties?.properties ?? {})
@@ -88,13 +89,17 @@ export async function schemaToDb(schema, query, { force = false, patch = false }
             stmts.push(`CREATE TABLE ${quoteId(table)} (\n${createBody(fields, primaries)}\n);`)
             stmts.push(...indexStatements(table, fields, primaries))
         } else {
-            const currFields = Object.keys(current.properties[table]?.additionalProperties?.properties ?? {})
-            const hasChanges = diffs.some(d => d.path[0] === 'properties' && d.path[1] === table)
-            const hasDrops   = !patch && currFields.some(n => !fields.find(([fn]) => fn === n))
+            const currFields = new Map(tableFields(current.properties[table]))
+            const nextFieldNames = new Set(fields.map(([n]) => n))
+            // A new plain column is an ADD COLUMN; only a new key column needs the rebuild.
+            const hasChanges = fields.some(([name, prop]) => currFields.has(name)
+                ? fieldNeedsDdl(prop, currFields.get(name))
+                : prop['x-index'] === 'primary' || prop['x-autoincrement'])
+            const hasDrops   = !patch && [...currFields.keys()].some(n => !nextFieldNames.has(n))
 
-            if (hasChanges && (hasDrops || !patch)) {
+            if (hasDrops || hasChanges && !patch) {
                 const tmp      = `${table}_migration_tmp`
-                const keep     = fields.map(([n]) => n).filter(n => currFields.includes(n))
+                const keep     = fields.map(([n]) => n).filter(n => currFields.has(n))
                 const colsList = keep.map(quoteId).join(', ')
 
                 stmts.push(`CREATE TABLE ${quoteId(tmp)} (\n${createBody(fields, primaries)}\n);`)
@@ -104,7 +109,7 @@ export async function schemaToDb(schema, query, { force = false, patch = false }
                 stmts.push(...indexStatements(table, fields, primaries))
             } else {
                 for (const [name, prop] of fields) {
-                    if (!currFields.includes(name))
+                    if (!currFields.has(name))
                         stmts.push(`ALTER TABLE ${quoteId(table)} ADD COLUMN ${toFieldDef(name, prop)};`)
                 }
                 stmts.push(...indexStatements(table, fields, primaries, await singleColumnIndexes(query, table), { patch }))