@nuxodin/item 0.6.4

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

@@ -0,0 +1,60 @@
+// mysql/to-field.js — JSON Schema property → MySQL column definition
+import { quoteId, defaultLiteral } from "../shared/sql.js";
+export { quoteId };
+
+const B = 4; // bytes per char, worst-case utf8mb4
+
+const formats = { date: "DATE", time: "TIME", "date-time": "DATETIME" };
+
+export function toFieldDef(name, prop, { required = false } = {}) {
+  let type, unsigned = false;
+  const types      = Array.isArray(prop.type) ? prop.type : [prop.type];
+  const schemaType = types.find(t => t !== "null");
+  const nullable = !required || types.includes("null");
+
+  if (schemaType === "boolean") type = "TINYINT(1)";
+  else if (schemaType === "integer") ({ type, unsigned } = integerType(prop));
+  else if (schemaType === "number") type = prop.multipleOf ? "DECIMAL" : "DOUBLE";
+  else if (schemaType === "object" || schemaType === "array") type = "JSON";
+  else type = stringType(prop);
+
+  let sql = `${quoteId(name)} ${type}`;
+  if (unsigned) sql += " UNSIGNED";
+  sql += !nullable || prop["x-autoincrement"] ? " NOT NULL" : " NULL";
+  // TEXT/BLOB/JSON can't carry a literal default in MySQL; emitting one never round-trips → endless ALTERs.
+  if (prop.default != null && !/TEXT|BLOB|JSON/.test(type)) sql += ` DEFAULT ${defaultLiteral(prop)}`;
+  if (prop["x-autoincrement"]) sql += " AUTO_INCREMENT";
+  if (prop["$comment"]) {
+    sql += ` COMMENT '${prop["$comment"].replace(/'/g, "''")}'`;
+  }
+
+  return sql;
+}
+
+function integerType(prop) {
+  if (prop.minimum == null && prop.maximum == null) return { type: "INT", unsigned: !!prop["x-autoincrement"] };
+  const min = prop.minimum ?? -Infinity, max = prop.maximum ?? Infinity;
+  const unsigned = min >= 0;
+  if (unsigned) {
+    if (max <= 255) return { type: "TINYINT", unsigned };
+    if (max <= 65535) return { type: "SMALLINT", unsigned };
+    if (max <= 16777215) return { type: "MEDIUMINT", unsigned };
+    if (max <= 4294967295) return { type: "INT", unsigned };
+    return { type: "BIGINT", unsigned };
+  }
+  if (min >= -128 && max <= 127) return { type: "TINYINT", unsigned };
+  if (min >= -32768 && max <= 32767) return { type: "SMALLINT", unsigned };
+  if (min >= -8388608 && max <= 8388607) return { type: "MEDIUMINT", unsigned };
+  if (min >= -2147483648 && max <= 2147483647) return { type: "INT", unsigned };
+  return { type: "BIGINT", unsigned };
+}
+
+function stringType(prop) {
+  if (prop.format in formats) return formats[prop.format];
+  if (prop.contentEncoding === "base64") return prop.maxLength ? `VARBINARY(${prop.maxLength})` : "BLOB";
+  const maxLength = prop.maxLength ?? Math.floor(65535 / B), maxBytes = maxLength * B;
+  if (maxLength <= 255) return `VARCHAR(${maxLength})`;
+  if (maxBytes <= 65535) return "TEXT";
+  if (maxBytes <= 16777215) return "MEDIUMTEXT";
+  return "LONGTEXT";
+}

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

