@nuxodin/item 0.6.4

package/tools/schema/build/input.js

@@ -0,0 +1,120 @@
+
+export function inputNode(schema = {}, { value, required, disabled, name } = {}) {
+    if (value != null && typeof value === 'object') {
+        console.warn('inputNode: value is object', schema, value)
+        value = '-'
+    }
+
+    const node = schema.enum ? selectNode(schema) : nativeNode(schema)
+
+    if (schema.examples?.[0] != null) node.attrs.placeholder = schema.examples[0]
+    else if (schema.description)      node.attrs.placeholder = schema.description
+
+    if (required)         node.attrs.required = true
+    if (disabled)         node.attrs.disabled = true
+    if (schema.readOnly)  node.attrs.readonly = true
+    if (schema.title)     node.attrs.title    = schema.title
+    if (name)             node.attrs.name     = name
+
+    applyValue(node, value ?? schema.default)
+
+    if (schema['x-html']) {
+        const { tag, ...attrs } = schema['x-html']
+        if (tag) node.tag = tag
+        Object.assign(node.attrs, attrs)
+    }
+
+    return node
+}
+
+function resolveType(schema) {
+    const { type, format, contentEncoding, writeOnly, maxLength } = schema
+    if (writeOnly)                    return 'password'
+    if (schema.const != null)         return 'text'
+    if (contentEncoding === 'base64') return 'file'
+    if (format === 'date')            return 'date'
+    if (format === 'date-time')       return 'datetime-local'
+    if (format === 'time')            return 'time'
+    if (format === 'email')           return 'email'
+    if (format === 'uri')             return 'url'
+    if (format === 'color')           return 'color'
+    if (type === 'integer')           return 'number'
+    if (type === 'number')            return 'number'
+    if (type === 'boolean')           return 'checkbox'
+    if (schema['x-multiline'] != null) return schema['x-multiline'] ? 'textarea' : 'text'
+    if (type === 'string' && (maxLength??0) > 100) return 'textarea'
+    return 'text'
+}
+
+// ── internals ─────────────────────────────────────────────────────────────────
+
+function nativeNode(schema) {
+    const type = resolveType(schema)
+
+    if (type === 'textarea') {
+        const attrs = {}
+        if (schema.maxLength != null) attrs.maxlength = schema.maxLength
+        if (schema.minLength != null) attrs.minlength = schema.minLength
+        return { tag: 'textarea', attrs, children: [] }
+    }
+
+    const attrs = { type }
+
+    if (type === 'number') {
+        const isInt = schema.type === 'integer'
+        attrs.step = schema.multipleOf ?? (isInt ? 1 : 'any')
+        if (schema.minimum          != null) attrs.min = schema.minimum
+        if (schema.maximum          != null) attrs.max = schema.maximum
+        if (schema.exclusiveMinimum != null) attrs.min = isInt ? schema.exclusiveMinimum + 1 : schema.exclusiveMinimum + Number.EPSILON
+        if (schema.exclusiveMaximum != null) attrs.max = isInt ? schema.exclusiveMaximum - 1 : schema.exclusiveMaximum - Number.EPSILON
+    }
+
+    if (type === 'text') {
+        if (schema.maxLength != null) attrs.maxlength = schema.maxLength
+        if (schema.minLength != null) attrs.minlength = schema.minLength
+        if (schema.pattern)           attrs.pattern   = schema.pattern
+    }
+
+    if (type === 'file' && schema.contentMediaType) attrs.accept = schema.contentMediaType
+
+    if (schema.const != null) attrs.readonly = true
+
+    return { tag: 'input', attrs }
+}
+
+function selectNode(schema) {
+    const nullable = Array.isArray(schema.type)
+        ? schema.type.includes('null')
+        : schema.type === 'null'
+
+    const children = []
+    if (nullable) children.push({ tag: 'option', attrs: { value: '' }, children: ['—'] })
+    for (const v of schema.enum) {
+        children.push({
+            tag: 'option',
+            attrs: { value: v ?? '' },
+            children: [v == null ? '—' : String(v)],
+        })
+    }
+
+    return { tag: 'select', attrs: {}, children }
+}
+
+function applyValue(node, value) {
+    if (node.tag === 'input' && node.attrs.type === 'checkbox') {
+        if (value == null) node.attrs.indeterminate = true
+        else if (value)    node.attrs.checked       = true
+        return
+    }
+    if (node.tag === 'select') {
+        const str = value == null ? '' : String(value)
+        for (const opt of node.children) {
+            if (String(opt.attrs.value) === str) { opt.attrs.selected = true; break }
+        }
+        return
+    }
+    if (value == null) return
+    const str = String(value)
+    if (node.tag === 'textarea') node.children = [str]
+    else                          node.attrs.value = str
+}

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

