@atscript/db-sqlite 0.1.34 → 0.1.36

package/dist/index.cjs

@@ -25,6 +25,211 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 const __atscript_utils_db = __toESM(require("@atscript/utils-db"));
 const __uniqu_core = __toESM(require("@uniqu/core"));
 
+//#region packages/db-sqlite/src/better-sqlite3-driver.ts
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var BetterSqlite3Driver = class {
+	run(sql, params) {
+		const stmt = this.db.prepare(sql);
+		const result = params ? stmt.run(...params) : stmt.run();
+		return {
+			changes: result.changes,
+			lastInsertRowid: result.lastInsertRowid
+		};
+	}
+	all(sql, params) {
+		const stmt = this.db.prepare(sql);
+		return params ? stmt.all(...params) : stmt.all();
+	}
+	get(sql, params) {
+		const stmt = this.db.prepare(sql);
+		return (params ? stmt.get(...params) : stmt.get()) ?? null;
+	}
+	exec(sql) {
+		this.db.exec(sql);
+	}
+	close() {
+		this.db.close();
+	}
+	constructor(pathOrDb, options) {
+		_define_property$1(this, "db", void 0);
+		if (typeof pathOrDb === "string") {
+			const Database = require("better-sqlite3");
+			this.db = new Database(pathOrDb, options);
+		} else this.db = pathOrDb;
+	}
+};
+
+//#endregion
+//#region packages/db-sqlite/src/sql-builder.ts
+function buildInsert(table, data) {
+	const keys = Object.keys(data);
+	const cols = keys.map((k) => `"${esc(k)}"`).join(", ");
+	const placeholders = keys.map(() => "?").join(", ");
+	return {
+		sql: `INSERT INTO "${esc(table)}" (${cols}) VALUES (${placeholders})`,
+		params: keys.map((k) => toSqliteValue(data[k]))
+	};
+}
+function buildSelect(table, where, controls) {
+	const cols = buildProjection(controls?.$select);
+	let sql = `SELECT ${cols} FROM "${esc(table)}" WHERE ${where.sql}`;
+	const params = [...where.params];
+	if (controls?.$sort) {
+		const orderParts = [];
+		for (const [col, dir] of Object.entries(controls.$sort)) orderParts.push(`"${esc(col)}" ${dir === -1 ? "DESC" : "ASC"}`);
+		if (orderParts.length > 0) sql += ` ORDER BY ${orderParts.join(", ")}`;
+	}
+	if (controls?.$limit !== undefined) {
+		sql += ` LIMIT ?`;
+		params.push(controls.$limit);
+	}
+	if (controls?.$skip !== undefined) {
+		if (controls.$limit === undefined) sql += ` LIMIT -1`;
+		sql += ` OFFSET ?`;
+		params.push(controls.$skip);
+	}
+	return {
+		sql,
+		params
+	};
+}
+function buildUpdate(table, data, where) {
+	const setClauses = [];
+	const params = [];
+	for (const [key, value] of Object.entries(data)) {
+		setClauses.push(`"${esc(key)}" = ?`);
+		params.push(toSqliteValue(value));
+	}
+	return {
+		sql: `UPDATE "${esc(table)}" SET ${setClauses.join(", ")} WHERE ${where.sql}`,
+		params: [...params, ...where.params]
+	};
+}
+function buildDelete(table, where) {
+	return {
+		sql: `DELETE FROM "${esc(table)}" WHERE ${where.sql}`,
+		params: [...where.params]
+	};
+}
+function buildCreateTable(table, fields, foreignKeys) {
+	const colDefs = [];
+	const primaryKeys = fields.filter((f) => f.isPrimaryKey);
+	for (const field of fields) {
+		if (field.ignored) continue;
+		const sqlType = field.isPrimaryKey && (field.designType === "number" || field.designType === "integer") ? "INTEGER" : sqliteTypeFromDesignType(field.designType);
+		let def = `"${esc(field.physicalName)}" ${sqlType}`;
+		if (field.isPrimaryKey && primaryKeys.length === 1) def += " PRIMARY KEY";
+		if (!field.optional && !field.isPrimaryKey) def += " NOT NULL";
+		if (field.defaultValue?.kind === "value") def += ` DEFAULT ${sqlStringLiteral(field.defaultValue.value)}`;
+		colDefs.push(def);
+	}
+	if (primaryKeys.length > 1) {
+		const pkCols = primaryKeys.map((pk) => `"${esc(pk.physicalName)}"`).join(", ");
+		colDefs.push(`PRIMARY KEY (${pkCols})`);
+	}
+	if (foreignKeys) for (const fk of foreignKeys.values()) {
+		const localCols = fk.fields.map((f) => `"${esc(f)}"`).join(", ");
+		const targetCols = fk.targetFields.map((f) => `"${esc(f)}"`).join(", ");
+		let constraint = `FOREIGN KEY (${localCols}) REFERENCES "${esc(fk.targetTable)}" (${targetCols})`;
+		if (fk.onDelete) constraint += ` ON DELETE ${refActionToSql(fk.onDelete)}`;
+		if (fk.onUpdate) constraint += ` ON UPDATE ${refActionToSql(fk.onUpdate)}`;
+		colDefs.push(constraint);
+	}
+	return `CREATE TABLE IF NOT EXISTS "${esc(table)}" (${colDefs.join(", ")})`;
+}
+function refActionToSql(action) {
+	switch (action) {
+		case "cascade": return "CASCADE";
+		case "restrict": return "RESTRICT";
+		case "setNull": return "SET NULL";
+		case "setDefault": return "SET DEFAULT";
+		default: return "NO ACTION";
+	}
+}
+function sqliteTypeFromDesignType(designType) {
+	switch (designType) {
+		case "number":
+		case "integer": return "REAL";
+		case "boolean": return "INTEGER";
+		case "string": return "TEXT";
+		default: return "TEXT";
+	}
+}
+function buildProjection(select) {
+	const fields = select?.asArray;
+	if (!fields) return "*";
+	let sql = "";
+	for (let i = 0; i < fields.length; i++) {
+		if (i > 0) sql += ", ";
+		sql += `"${esc(fields[i])}"`;
+	}
+	return sql || "*";
+}
+function esc(name) {
+	return name.replace(/"/g, "\"\"");
+}
+function sqlStringLiteral(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+function toSqliteValue(value) {
+	if (value === undefined) return null;
+	if (value === null) return null;
+	if (typeof value === "object") return JSON.stringify(value);
+	if (typeof value === "boolean") return value ? 1 : 0;
+	return value;
+}
+function buildCreateView(viewName, plan, columns, resolveFieldRef) {
+	const selectCols = columns.map((c) => `"${esc(c.sourceTable)}"."${esc(c.sourceColumn)}" AS "${esc(c.viewColumn)}"`).join(", ");
+	let sql = `CREATE VIEW IF NOT EXISTS "${esc(viewName)}" AS SELECT ${selectCols} FROM "${esc(plan.entryTable)}"`;
+	for (const join of plan.joins) {
+		const onClause = queryNodeToSql(join.condition, resolveFieldRef);
+		sql += ` JOIN "${esc(join.targetTable)}" ON ${onClause}`;
+	}
+	if (plan.filter) {
+		const whereClause = queryNodeToSql(plan.filter, resolveFieldRef);
+		sql += ` WHERE ${whereClause}`;
+	}
+	return sql;
+}
+const queryOpToSql = {
+	$eq: "=",
+	$ne: "!=",
+	$gt: ">",
+	$gte: ">=",
+	$lt: "<",
+	$lte: "<="
+};
+/**
+* Renders an AtscriptQueryNode tree to raw SQL (no parameters — for DDL use only).
+*/ function queryNodeToSql(node, resolveFieldRef) {
+	if ("$and" in node) {
+		const children = node.$and;
+		return children.map((n) => queryNodeToSql(n, resolveFieldRef)).join(" AND ");
+	}
+	if ("$or" in node) {
+		const children = node.$or;
+		return `(${children.map((n) => queryNodeToSql(n, resolveFieldRef)).join(" OR ")})`;
+	}
+	if ("$not" in node) return `NOT (${queryNodeToSql(node.$not, resolveFieldRef)})`;
+	const comp = node;
+	const leftSql = resolveFieldRef(comp.left);
+	const sqlOp = queryOpToSql[comp.op] || "=";
+	if (comp.right && typeof comp.right === "object" && "field" in comp.right) return `${leftSql} ${sqlOp} ${resolveFieldRef(comp.right)}`;
+	if (comp.right === null || comp.right === undefined) return comp.op === "$ne" ? `${leftSql} IS NOT NULL` : `${leftSql} IS NULL`;
+	if (typeof comp.right === "string") return `${leftSql} ${sqlOp} '${comp.right.replace(/'/g, "''")}'`;
+	return `${leftSql} ${sqlOp} ${comp.right}`;
+}
+
+//#endregion
 //#region packages/db-sqlite/src/filter-builder.ts
 const EMPTY_AND = {
 	sql: "1=1",
@@ -39,7 +244,7 @@ const EMPTY_OR = {
 * into a parameterized SQL WHERE clause.
 */ const sqlVisitor = {
 	comparison(field, op, value) {
-		const col = `"${escapeIdent(field)}"`;
+		const col = `"${esc(field)}"`;
 		const v = toSqliteParam(value);
 		switch (op) {
 			case "$eq": {
@@ -136,7 +341,7 @@ const EMPTY_OR = {
 };
 function buildWhere(filter) {
 	if (!filter || Object.keys(filter).length === 0) return EMPTY_AND;
-	return (0, __uniqu_core.walkFilter)(filter, sqlVisitor);
+	return (0, __uniqu_core.walkFilter)(filter, sqlVisitor) ?? EMPTY_AND;
 }
 /**
 * Basic regex-to-LIKE conversion.
@@ -158,12 +363,6 @@ function buildWhere(filter) {
 	return `%${core}%`;
 }
 /**
-* Escapes a SQL identifier to prevent injection.
-* Doubles any embedded double-quotes.
-*/ function escapeIdent(name) {
-	return name.replace(/"/g, "\"\"");
-}
-/**
 * Converts a JS value to a SQLite-bindable parameter.
 * SQLite cannot bind booleans — they must be 0/1.
 */ function toSqliteParam(value) {
@@ -171,128 +370,9 @@ function buildWhere(filter) {
 	return value;
 }
 
-//#endregion
-//#region packages/db-sqlite/src/sql-builder.ts
-function buildInsert(table, data) {
-	const keys = Object.keys(data);
-	const cols = keys.map((k) => `"${esc$1(k)}"`).join(", ");
-	const placeholders = keys.map(() => "?").join(", ");
-	return {
-		sql: `INSERT INTO "${esc$1(table)}" (${cols}) VALUES (${placeholders})`,
-		params: keys.map((k) => toSqliteValue$1(data[k]))
-	};
-}
-function buildSelect(table, where, controls) {
-	const cols = buildProjection(controls?.$select);
-	let sql = `SELECT ${cols} FROM "${esc$1(table)}" WHERE ${where.sql}`;
-	const params = [...where.params];
-	if (controls?.$sort) {
-		const orderParts = [];
-		for (const [col, dir] of Object.entries(controls.$sort)) orderParts.push(`"${esc$1(col)}" ${dir === -1 ? "DESC" : "ASC"}`);
-		if (orderParts.length > 0) sql += ` ORDER BY ${orderParts.join(", ")}`;
-	}
-	if (controls?.$limit !== undefined) {
-		sql += ` LIMIT ?`;
-		params.push(controls.$limit);
-	}
-	if (controls?.$skip !== undefined) {
-		if (controls.$limit === undefined) sql += ` LIMIT -1`;
-		sql += ` OFFSET ?`;
-		params.push(controls.$skip);
-	}
-	return {
-		sql,
-		params
-	};
-}
-function buildUpdate(table, data, where) {
-	const setClauses = [];
-	const params = [];
-	for (const [key, value] of Object.entries(data)) {
-		setClauses.push(`"${esc$1(key)}" = ?`);
-		params.push(toSqliteValue$1(value));
-	}
-	return {
-		sql: `UPDATE "${esc$1(table)}" SET ${setClauses.join(", ")} WHERE ${where.sql}`,
-		params: [...params, ...where.params]
-	};
-}
-function buildDelete(table, where) {
-	return {
-		sql: `DELETE FROM "${esc$1(table)}" WHERE ${where.sql}`,
-		params: [...where.params]
-	};
-}
-function buildCreateTable(table, fields, foreignKeys) {
-	const colDefs = [];
-	const primaryKeys = fields.filter((f) => f.isPrimaryKey);
-	for (const field of fields) {
-		if (field.ignored) continue;
-		const sqlType = field.isPrimaryKey && (field.designType === "number" || field.designType === "integer") ? "INTEGER" : sqliteTypeFromDesignType(field.designType);
-		let def = `"${esc$1(field.physicalName)}" ${sqlType}`;
-		if (field.isPrimaryKey && primaryKeys.length === 1) def += " PRIMARY KEY";
-		if (!field.optional && !field.isPrimaryKey) def += " NOT NULL";
-		colDefs.push(def);
-	}
-	if (primaryKeys.length > 1) {
-		const pkCols = primaryKeys.map((pk) => `"${esc$1(pk.physicalName)}"`).join(", ");
-		colDefs.push(`PRIMARY KEY (${pkCols})`);
-	}
-	if (foreignKeys) for (const fk of foreignKeys.values()) {
-		const localCols = fk.fields.map((f) => `"${esc$1(f)}"`).join(", ");
-		const targetCols = fk.targetFields.map((f) => `"${esc$1(f)}"`).join(", ");
-		let constraint = `FOREIGN KEY (${localCols}) REFERENCES "${esc$1(fk.targetTable)}" (${targetCols})`;
-		if (fk.onDelete) constraint += ` ON DELETE ${refActionToSql(fk.onDelete)}`;
-		if (fk.onUpdate) constraint += ` ON UPDATE ${refActionToSql(fk.onUpdate)}`;
-		colDefs.push(constraint);
-	}
-	return `CREATE TABLE IF NOT EXISTS "${esc$1(table)}" (${colDefs.join(", ")})`;
-}
-function refActionToSql(action) {
-	switch (action) {
-		case "cascade": return "CASCADE";
-		case "restrict": return "RESTRICT";
-		case "setNull": return "SET NULL";
-		case "setDefault": return "SET DEFAULT";
-		default: return "NO ACTION";
-	}
-}
-function sqliteTypeFromDesignType(designType) {
-	switch (designType) {
-		case "number":
-		case "integer": return "REAL";
-		case "boolean": return "INTEGER";
-		case "string": return "TEXT";
-		default: return "TEXT";
-	}
-}
-function buildProjection(select) {
-	const fields = select?.asArray;
-	if (!fields) return "*";
-	let sql = "";
-	for (let i = 0; i < fields.length; i++) {
-		if (i > 0) sql += ", ";
-		sql += `"${esc$1(fields[i])}"`;
-	}
-	return sql || "*";
-}
-function esc$1(name) {
-	return name.replace(/"/g, "\"\"");
-}
-/**
-* Converts a JS value to a SQLite-compatible value.
-* Objects and arrays are stored as JSON strings.
-*/ function toSqliteValue$1(value) {
-	if (value === undefined) return null;
-	if (value === null) return null;
-	if (typeof value === "object") return JSON.stringify(value);
-	if (typeof value === "boolean") return value ? 1 : 0;
-	return value;
-}
-
 //#endregion
 //#region packages/db-sqlite/src/sqlite-adapter.ts
-function _define_property$1(obj, key, value) {
+function _define_property(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
 		enumerable: true,
@@ -303,35 +383,73 @@ else obj[key] = value;
 	return obj;
 }
 var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
+	async _beginTransaction() {
+		this._log("BEGIN");
+		this.driver.exec("BEGIN");
+		return undefined;
+	}
+	async _commitTransaction() {
+		this._log("COMMIT");
+		this.driver.exec("COMMIT");
+	}
+	async _rollbackTransaction() {
+		this._log("ROLLBACK");
+		this.driver.exec("ROLLBACK");
+	}
 	/** SQLite does not use schemas — override to always exclude schema. */ resolveTableName() {
 		return super.resolveTableName(false);
 	}
+	/** SQLite enforces FK constraints natively via PRAGMA foreign_keys. */ supportsNativeForeignKeys() {
+		return true;
+	}
 	prepareId(id, _fieldType) {
 		return id;
 	}
+	/**
+	* Wraps a write operation to catch native SQLite constraint errors
+	* and rethrow as structured `DbError`.
+	*/ _wrapConstraintError(fn) {
+		try {
+			return fn();
+		} catch (e) {
+			if (e instanceof Error) {
+				if (e.message.includes("FOREIGN KEY constraint failed")) throw new __atscript_utils_db.DbError("FK_VIOLATION", [{
+					path: "",
+					message: e.message
+				}]);
+				const uniqueMatch = e.message.match(/UNIQUE constraint failed:\s*\S+\.(\S+)/);
+				if (uniqueMatch) throw new __atscript_utils_db.DbError("CONFLICT", [{
+					path: uniqueMatch[1],
+					message: e.message
+				}]);
+				if (e.message.includes("UNIQUE constraint failed")) throw new __atscript_utils_db.DbError("CONFLICT", [{
+					path: "",
+					message: e.message
+				}]);
+			}
+			throw e;
+		}
+	}
 	async insertOne(data) {
 		const { sql, params } = buildInsert(this.resolveTableName(), data);
-		const result = this.driver.run(sql, params);
+		this._log(sql, params);
+		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return { insertedId: result.lastInsertRowid };
 	}
 	async insertMany(data) {
-		const ids = [];
-		this.driver.exec("BEGIN");
-		try {
+		return this.withTransaction(async () => {
+			const ids = [];
 			for (const row of data) {
 				const { sql, params } = buildInsert(this.resolveTableName(), row);
-				const result = this.driver.run(sql, params);
+				this._log(sql, params);
+				const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 				ids.push(result.lastInsertRowid);
 			}
-			this.driver.exec("COMMIT");
-		} catch (error) {
-			this.driver.exec("ROLLBACK");
-			throw error;
-		}
-		return {
-			insertedCount: ids.length,
-			insertedIds: ids
-		};
+			return {
+				insertedCount: ids.length,
+				insertedIds: ids
+			};
+		});
 	}
 	async findOne(query) {
 		const where = buildWhere(query.filter);
@@ -340,17 +458,20 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 			$limit: 1
 		};
 		const { sql, params } = buildSelect(this.resolveTableName(), where, controls);
+		this._log(sql, params);
 		return this.driver.get(sql, params);
 	}
 	async findMany(query) {
 		const where = buildWhere(query.filter);
 		const { sql, params } = buildSelect(this.resolveTableName(), where, query.controls);
+		this._log(sql, params);
 		return this.driver.all(sql, params);
 	}
 	async count(query) {
 		const where = buildWhere(query.filter);
 		const tableName = this.resolveTableName();
 		const sql = `SELECT COUNT(*) as cnt FROM "${esc(tableName)}" WHERE ${where.sql}`;
+		this._log(sql, where.params);
 		const row = this.driver.get(sql, where.params);
 		return row?.cnt ?? 0;
 	}
@@ -364,7 +485,9 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 			setParams.push(toSqliteValue(value));
 		}
 		const sql = `UPDATE "${esc(tableName)}" SET ${setClauses.join(", ")} WHERE rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`;
-		const result = this.driver.run(sql, [...setParams, ...where.params]);
+		const allParams = [...setParams, ...where.params];
+		this._log(sql, allParams);
+		const result = this._wrapConstraintError(() => this.driver.run(sql, allParams));
 		return {
 			matchedCount: result.changes,
 			modifiedCount: result.changes
@@ -373,7 +496,8 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 	async updateMany(filter, data) {
 		const where = buildWhere(filter);
 		const { sql, params } = buildUpdate(this.resolveTableName(), data, where);
-		const result = this.driver.run(sql, params);
+		this._log(sql, params);
+		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
 			matchedCount: result.changes,
 			modifiedCount: result.changes
@@ -382,28 +506,23 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 	async replaceOne(filter, data) {
 		const where = buildWhere(filter);
 		const tableName = this.resolveTableName();
-		this.driver.exec("BEGIN");
-		try {
-			const delSql = `DELETE FROM "${esc(tableName)}" WHERE rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`;
-			const delResult = this.driver.run(delSql, where.params);
-			if (delResult.changes > 0) {
-				const { sql, params } = buildInsert(tableName, data);
-				this.driver.run(sql, params);
-			}
-			this.driver.exec("COMMIT");
-			return {
-				matchedCount: delResult.changes,
-				modifiedCount: delResult.changes
-			};
-		} catch (error) {
-			this.driver.exec("ROLLBACK");
-			throw error;
-		}
+		const limitedWhere = {
+			sql: `rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`,
+			params: where.params
+		};
+		const { sql, params } = buildUpdate(tableName, data, limitedWhere);
+		this._log(sql, params);
+		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
+		return {
+			matchedCount: result.changes,
+			modifiedCount: result.changes
+		};
 	}
 	async replaceMany(filter, data) {
 		const where = buildWhere(filter);
 		const { sql, params } = buildUpdate(this.resolveTableName(), data, where);
-		const result = this.driver.run(sql, params);
+		this._log(sql, params);
+		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
 			matchedCount: result.changes,
 			modifiedCount: result.changes
@@ -413,19 +532,140 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 		const where = buildWhere(filter);
 		const tableName = this.resolveTableName();
 		const sql = `DELETE FROM "${esc(tableName)}" WHERE rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`;
-		const result = this.driver.run(sql, where.params);
+		this._log(sql, where.params);
+		const result = this._wrapConstraintError(() => this.driver.run(sql, where.params));
 		return { deletedCount: result.changes };
 	}
 	async deleteMany(filter) {
 		const where = buildWhere(filter);
 		const { sql, params } = buildDelete(this.resolveTableName(), where);
-		const result = this.driver.run(sql, params);
+		this._log(sql, params);
+		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return { deletedCount: result.changes };
 	}
 	async ensureTable() {
+		if (this._table instanceof __atscript_utils_db.AtscriptDbView) return this.ensureView();
 		const sql = buildCreateTable(this.resolveTableName(), this._table.fieldDescriptors, this._table.foreignKeys);
+		this._log(sql);
+		this.driver.exec(sql);
+	}
+	async ensureView() {
+		const view = this._table;
+		const sql = buildCreateView(this.resolveTableName(), view.viewPlan, view.getViewColumnMappings(), (ref) => view.resolveFieldRef(ref));
+		this._log(sql);
 		this.driver.exec(sql);
 	}
+	async getExistingColumns() {
+		return this.getExistingColumnsForTable(this.resolveTableName());
+	}
+	async syncColumns(diff) {
+		const tableName = this.resolveTableName();
+		const added = [];
+		const renamed = [];
+		for (const { field, oldName } of diff.renamed ?? []) {
+			const ddl = `ALTER TABLE "${esc(tableName)}" RENAME COLUMN "${esc(oldName)}" TO "${esc(field.physicalName)}"`;
+			this._log(ddl);
+			this.driver.exec(ddl);
+			renamed.push(field.physicalName);
+		}
+		for (const field of diff.added) {
+			const sqlType = this.typeMapper(field);
+			let ddl = `ALTER TABLE "${esc(tableName)}" ADD COLUMN "${esc(field.physicalName)}" ${sqlType}`;
+			if (!field.optional && !field.isPrimaryKey) ddl += " NOT NULL";
+			if (field.defaultValue?.kind === "value") ddl += ` DEFAULT ${sqlStringLiteral(field.defaultValue.value)}`;
+else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValueForType(field.designType)}`;
+			this._log(ddl);
+			this.driver.exec(ddl);
+			added.push(field.physicalName);
+		}
+		return {
+			added,
+			renamed
+		};
+	}
+	async recreateTable() {
+		const tableName = this.resolveTableName();
+		const tempName = `${tableName}__tmp_${Date.now()}`;
+		this.driver.exec("PRAGMA foreign_keys = OFF");
+		this.driver.exec("PRAGMA legacy_alter_table = ON");
+		try {
+			const createSql = buildCreateTable(tempName, this._table.fieldDescriptors, this._table.foreignKeys);
+			this._log(createSql);
+			this.driver.exec(createSql);
+			const oldCols = (await this.getExistingColumns()).map((c) => c.name);
+			const newCols = this._table.fieldDescriptors.filter((f) => !f.ignored).map((f) => f.physicalName);
+			const oldColSet = new Set(oldCols);
+			const commonCols = newCols.filter((c) => oldColSet.has(c));
+			if (commonCols.length > 0) {
+				const fieldsByName = new Map(this._table.fieldDescriptors.map((f) => [f.physicalName, f]));
+				const colNames = commonCols.map((c) => `"${esc(c)}"`).join(", ");
+				const selectExprs = commonCols.map((c) => {
+					const field = fieldsByName.get(c);
+					if (field && !field.optional && !field.isPrimaryKey) {
+						const fallback = field.defaultValue?.kind === "value" ? sqlStringLiteral(field.defaultValue.value) : defaultValueForType(field.designType);
+						return `COALESCE("${esc(c)}", ${fallback}) AS "${esc(c)}"`;
+					}
+					return `"${esc(c)}"`;
+				}).join(", ");
+				const copySql = `INSERT INTO "${esc(tempName)}" (${colNames}) SELECT ${selectExprs} FROM "${esc(tableName)}"`;
+				this._log(copySql);
+				this.driver.exec(copySql);
+			}
+			const oldName = `${tableName}__old_${Date.now()}`;
+			this.driver.exec(`ALTER TABLE "${esc(tableName)}" RENAME TO "${esc(oldName)}"`);
+			this.driver.exec(`ALTER TABLE "${esc(tempName)}" RENAME TO "${esc(tableName)}"`);
+			this.driver.exec(`DROP TABLE IF EXISTS "${esc(oldName)}"`);
+		} finally {
+			this.driver.exec("PRAGMA legacy_alter_table = OFF");
+			this.driver.exec("PRAGMA foreign_keys = ON");
+		}
+	}
+	async dropTable() {
+		const tableName = this.resolveTableName();
+		const ddl = `DROP TABLE IF EXISTS "${esc(tableName)}"`;
+		this._log(ddl);
+		this.driver.exec(ddl);
+	}
+	async dropColumns(columns) {
+		await this.withTransaction(async () => {
+			const tableName = this.resolveTableName();
+			for (const col of columns) {
+				const ddl = `ALTER TABLE "${esc(tableName)}" DROP COLUMN "${esc(col)}"`;
+				this._log(ddl);
+				this.driver.exec(ddl);
+			}
+		});
+	}
+	async dropTableByName(tableName) {
+		const ddl = `DROP TABLE IF EXISTS "${esc(tableName)}"`;
+		this._log(ddl);
+		this.driver.exec(ddl);
+	}
+	async dropViewByName(viewName) {
+		const ddl = `DROP VIEW IF EXISTS "${esc(viewName)}"`;
+		this._log(ddl);
+		this.driver.exec(ddl);
+	}
+	async renameTable(oldName) {
+		const newName = this.resolveTableName();
+		const ddl = `ALTER TABLE "${esc(oldName)}" RENAME TO "${esc(newName)}"`;
+		this._log(ddl);
+		this.driver.exec(ddl);
+	}
+	typeMapper(field) {
+		if (field.isPrimaryKey && (field.designType === "number" || field.designType === "integer")) return "INTEGER";
+		return sqliteTypeFromDesignType(field.designType);
+	}
+	async getExistingColumnsForTable(tableName) {
+		const rows = this.driver.all(`PRAGMA table_info("${esc(tableName)}")`);
+		return rows.map((r) => ({
+			name: r.name,
+			type: r.type,
+			notnull: r.notnull === 1,
+			pk: r.pk > 0,
+			dflt_value: normalizeSqliteDefault(r.dflt_value)
+		}));
+	}
 	async syncIndexes() {
 		const tableName = this.resolveTableName();
 		await this.syncIndexesWithDiff({
@@ -433,75 +673,47 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 			createIndex: async (index) => {
 				const unique = index.type === "unique" ? "UNIQUE " : "";
 				const cols = index.fields.map((f) => `"${esc(f.name)}" ${f.sort === "desc" ? "DESC" : "ASC"}`).join(", ");
-				this.driver.exec(`CREATE ${unique}INDEX IF NOT EXISTS "${esc(index.key)}" ON "${esc(tableName)}" (${cols})`);
+				const sql = `CREATE ${unique}INDEX IF NOT EXISTS "${esc(index.key)}" ON "${esc(tableName)}" (${cols})`;
+				this._log(sql);
+				this.driver.exec(sql);
 			},
 			dropIndex: async (name) => {
-				this.driver.exec(`DROP INDEX IF EXISTS "${esc(name)}"`);
+				const sql = `DROP INDEX IF EXISTS "${esc(name)}"`;
+				this._log(sql);
+				this.driver.exec(sql);
 			},
 			shouldSkipType: (type) => type === "fulltext"
 		});
 	}
 	constructor(driver) {
-		super(), _define_property$1(this, "driver", void 0), this.driver = driver;
-		driver.exec("PRAGMA foreign_keys = ON");
+		super(), _define_property(this, "driver", void 0), this.driver = driver;
+		this.driver.exec("PRAGMA foreign_keys = ON");
 	}
 };
-function esc(name) {
-	return name.replace(/"/g, "\"\"");
+/** Returns a safe SQLite DEFAULT literal for a given design type. */ function defaultValueForType(designType) {
+	switch (designType) {
+		case "number":
+		case "integer": return "0";
+		case "boolean": return "0";
+		default: return "''";
+	}
 }
-function toSqliteValue(value) {
-	if (value === undefined) return null;
-	if (value === null) return null;
-	if (typeof value === "object") return JSON.stringify(value);
-	if (typeof value === "boolean") return value ? 1 : 0;
+/** Normalizes SQLite PRAGMA dflt_value to match serialized format.
+*  PRAGMA returns `'active'` (SQL-quoted), we store `active` (raw). */ function normalizeSqliteDefault(value) {
+	if (value == null) return undefined;
+	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
 	return value;
 }
 
 //#endregion
-//#region packages/db-sqlite/src/better-sqlite3-driver.ts
-function _define_property(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-else obj[key] = value;
-	return obj;
+//#region packages/db-sqlite/src/index.ts
+function createAdapter(connection, options) {
+	const driver = new BetterSqlite3Driver(connection, options);
+	return new __atscript_utils_db.DbSpace(() => new SqliteAdapter(driver));
 }
-var BetterSqlite3Driver = class {
-	run(sql, params) {
-		const stmt = this.db.prepare(sql);
-		const result = params ? stmt.run(...params) : stmt.run();
-		return {
-			changes: result.changes,
-			lastInsertRowid: result.lastInsertRowid
-		};
-	}
-	all(sql, params) {
-		const stmt = this.db.prepare(sql);
-		return params ? stmt.all(...params) : stmt.all();
-	}
-	get(sql, params) {
-		const stmt = this.db.prepare(sql);
-		return (params ? stmt.get(...params) : stmt.get()) ?? null;
-	}
-	exec(sql) {
-		this.db.exec(sql);
-	}
-	close() {
-		this.db.close();
-	}
-	constructor(pathOrDb, options) {
-		_define_property(this, "db", void 0);
-		if (typeof pathOrDb === "string") {
-			const Database = require("better-sqlite3");
-			this.db = new Database(pathOrDb, options);
-		} else this.db = pathOrDb;
-	}
-};
 
 //#endregion
 exports.BetterSqlite3Driver = BetterSqlite3Driver
 exports.SqliteAdapter = SqliteAdapter
-exports.buildWhere = buildWhere
+exports.buildWhere = buildWhere
+exports.createAdapter = createAdapter