@@ -0,0 +1,48 @@
+// pg/from-db.js
+import { schemaFromDb as _schemaFromDb } from '../shared/from-db.js'
+import { queryRows } from '../shared/sql.js'
+import { schemaFromField } from './from-field.js'
+import { quoteLit } from './to-field.js'
+
+const dialect = {
+    tables: async (query) => (await queryRows(query, `
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = current_schema() AND table_type = 'BASE TABLE'
+        ORDER BY table_name
+    `)).map(r => r.table_name),
+
+    fields: async (query, table) => queryRows(query, `
+        WITH ix AS (
+            SELECT a.attname AS column_name,
+                   bool_or(i.indisprimary) AS is_primary,
+                   bool_or(i.indisunique AND NOT i.indisprimary AND array_length(i.indkey, 1) = 1) AS is_unique,
+                   bool_or(NOT i.indisunique AND NOT i.indisprimary AND array_length(i.indkey, 1) = 1) AS is_index
+            FROM pg_class t
+            JOIN pg_namespace n ON n.oid = t.relnamespace
+            JOIN pg_index i ON i.indrelid = t.oid
+            JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(i.indkey)
+            WHERE n.nspname = current_schema() AND t.relname = ${quoteLit(table)}
+            GROUP BY a.attname
+        )
+        SELECT c.column_name, c.data_type, c.udt_name, c.character_maximum_length,
+               c.numeric_precision, c.numeric_scale, c.is_nullable, c.column_default,
+               c.is_identity, d.description AS comment, ix.is_primary, ix.is_unique, ix.is_index
+        FROM information_schema.columns c
+        LEFT JOIN pg_namespace n ON n.nspname = c.table_schema
+        LEFT JOIN pg_class t ON t.relnamespace = n.oid AND t.relname = c.table_name
+        LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attname = c.column_name
+        LEFT JOIN pg_description d ON d.objoid = t.oid AND d.objsubid = a.attnum
+        LEFT JOIN ix ON ix.column_name = c.column_name
+        WHERE c.table_schema = current_schema() AND c.table_name = ${quoteLit(table)}
+        ORDER BY c.ordinal_position
+    `),
+
+    fromField: (row) => ({
+        name:       row.column_name,
+        prop:       schemaFromField(row),
+        isRequired: row.is_nullable === 'NO',
+    }),
+}
+
+export const schemaFromDb = (query) => _schemaFromDb(query, dialect)

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

@@ -0,0 +1,71 @@
+// pg/from-field.js
+
+const intRanges = {
+    int2:     [-32768, 32767],
+    smallint: [-32768, 32767],
+    int4:     [-2147483648, 2147483647],
+    integer:  [-2147483648, 2147483647],
+    int8:     [-9007199254740991, 9007199254740991], // JS safe
+    bigint:   [-9007199254740991, 9007199254740991],
+}
+
+const floats = new Set(['float4', 'float8', 'real', 'double precision'])
+const strings = new Set(['varchar', 'bpchar'])
+
+export function schemaFromField(row) {
+    const prop = {}
+    const type = String(row.udt_name || row.data_type || '').toLowerCase()
+    const dataType = String(row.data_type || '').toLowerCase()
+    const isAuto = row.is_identity === 'YES' || /^nextval\(/i.test(row.column_default ?? '')
+
+    if (type === 'bool' || dataType === 'boolean') prop.type = 'boolean'
+    else if (type in intRanges) {
+        const [min, max] = intRanges[type]
+        prop.type = 'integer'
+        if (!isAuto) { prop.minimum = min; prop.maximum = max }
+    } else if (floats.has(type) || floats.has(dataType)) prop.type = 'number'
+    else if (type === 'numeric' || dataType === 'numeric') {
+        prop.type = 'number'
+        if (row.numeric_scale > 0) prop.multipleOf = Math.pow(10, -row.numeric_scale)
+    } else if (strings.has(type)) {
+        prop.type = 'string'
+        if (row.character_maximum_length) prop.maxLength = row.character_maximum_length
+        if (type === 'bpchar' && row.character_maximum_length) prop.minLength = row.character_maximum_length
+    } else if (type === 'bytea') {
+        prop.type = 'string'
+        prop.contentEncoding = 'base64'
+    } else if (type === 'date') {
+        prop.type = 'string'
+        prop.format = 'date'
+    } else if (type.startsWith('time') || dataType.startsWith('time')) {
+        prop.type = 'string'
+        prop.format = 'time'
+    } else if (type.startsWith('timestamp') || dataType.startsWith('timestamp')) {
+        prop.type = 'string'
+        prop.format = 'date-time'
+    } else if (type === 'json' || type === 'jsonb') prop.type = 'object'
+    else prop.type = 'string'
+
+    const def = defaultValue(row.column_default, prop)
+    if (def !== undefined) prop.default = def
+    if (row.comment) prop['$comment'] = row.comment
+    if (row.is_primary) prop['x-index'] = 'primary'
+    else if (row.is_unique) prop['x-index'] = 'unique'
+    else if (row.is_index) prop['x-index'] = true
+    if (isAuto) prop['x-autoincrement'] = true
+    return prop
+}
+
+function defaultValue(value, prop) {
+    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))
+    return v
+}
+
+function numberOr(fallback, value) {
+    return Number.isNaN(value) ? fallback : value
+}

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