@@ -0,0 +1,29 @@
+// indexeddb/from-db.js
+import { schemaFromDb as _schemaFromDb } from '../shared/from-db.js'
+
+const dialect = {
+    tables: (db) => Array.from(db.objectStoreNames),
+
+    fields: (db, table) => {
+        const store = db.transaction(table).objectStore(table)
+        const fields = []
+        const keyPath = Array.isArray(store.keyPath) ? store.keyPath[0] : store.keyPath
+        if (keyPath) fields.push({ name: keyPath, isPrimary: true, autoIncrement: store.autoIncrement })
+        for (const name of store.indexNames) {
+            const idx = store.index(name)
+            fields.push({ name, isUnique: idx.unique })
+        }
+        return fields
+    },
+
+    fromField: (row) => {
+        const prop = {}
+        if (row.isPrimary)     prop['x-index']       = 'primary'
+        if (row.isUnique)      prop['x-index']       = 'unique'
+        if (row.autoIncrement) prop['x-autoincrement'] = true
+        // no type info available — IndexedDB is schemaless
+        return { name: row.name, prop, isRequired: !!row.isPrimary }
+    },
+}
+
+export const schemaFromDb = (db) => _schemaFromDb(db, dialect)

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

@@ -0,0 +1,115 @@
+// indexeddb/to-db.js
+
+const STRUCTURAL = new Set([
+    'properties',
+    'additionalProperties',
+    'x-index',
+    'x-autoincrement',
+])
+
+function stripMeta(v, keepKeys = false) {
+    if (Array.isArray(v)) return v.map(x => stripMeta(x))
+    if (v !== null && typeof v === 'object') {
+        const entries = keepKeys ? Object.entries(v) : Object.entries(v).filter(([k]) => STRUCTURAL.has(k))
+        return Object.fromEntries(entries.map(([k, val]) => [k, stripMeta(val, k === 'properties')]))
+    }
+    return v
+}
+
+function indexOptions(table, name, prop) {
+    if (prop['x-index'] === 'unique') return { unique: true }
+    if (prop['x-index'] === true) return { unique: false }
+    if (prop['x-index'] === 'fulltext')
+        console.warn(`Skip fulltext index ${table}.${name}: IndexedDB has no native fulltext index`)
+    return null
+}
+
+function sameKeyPath(a, b) {
+    return JSON.stringify(a ?? null) === JSON.stringify(b ?? null)
+}
+
+function sameIndex(index, opts) {
+    return index.unique === opts.unique
+}
+
+async function schemaVersion(schema, dbName = 'default') {
+    const buf  = await crypto.subtle.digest('SHA-1', new TextEncoder().encode(JSON.stringify(stripMeta(schema))))
+    const hash = Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2,'0')).join('')
+    const key  = 'idb-schema-versions:' + dbName
+    const map  = JSON.parse(localStorage.getItem(key) || '{}')
+    
+    const vActual = Math.max(0, ...Object.values(map));
+    const vStored = map?.[hash] ?? 0;
+
+    if (!vStored || vActual > vStored) {
+        map[hash] = vActual + 1
+        localStorage.setItem(key, JSON.stringify(map))
+    }
+    return map[hash]
+}
+
+/**
+ * @param {string} name
+ * @param {object|null} schema
+ * @param {object} [options]
+ * @param {number|null} [options.version=null]
+ * @param {boolean} [options.patch=true]
+ * @param {function|null} [options.upgrade=null] - Called in onupgradeneeded after schema migration. (e: IDBVersionChangeEvent) => void
+ */
+export async function openDb(name, schema, { patch = true, version = null, upgrade = null } = {}) {
+    if (upgrade && version == null) throw new Error('openDb: "upgrade" requires a manual "version"')
+    if (version == null && schema) version = await schemaVersion(schema, name);
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.open(name, version);
+        req.onupgradeneeded = (e) => {
+            if (schema) schemaToDb(schema, e.target.result, e.target.transaction, { patch });
+            upgrade?.(e)
+        }
+        req.onsuccess = (e) => resolve(e.target.result);
+        req.onerror = (e) => reject(e.target.error);
+    })
+}
+
+// tx = upgrade transaction from onupgradeneeded (e.target.transaction)
+export function schemaToDb(schema, db, tx, { patch = false } = {}) {
+    const tables = Object.keys(schema.properties ?? {})
+
+    for (const table of tables) {
+        const fields  = Object.entries(schema.properties[table]?.additionalProperties?.properties ?? {})
+        const primaries = fields.filter(([, f]) => f['x-index'] === 'primary')
+        const keyPath = primaries.length > 1 ? primaries.map(([n]) => n) : primaries[0]?.[0]
+
+        if (!db.objectStoreNames.contains(table)) {
+            const store = db.createObjectStore(table, {
+                keyPath:       keyPath,
+                autoIncrement: !!primaries[0]?.[1]?.['x-autoincrement'],
+            })
+            for (const [name, prop] of fields) {
+                const opts = indexOptions(table, name, prop)
+                if (opts) store.createIndex(name, name, opts)
+            }
+        } else {
+            const store = tx.objectStore(table)
+            if (!sameKeyPath(store.keyPath, keyPath) || store.autoIncrement !== !!primaries[0]?.[1]?.['x-autoincrement'])
+                throw new Error(`IndexedDB objectStore ${table}: changing keyPath/autoIncrement requires a manual migration`)
+            for (const [name, prop] of fields) {
+                const opts = indexOptions(table, name, prop)
+                if (!opts) continue
+                if (store.indexNames.contains(name)) {
+                    if (sameIndex(store.index(name), opts)) continue
+                    store.deleteIndex(name)
+                }
+                store.createIndex(name, name, opts)
+            }
+            if (!patch) {
+                for (const name of Array.from(store.indexNames))
+                    if (!fields.find(([n]) => n === name)) store.deleteIndex(name)
+            }
+        }
+    }
+
+    if (!patch) {
+        for (const name of Array.from(db.objectStoreNames))
+            if (!tables.includes(name)) db.deleteObjectStore(name)
+    }
+}

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