@@ -0,0 +1,223 @@
+// pg/to-db.js
+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'
+
+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',
+])
+
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key)
+}
+
+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 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
+        : { ...prop, default: currProp.default }
+}
+
+function secondaryIndexKind(table, name, prop) {
+    if (prop['x-index'] === 'unique') return 'UNIQUE INDEX'
+    if (prop['x-index'] === true) return 'INDEX'
+    if (prop['x-index'] === 'fulltext')
+        console.warn(`Skip FULLTEXT INDEX ${table}.${name}: PostgreSQL fulltext requires an expression index`)
+    return null
+}
+
+function indexName(table, name) {
+    return `idx_${table}_${name}`
+}
+
+function createIndex(table, name, kind) {
+    return `CREATE ${kind} ${quoteId(indexName(table, name))} ON ${quoteId(table)} (${quoteId(name)});`
+}
+
+async function tableIndexes(query, table) {
+    const primaryRows = await queryRows(query, `
+        SELECT con.conname, array_agg(a.attname ORDER BY u.ord) AS columns
+        FROM pg_constraint con
+        JOIN pg_class t ON t.oid = con.conrelid
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        JOIN unnest(con.conkey) WITH ORDINALITY AS u(attnum, ord) ON true
+        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = u.attnum
+        WHERE con.contype = 'p' AND n.nspname = current_schema() AND t.relname = ${quoteLit(table)}
+        GROUP BY con.conname
+    `)
+    const secondary = await queryRows(query, `
+        SELECT ci.relname AS key, a.attname AS column, i.indisunique AS unique
+        FROM pg_index i
+        JOIN pg_class t ON t.oid = i.indrelid
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        JOIN pg_class ci ON ci.oid = i.indexrelid
+        JOIN unnest(i.indkey) WITH ORDINALITY AS k(attnum, ord) ON true
+        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+        WHERE NOT i.indisprimary
+          AND array_length(i.indkey, 1) = 1
+          AND n.nspname = current_schema()
+          AND t.relname = ${quoteLit(table)}
+    `)
+    const primary = primaryRows[0]
+    return { primaryName: primary?.conname, primary: primary?.columns ?? [], secondary }
+}
+
+function commentStmt(table, name, comment) {
+    return `COMMENT ON COLUMN ${quoteId(table)}.${quoteId(name)} IS ${comment ? quoteLit(comment) : 'NULL'};`
+}
+
+function alterFieldStmts(table, name, prop, currProp, required, currRequired, changed) {
+    const stmts = [], tableId = quoteId(table), colId = quoteId(name)
+    if (currProp['x-autoincrement'] && !prop['x-autoincrement'])
+        stmts.push(`ALTER TABLE ${tableId} ALTER COLUMN ${colId} DROP IDENTITY IF EXISTS;`)
+    if (changed && typeSql(prop) !== typeSql(currProp))
+        stmts.push(`ALTER TABLE ${tableId} ALTER COLUMN ${colId} TYPE ${typeSql(prop)} USING ${colId}::${typeSql(prop)};`)
+    if (prop['x-autoincrement'] && !currProp['x-autoincrement'] && hasOwn(currProp, 'default'))
+        stmts.push(`ALTER TABLE ${tableId} ALTER COLUMN ${colId} DROP DEFAULT;`)
+    if (prop['x-autoincrement'] && !currProp['x-autoincrement'])
+        stmts.push(`ALTER TABLE ${tableId} ALTER COLUMN ${colId} ADD GENERATED BY DEFAULT AS IDENTITY;`)
+    if (hasOwn(prop, 'default') && !prop['x-autoincrement'])
+        stmts.push(`ALTER TABLE ${tableId} ALTER COLUMN ${colId} SET DEFAULT ${defaultLiteral(prop)};`)
+    if (required !== currRequired)
+        stmts.push(`ALTER TABLE ${tableId} ALTER COLUMN ${colId} ${required ? 'SET' : 'DROP'} NOT NULL;`)
+    if (prop['$comment'] !== currProp['$comment'])
+        stmts.push(commentStmt(table, name, prop['$comment']))
+    return stmts
+}
+
+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)
+
+        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 primarySet = new Set(primaries)
+            stmts.push(`CREATE TABLE ${tableId} (\n${cols}${pk}\n);`)
+            for (const [n, f] of fields) if (f['$comment']) stmts.push(commentStmt(table, n, f['$comment']))
+            for (const [n, f] of fields) {
+                if (primarySet.has(n)) continue
+                const kind = secondaryIndexKind(table, n, f)
+                if (kind) stmts.push(createIndex(table, n, kind))
+            }
+        } else {
+            const { fields: currFieldEntries, required: currRequired } = tableData(current.properties[table])
+            const currFields = new Map(currFieldEntries)
+            const nextFieldNames = new Set(fields.map(([n]) => n))
+            const indexStmts = await indexStatements(query, table, fields, currFieldEntries, { patch })
+            stmts.push(...indexStmts.before)
+            for (const [name, prop] of fields) {
+                const isRequired = required.has(name)
+                const currProp = currFields.get(name)
+                if (!currProp) {
+                    stmts.push(`ALTER TABLE ${tableId} ADD COLUMN ${toFieldDef(name, prop, { required: isRequired })};`)
+                    if (prop['$comment']) stmts.push(commentStmt(table, name, prop['$comment']))
+                    continue
+                }
+                const propWithDefault = preserveDefault(prop, currProp)
+                const changed = fieldChanged(diffs, table, name, prop) || isRequired !== currRequired.has(name) || propWithDefault['$comment'] !== currProp['$comment']
+                if (changed) stmts.push(...alterFieldStmts(table, name, propWithDefault, currProp, isRequired, currRequired.has(name), changed))
+            }
+            if (!patch) {
+                for (const name of currFields.keys()) {
+                    if (!nextFieldNames.has(name))
+                        stmts.push(`ALTER TABLE ${tableId} DROP COLUMN ${quoteId(name)};`)
+                }
+            }
+            stmts.push(...indexStmts.after)
+        }
+    }
+
+    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 = [], after = [], 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 primaryChanged = !setEqual(currPrimary, nextPrimary) && (!patch || nextPrimary.size)
+
+    if (primaryChanged) {
+        if (indexes.primaryName) before.push(`ALTER TABLE ${tableId} DROP CONSTRAINT ${quoteId(indexes.primaryName)};`)
+        if (nextPrimary.size) after.push(`ALTER TABLE ${tableId} ADD PRIMARY KEY (${[...nextPrimary].map(quoteId).join(', ')});`)
+    }
+
+    for (const [name, prop] of nextFields) {
+        if (nextPrimary.has(name)) continue
+        const nextKind = secondaryIndexKind(table, name, prop)
+        const curr = indexes.secondary.find(i => i.column === name)
+        const currKind = curr ? curr.unique ? 'UNIQUE INDEX' : 'INDEX' : null
+        const changed = curr && currKind !== nextKind
+        if (patch && !nextKind) continue
+        if (changed) before.push(`DROP INDEX ${quoteId(curr.key)};`)
+        if (nextKind && (!curr || changed)) after.push(createIndex(table, name, nextKind))
+    }
+
+    if (!patch) {
+        for (const curr of indexes.secondary) {
+            const wanted = nextFields.find(([name, prop]) => name === curr.column && secondaryIndexKind(table, name, prop))
+            if (!wanted) before.push(`DROP INDEX ${quoteId(curr.key)};`)
+        }
+    }
+
+    return { before, after }
+}

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

@@ -0,0 +1,52 @@
+// pg/to-field.js - JSON Schema property -> PostgreSQL column definition
+import { schemaType } from '../shared/sql.js'
+
+const formats = { date: 'DATE', time: 'TIME', 'date-time': 'TIMESTAMP' }
+const maxVarchar = 10485760
+
+export function quoteId(name) {
+    return `"${String(name).replaceAll('"', '""')}"`
+}
+
+export function quoteLit(value) {
+    return `'${String(value).replace(/'/g, "''")}'`
+}
+
+export function typeSql(prop) {
+    const t = schemaType(prop)
+    if (t === 'boolean') return 'BOOLEAN'
+    if (t === 'integer') return integerType(prop)
+    if (t === 'number') return prop.multipleOf ? 'NUMERIC' : 'DOUBLE PRECISION'
+    if (t === 'object' || t === 'array') return 'JSONB'
+    if (prop.format in formats) return formats[prop.format]
+    if (prop.contentEncoding === 'base64') return 'BYTEA'
+    return prop.maxLength && prop.maxLength <= maxVarchar ? `VARCHAR(${prop.maxLength})` : 'TEXT'
+}
+
+export function defaultLiteral(prop) {
+    const t = schemaType(prop)
+    if (t === 'boolean') return prop.default ? 'TRUE' : 'FALSE'
+    if (t === 'integer' || t === 'number') return Number(prop.default)
+    if (typeof prop.default === 'boolean') return "''"
+    if (t === 'object' || t === 'array') return `${quoteLit(JSON.stringify(prop.default))}::jsonb`
+    return quoteLit(prop.default)
+}
+
+export function toFieldDef(name, prop, { required = false } = {}) {
+    const types = Array.isArray(prop.type) ? prop.type : [prop.type]
+    const nullable = !required || types.includes('null')
+    let sql = `${quoteId(name)} ${typeSql(prop)}`
+    if (prop['x-autoincrement']) sql += ' GENERATED BY DEFAULT AS IDENTITY'
+    sql += !nullable || prop['x-autoincrement'] ? ' NOT NULL' : ' NULL'
+    if (prop.default != null && !prop['x-autoincrement']) sql += ` DEFAULT ${defaultLiteral(prop)}`
+    return sql
+}
+
+function integerType(prop) {
+    if (prop['x-autoincrement']) return 'INTEGER'
+    if (prop.minimum == null && prop.maximum == null) return 'INTEGER'
+    const min = prop.minimum ?? -Infinity, max = prop.maximum ?? Infinity
+    if (min >= -32768 && max <= 32767) return 'SMALLINT'
+    if (min >= -2147483648 && max <= 2147483647) return 'INTEGER'
+    return 'BIGINT'
+}

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