@@ -0,0 +1,16 @@
+// mysql/from-db.js
+import { schemaFromDb as _schemaFromDb } from '../shared/from-db.js'
+import { 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)}`),
+    fromField: (row) => ({
+        name:       row.Field,
+        prop:       schemaFromField(row),
+        isRequired: row.Null === 'NO',
+    }),
+}
+
+export const schemaFromDb = (query) => _schemaFromDb(query, dialect)

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

@@ -0,0 +1,101 @@
+// mysql/schema-from-field.js
+// Note: MySQL VARCHAR/CHAR lengths are in characters; TEXT sizes are byte caps.
+
+const intRanges = {
+  tinyint: { signed: [-128, 127], unsigned: [0, 255] },
+  smallint: { signed: [-32768, 32767], unsigned: [0, 65535] },
+  mediumint: { signed: [-8388608, 8388607], unsigned: [0, 16777215] },
+  int: { signed: [], unsigned: [0, 4294967295] },
+  integer: { signed: [], unsigned: [0, 4294967295] },
+  bigint: {
+    signed: [-9007199254740991, 9007199254740991],
+    unsigned: [0, 9007199254740991],
+  }, // JS safe
+};
+const textBytes = {
+  tinytext: 255,
+  text: 65535,
+  mediumtext: 16777215,
+  longtext: 4294967295,
+};
+const B = 4; // bytes per char, worst-case utf8mb4
+
+export function schemaFromField(row) {
+  const prop = {};
+  const unsigned = /unsigned/i.test(row.Type);
+  const isAuto = /auto_increment/i.test(row.Extra ?? "");
+  const [rawType, rawLen] = row.Type.replace(/\s*unsigned/i, "").split(/[()]/);
+  const type = rawType.trim().toLowerCase();
+  const len = rawLen ? parseInt(rawLen) : null;
+
+  if (type === "tinyint" && len === 1) {
+    prop.type = "boolean";
+  } else if (type in intRanges) {
+    const [min, max] = intRanges[type][unsigned ? "unsigned" : "signed"];
+    prop.type = "integer";
+    if (min != null && max != null && !(isAuto && (type === "int" || type === "integer"))) {
+      prop.minimum = min;
+      prop.maximum = max;
+    }
+  } else if (type === "float" || type === "double" || type === "real") {
+    prop.type = "number";
+  } else if (type === "decimal" || type === "numeric") {
+    prop.type = "number";
+    const scale = rawLen ? parseInt(rawLen.split(",")[1] ?? 0) : 0;
+    if (scale > 0) prop.multipleOf = Math.pow(10, -scale);
+  } else if (type === "char") {
+    prop.type = "string";
+    prop.minLength = len;
+    prop.maxLength = len;
+  } else if (type === "varchar") {
+    prop.type = "string";
+    prop.maxLength = len;
+  } else if (type in textBytes) {
+    prop.type = "string";
+    if (type !== "text") prop.maxLength = Math.floor(textBytes[type] / B);
+  } else if (type === "binary") {
+    prop.type = "string";
+    prop.contentEncoding = "base64";
+    prop.minLength = len;
+    prop.maxLength = len;
+  } else if (type === "varbinary") {
+    prop.type = "string";
+    prop.contentEncoding = "base64";
+    prop.maxLength = len;
+  } else if (/blob/.test(type)) {
+    prop.type = "string";
+    prop.contentEncoding = "base64";
+  } else if (type === "date") {
+    prop.type = "string";
+    prop.format = "date";
+  } else if (type === "time") {
+    prop.type = "string";
+    prop.format = "time";
+  } else if (type === "datetime" || type === "timestamp") {
+    prop.type = "string";
+    prop.format = "date-time";
+  } else if (type === "year") {
+    prop.type = "integer";
+    prop.minimum = 1901;
+    prop.maximum = 2155;
+  } else if (type === "json") prop.type = "object";
+  else if (type === "enum") {
+    prop.type = "string";
+    prop.enum = rawLen.split(",").map((s) => s.replace(/'/g, ""));
+  } else if (type === "set") {
+    prop.type = "array";
+    prop.items = {
+      type: "string",
+      enum: rawLen.split(",").map((s) => s.replace(/'/g, "")),
+    };
+  } else prop.type = "string";
+
+  if (row.Default != null) prop.default = row.Default;
+  if (row.Comment) prop["$comment"] = row.Comment;
+  if (row.Key === "PRI") prop["x-index"] = "primary";
+  if (row.Key === "UNI") prop["x-index"] = "unique";
+  if (row.Key === "MUL") prop["x-index"] = true;
+  if (isAuto) prop["x-autoincrement"] = true;
+
+  return prop;
+}

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

@@ -0,0 +1,275 @@
+// mysql/to-db.js
+import { schemaFromDb } from "./from-db.js";
+import { quoteId, toFieldDef } from "./to-field.js";
+import { schemaDiff } from "../../diff.js";
+
+function tableData(tableSchema) {
+  const row = tableSchema.additionalProperties ?? {};
+  const fields = Object.entries(row.properties ?? {});
+  const required = new Set(row.required ?? []);
+  return { fields, required };
+}
+
+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
+    : { ...prop, default: currProp.default };
+}
+
+function setEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const v of a) if (!b.has(v)) return false;
+  return true;
+}
+
+function secondaryIndexKind(prop) {
+  if (prop["x-index"] === "unique") return "UNIQUE KEY";
+  if (prop["x-index"] === "fulltext") return "FULLTEXT KEY";
+  if (prop["x-index"] === true) return "KEY";
+  return null;
+}
+
+function usableIndexKind(table, name, prop) {
+  const kind = secondaryIndexKind(prop);
+  const issue = kind && indexIssue(table, name, prop, kind);
+  if (!issue) return kind;
+  console.warn(issue);
+  return null;
+}
+
+function indexIssue(table, name, prop, kind) {
+  const schemaType = Array.isArray(prop.type) ? prop.type.find(t => t !== "null") : prop.type;
+  if (kind === "FULLTEXT KEY") return schemaType === "string" && !prop.format && !prop.contentEncoding ? "" : `Skip ${kind} ${table}.${name}: fulltext indexes require plain string fields`;
+  if (schemaType !== "string" || prop.format || (prop.maxLength ?? Infinity) <= 191) return "";
+  const max = prop.maxLength ?? "unknown";
+  return `Skip ${kind} ${table}.${name}: string maxLength ${max} is too long for a normal index; use maxLength <= 191, x-index:"fulltext", or remove x-index`;
+}
+
+function secondaryIndexDef(table, name, prop) {
+  const kind = usableIndexKind(table, name, prop);
+  return kind && secondaryIndexSql(name, kind);
+}
+
+function secondaryIndexSql(name, kind) {
+  return `${kind} ${quoteId(name)} (${quoteId(name)})`;
+}
+
+async function tableIndexes(query, table) {
+  const rows = await query(`SHOW INDEX FROM ${quoteId(table)}`);
+  const primary = rows
+    .filter(row => row.Key_name === "PRIMARY")
+    .sort((a, b) => a.Seq_in_index - b.Seq_in_index)
+    .map(row => row.Column_name);
+  const grouped = new Map();
+  for (const row of rows) {
+    const key = row.Key_name;
+    if (key === "PRIMARY") continue;
+    if (!grouped.has(key)) grouped.set(key, []);
+    grouped.get(key).push(row);
+  }
+  const secondary = [...grouped.entries()]
+    .filter(([, rows]) => rows.length === 1)
+    .map(([key, [row]]) => ({
+      key,
+      column: row.Column_name,
+      nonUnique: row.Non_unique,
+      indexType: row.Index_type,
+      subPart: row.Sub_part,
+    }));
+  return { primary, secondary };
+}
+
+function autoIncrementField(fields) {
+  return fields.find(([, prop]) => prop["x-autoincrement"]);
+}
+
+export async function schemaToDb(
+  schema,
+  query,
+  { force = false, patch = false } = {},
+) {
+  const current = await schemaFromDb(query);
+  const diffs = schemaDiff(schema, current);
+
+  if (!patch) {
+    const destructive = diffs.filter((d) => d.destructive === true);
+    if (destructive.length && !force) {
+      const msgs = destructive.map((d) => `  ${d.path.join(".")} — ${d.msg}`).join("\n");
+      throw new Error(`Destructive schema changes detected (use force to apply):\n${msgs}`);
+    }
+  }
+
+  const stmts = [];
+  const nextTables = Object.keys(schema.properties ?? {});
+  const currTables = Object.keys(current.properties ?? {});
+
+  for (const table of nextTables) {
+    const tableId = quoteId(table);
+    const { fields, required } = tableData(schema.properties[table]);
+    const primaries = primaryFields(fields);
+    for (const p of primaries) required.add(p); // primary key columns are always NOT NULL
+
+    if (!currTables.includes(table)) {
+      const cols = fields.map(([n, f]) =>
+        "  " + toFieldDef(n, f, { required: required.has(n) })
+      ).join(",\n");
+      const pk = primaries.length
+        ? `,\n  PRIMARY KEY (${primaries.map(quoteId).join(", ")})`
+        : "";
+      const keys = fields
+        .filter(([n]) => !primaries.includes(n))
+        .map(([n, f]) => secondaryIndexDef(table, n, f))
+        .filter(Boolean)
+        .map((def) => ",\n  " + def)
+        .join("");
+      stmts.push(
+        `CREATE TABLE ${tableId} (\n${cols}${pk}${keys}\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`,
+      );
+    } else {
+      const { fields: currFieldEntries, required: currRequired } = tableData(
+        current.properties[table],
+      );
+      const currFields = Object.keys(Object.fromEntries(currFieldEntries));
+      const indexStmts = await indexStatements(
+        query,
+        table,
+        fields,
+        currFieldEntries,
+        { patch },
+      );
+      stmts.push(...indexStmts.before);
+      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 fieldProp = propWithDefault["x-autoincrement"] ? { ...propWithDefault, "x-autoincrement": false } : propWithDefault;
+        const fieldDef = toFieldDef(name, fieldProp, { required: isRequired });
+        if (!currFields.includes(name)) {
+          stmts.push(`ALTER TABLE ${tableId} ADD COLUMN ${fieldDef};`);
+          if (prop["x-autoincrement"]) autoAfter.set(name, prop);
+        } else {
+          const hasAuto = !!curr?.[1]["x-autoincrement"];
+          const wantsAuto = !!prop["x-autoincrement"];
+          const wantsChange = fieldChanged(diffs, table, name, prop) ||
+            isRequired !== currRequired.has(name) ||
+            hasAuto && !wantsAuto;
+          const changed = wantsChange && fieldDef !== toFieldDef(name, curr[1], { required: currRequired.has(name) });
+          if (changed) {
+            stmts.push(`ALTER TABLE ${tableId} MODIFY COLUMN ${fieldDef};`);
+          }
+          if (wantsAuto && (changed || !hasAuto)) autoAfter.set(name, propWithDefault);
+        }
+      }
+      if (!patch) {
+        for (const name of currFields) {
+          if (!fields.find(([n]) => n === name)) {
+            stmts.push(`ALTER TABLE ${tableId} DROP COLUMN ${quoteId(name)};`);
+          }
+        }
+      }
+      stmts.push(...indexStmts.after);
+      if (indexStmts.primaryChanged) {
+        const nextAuto = autoIncrementField(fields);
+        if (nextAuto) autoAfter.set(nextAuto[0], nextAuto[1]);
+      }
+      for (const [name, prop] of autoAfter) {
+        stmts.push(`ALTER TABLE ${tableId} MODIFY COLUMN ${toFieldDef(name, prop, { required: true })};`);
+      }
+    }
+  }
+
+  if (!patch) {
+    for (const table of currTables) {
+      if (!nextTables.includes(table)) stmts.push(`DROP TABLE ${quoteId(table)};`);
+    }
+  }
+
+  for (const stmt of stmts) {
+    console.log(stmt);
+    await query(stmt);
+  }
+  return { diffs, executed: stmts };
+}
+
+async function indexStatements(query, table, nextFields, currFields, { patch = false } = {}) {
+  const before = [];
+  const after = [];
+  const tableId = quoteId(table);
+  const indexes = await tableIndexes(query, table);
+  const currPrimary = new Set(indexes.primary.length ? indexes.primary : primaryFields(currFields));
+  const nextPrimary = new Set(primaryFields(nextFields));
+  const currentSecondary = indexes.secondary;
+
+  const primaryChanged = !setEqual(currPrimary, nextPrimary) && (!patch || nextPrimary.size);
+  if (primaryChanged) {
+    const currAuto = autoIncrementField(currFields);
+    if (currAuto) {
+      const [name, prop] = currAuto;
+      before.push(`ALTER TABLE ${tableId} MODIFY COLUMN ${toFieldDef(name, { ...prop, "x-autoincrement": false }, { required: true })};`);
+    }
+    if (currPrimary.size) before.push(`ALTER TABLE ${tableId} DROP PRIMARY KEY;`);
+    if (nextPrimary.size) {
+      const cols = [...nextPrimary].map(quoteId).join(", ");
+      after.push(`ALTER TABLE ${tableId} ADD PRIMARY KEY (${cols});`);
+    }
+  }
+
+  for (const [name, prop] of nextFields) {
+    if (nextPrimary.has(name)) continue;
+    const nextKind = usableIndexKind(table, name, prop);
+    const current = currentSecondary.find(i => i.column === name);
+    const currentKind = current
+      ? current.indexType === "FULLTEXT"
+        ? "FULLTEXT KEY"
+        : current.nonUnique
+        ? "KEY"
+        : "UNIQUE KEY"
+      : null;
+    const changed       = current && (currentKind !== nextKind || current.subPart != null);
+    if (patch && !nextKind) continue;
+    if (changed) {
+      const indexId = quoteId(current.key);
+      before.push(`ALTER TABLE ${tableId} DROP INDEX ${indexId};`);
+    }
+    if (nextKind && (!current || changed)) {
+      after.push(`ALTER TABLE ${tableId} ADD ${secondaryIndexSql(name, nextKind)};`);
+    }
+  }
+
+  if (!patch) {
+    for (const current of currentSecondary) {
+      const stillWanted = nextFields.find(([name, prop]) => name === current.column && usableIndexKind(table, name, prop));
+      if (!stillWanted) {
+        const indexId = quoteId(current.key);
+        before.push(`ALTER TABLE ${tableId} DROP INDEX ${indexId};`);
+      }
+    }
+  }
+
+  return { before, after, primaryChanged };
+}