@@ -0,0 +1,29 @@
+// shared/from-db.js
+
+export function schemaFromTable(fields, fromField) {
+  const properties = {}, required = [];
+  for (const f of fields) {
+    const { name, prop, isRequired } = fromField(f);
+    properties[name] = prop;
+    if (isRequired) required.push(name);
+  }
+  return {
+    additionalProperties: {
+      properties,
+      ...(required.length && { required }),
+    },
+  };
+}
+
+export async function schemaFromDb(db, dialect) {
+  const tables = await dialect.tables(db);
+  const entries = await Promise.all(
+    tables.map(
+      async (t) => [
+        t,
+        schemaFromTable(await dialect.fields(db, t), dialect.fromField),
+      ],
+    ),
+  );
+  return { properties: Object.fromEntries(entries) };
+}

package/tools/schema/db/shared/sql.js

@@ -0,0 +1,26 @@
+// shared/sql.js — helpers shared by SQL dialects
+
+export function quoteId(name) {
+  return `\`${String(name).replaceAll('`', '``')}\``;
+}
+
+export async function queryRows(query, sql) {
+  const res = await query(sql);
+  return Array.isArray(res) ? res : res.rows ?? [];
+}
+
+/** First non-null JSON-Schema type: 'integer' | ['string','null'] → 'string'. */
+export function schemaType(prop) {
+  return Array.isArray(prop.type) ? prop.type.find(t => t !== 'null') : prop.type;
+}
+
+const numericTypes = new Set(['boolean', 'integer', 'number']);
+
+/** JSON-Schema default → SQL literal: numeric columns get an unquoted number
+ *  (boolean false→0, true→1), string columns a quoted literal ('' for a boolean).
+ *  Used by mysql/sqlite; dialects with native literals can keep their own renderer. */
+export function defaultLiteral(prop) {
+  if (numericTypes.has(schemaType(prop))) return Number(prop.default);
+  if (typeof prop.default === 'boolean') return "''";
+  return `'${String(prop.default).replace(/'/g, "''")}'`;
+}

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

@@ -0,0 +1,39 @@
+// sqlite/from-db.js
+import { schemaFromDb as _schemaFromDb } from '../shared/from-db.js'
+import { 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)})`)) {
+        if (row.origin && row.origin !== 'c') continue
+        const cols = await 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
+}
+
+async function indexes(query, table) {
+    const map = new Map()
+    for (const { column, unique } of await singleColumnIndexes(query, table))
+        map.set(column, unique ? 'unique' : true)
+    return map
+}
+
+const dialect = {
+    tables:    async (query) => (await 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) }
+        )
+    },
+    fromField: (row) => ({
+        name:       row.name,
+        prop:       schemaFromField(row),
+        isRequired: row.notnull === 1 && !row.pk,
+    }),
+}
+
+export const schemaFromDb = (query) => _schemaFromDb(query, dialect)

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

@@ -0,0 +1,49 @@
+// sqlite/schema-from-field.js
+// 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
+}
+
+export function schemaFromField(row) {
+    const prop = {}
+    const raw  = (row.type ?? '').trim()
+    const m    = raw.match(/^(\w+)\s*(?:\(([^)]+)\))?/)
+    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
+
+    } else if (type === 'boolean' || type === 'bool') { prop.type = 'boolean'
+    } else if (type === 'real' || type === 'float' || type === 'double') { prop.type = 'number'
+    } else if (type === 'numeric' || type === 'decimal') { prop.type = 'number'
+
+    } else if (type === 'varchar' || type === 'nvarchar') {
+        prop.type = 'string'; if (len) prop.maxLength = len
+
+    } else if (type === 'char' || type === 'nchar') {
+        prop.type = 'string'; if (len) { prop.minLength = len; prop.maxLength = len }
+
+    } else if (type === 'blob') { 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 === 'json')      { prop.type = 'object'
+    } else {
+        prop.type = 'string'
+    }
+
+    if (row.dflt_value != null) prop.default    = row.dflt_value
+    if (row.pk)                 prop['x-index'] = 'primary'
+    else if (row.index)         prop['x-index'] = row.index
+
+    return prop
+}