@atscript/db-sqlite 0.1.37 → 0.1.39

package/dist/index.mjs

@@ -1,13 +1,7 @@
-import { AtscriptDbView, BaseDbAdapter, DbError, DbSpace } from "@atscript/utils-db";
-import { walkFilter } from "@uniqu/core";
+import { AtscriptDbView, BaseDbAdapter, DbError, DbSpace } from "@atscript/db";
+import { createRequire } from "node:module";
+import { buildAggregateCount, buildAggregateSelect, buildCreateView, buildDelete, buildInsert, buildSelect, buildUpdate, buildWhere as buildWhere$1, defaultValueForType, defaultValueToSqlLiteral, refActionToSql, toSqlValue } from "@atscript/db-sql-tools";
 
-//#region rolldown:runtime
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
-	if (typeof require !== "undefined") return require.apply(this, arguments);
-	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function.");
-});
-
-//#endregion
 //#region packages/db-sqlite/src/better-sqlite3-driver.ts
 function _define_property$1(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
@@ -45,7 +39,8 @@ var BetterSqlite3Driver = class {
 	constructor(pathOrDb, options) {
 		_define_property$1(this, "db", void 0);
 		if (typeof pathOrDb === "string") {
-			const Database = __require("better-sqlite3");
+			const req = createRequire(import.meta.url);
+			const Database = req("better-sqlite3");
 			this.db = new Database(pathOrDb, options);
 		} else this.db = pathOrDb;
 	}
@@ -53,55 +48,80 @@ var BetterSqlite3Driver = class {
 
 //#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 esc(name) {
+	return name.replace(/"/g, "\"\"");
 }
-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
-	};
+/**
+* Basic regex-to-LIKE conversion.
+* - `^abc` → `abc%`
+* - `abc$` → `%abc`
+* - `^abc$` → `abc`
+* - `abc` → `%abc%`
+*/ function regexToLike(pattern) {
+	const hasStart = pattern.startsWith("^");
+	const hasEnd = pattern.endsWith("$");
+	let core = pattern;
+	if (hasStart) core = core.slice(1);
+	if (hasEnd) core = core.slice(0, -1);
+	core = core.replace(/%/g, "\\%").replace(/_/g, "\\_");
+	core = core.replace(/\.\*/g, "%").replace(/\./g, "_");
+	if (hasStart && hasEnd) return core;
+	if (hasStart) return `${core}%`;
+	if (hasEnd) return `%${core}`;
+	return `%${core}%`;
+}
+const sqliteDialect = {
+	quoteIdentifier(name) {
+		return `"${esc(name)}"`;
+	},
+	quoteTable(name) {
+		return `"${esc(name)}"`;
+	},
+	unlimitedLimit: "-1",
+	toValue: toSqlValue,
+	toParam(value) {
+		if (value === undefined) return null;
+		return typeof value === "boolean" ? value ? 1 : 0 : value;
+	},
+	regex(quotedCol, value) {
+		const pattern = regexToLike(value instanceof RegExp ? value.source : String(value));
+		return {
+			sql: `${quotedCol} LIKE ?`,
+			params: [pattern]
+		};
+	},
+	createViewPrefix: "CREATE VIEW IF NOT EXISTS"
+};
+function buildInsert$1(table, data) {
+	return buildInsert(sqliteDialect, table, data);
 }
-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 buildSelect$1(table, where, controls) {
+	return buildSelect(sqliteDialect, table, where, controls);
 }
-function buildDelete(table, where) {
-	return {
-		sql: `DELETE FROM "${esc(table)}" WHERE ${where.sql}`,
-		params: [...where.params]
-	};
+function buildUpdate$1(table, data, where) {
+	return buildUpdate(sqliteDialect, table, data, where);
+}
+function buildDelete$1(table, where) {
+	return buildDelete(sqliteDialect, table, where);
+}
+function buildCreateView$1(viewName, plan, columns, resolveFieldRef) {
+	return buildCreateView(sqliteDialect, viewName, plan, columns, resolveFieldRef);
+}
+function buildAggregateSelect$1(table, where, controls) {
+	return buildAggregateSelect(sqliteDialect, table, where, controls);
+}
+function buildAggregateCount$1(table, where, controls) {
+	return buildAggregateCount(sqliteDialect, table, where, controls);
+}
+function sqliteTypeFromDesignType(designType) {
+	switch (designType) {
+		case "number":
+		case "integer":
+		case "decimal": return "REAL";
+		case "boolean": return "INTEGER";
+		case "string": return "TEXT";
+		default: return "TEXT";
+	}
 }
 function buildCreateTable(table, fields, foreignKeys) {
 	const colDefs = [];
@@ -110,9 +130,13 @@ function buildCreateTable(table, fields, foreignKeys) {
 		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.isPrimaryKey && primaryKeys.length === 1) {
+			def += " PRIMARY KEY";
+			if (field.defaultValue?.kind === "fn" && field.defaultValue.fn === "increment" && (field.designType === "number" || field.designType === "integer")) def += " AUTOINCREMENT";
+		}
 		if (!field.optional && !field.isPrimaryKey) def += " NOT NULL";
-		if (field.defaultValue?.kind === "value") def += ` DEFAULT ${sqlStringLiteral(field.defaultValue.value)}`;
+		if (field.defaultValue?.kind === "value") def += ` DEFAULT ${defaultValueToSqlLiteral(field.designType, field.defaultValue.value)}`;
+		if (field.collate) def += ` COLLATE ${field.collate.toUpperCase()}`;
 		colDefs.push(def);
 	}
 	if (primaryKeys.length > 1) {
@@ -129,228 +153,19 @@ function buildCreateTable(table, fields, foreignKeys) {
 	}
 	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",
-	params: []
-};
-const EMPTY_OR = {
-	sql: "0=1",
-	params: []
-};
-/**
-* SQL visitor for `walkFilter` — renders a filter expression tree
-* into a parameterized SQL WHERE clause.
-*/ const sqlVisitor = {
-	comparison(field, op, value) {
-		const col = `"${esc(field)}"`;
-		const v = toSqliteParam(value);
-		switch (op) {
-			case "$eq": {
-				if (v === null) return {
-					sql: `${col} IS NULL`,
-					params: []
-				};
-				return {
-					sql: `${col} = ?`,
-					params: [v]
-				};
-			}
-			case "$ne": {
-				if (v === null) return {
-					sql: `${col} IS NOT NULL`,
-					params: []
-				};
-				return {
-					sql: `${col} != ?`,
-					params: [v]
-				};
-			}
-			case "$gt": return {
-				sql: `${col} > ?`,
-				params: [v]
-			};
-			case "$gte": return {
-				sql: `${col} >= ?`,
-				params: [v]
-			};
-			case "$lt": return {
-				sql: `${col} < ?`,
-				params: [v]
-			};
-			case "$lte": return {
-				sql: `${col} <= ?`,
-				params: [v]
-			};
-			case "$in": {
-				const arr = value.map(toSqliteParam);
-				if (arr.length === 0) return EMPTY_OR;
-				const placeholders = arr.map(() => "?").join(", ");
-				return {
-					sql: `${col} IN (${placeholders})`,
-					params: [...arr]
-				};
-			}
-			case "$nin": {
-				const arr = value.map(toSqliteParam);
-				if (arr.length === 0) return EMPTY_AND;
-				const placeholders = arr.map(() => "?").join(", ");
-				return {
-					sql: `${col} NOT IN (${placeholders})`,
-					params: [...arr]
-				};
-			}
-			case "$exists": return value ? {
-				sql: `${col} IS NOT NULL`,
-				params: []
-			} : {
-				sql: `${col} IS NULL`,
-				params: []
-			};
-			case "$regex": {
-				const pattern = regexToLike(value instanceof RegExp ? value.source : String(value));
-				return {
-					sql: `${col} LIKE ?`,
-					params: [pattern]
-				};
-			}
-			default: throw new Error(`Unsupported filter operator: ${op}`);
-		}
-	},
-	and(children) {
-		if (children.length === 0) return EMPTY_AND;
-		return {
-			sql: children.map((c) => c.sql).join(" AND "),
-			params: children.flatMap((c) => c.params)
-		};
-	},
-	or(children) {
-		if (children.length === 0) return EMPTY_OR;
-		return {
-			sql: `(${children.map((c) => c.sql).join(" OR ")})`,
-			params: children.flatMap((c) => c.params)
-		};
-	},
-	not(child) {
-		return {
-			sql: `NOT (${child.sql})`,
-			params: child.params
-		};
-	}
-};
 function buildWhere(filter) {
-	if (!filter || Object.keys(filter).length === 0) return EMPTY_AND;
-	return walkFilter(filter, sqlVisitor) ?? EMPTY_AND;
+	return buildWhere$1(sqliteDialect, filter);
 }
-/**
-* Basic regex-to-LIKE conversion.
-* - `^abc` → `abc%`
-* - `abc$` → `%abc`
-* - `^abc$` → `abc`
-* - `abc` → `%abc%`
-*/ function regexToLike(pattern) {
-	const hasStart = pattern.startsWith("^");
-	const hasEnd = pattern.endsWith("$");
-	let core = pattern;
-	if (hasStart) core = core.slice(1);
-	if (hasEnd) core = core.slice(0, -1);
-	core = core.replace(/%/g, "\\%").replace(/_/g, "\\_");
-	core = core.replace(/\.\*/g, "%").replace(/\./g, "_");
-	if (hasStart && hasEnd) return core;
-	if (hasStart) return `${core}%`;
-	if (hasEnd) return `%${core}`;
-	return `%${core}%`;
-}
-/**
-* Converts a JS value to a SQLite-bindable parameter.
-* SQLite cannot bind booleans — they must be 0/1.
-*/ function toSqliteParam(value) {
-	if (typeof value === "boolean") return value ? 1 : 0;
-	return value;
+function buildPrefixedWhere(alias, filter) {
+	return buildWhere$1({
+		...sqliteDialect,
+		quoteIdentifier(name) {
+			return `${alias}."${esc(name)}"`;
+		}
+	}, filter);
 }
 
 //#endregion
@@ -366,6 +181,9 @@ else obj[key] = value;
 	return obj;
 }
 var SqliteAdapter = class extends BaseDbAdapter {
+	supportsNativeValueDefaults() {
+		return true;
+	}
 	async _beginTransaction() {
 		this._log("BEGIN");
 		this.driver.exec("BEGIN");
@@ -394,39 +212,39 @@ var SqliteAdapter = class extends BaseDbAdapter {
 	*/ _wrapConstraintError(fn) {
 		try {
 			return fn();
-		} catch (e) {
-			if (e instanceof Error) {
-				if (e.message.includes("FOREIGN KEY constraint failed")) throw new DbError("FK_VIOLATION", [{
+		} catch (error) {
+			if (error instanceof Error) {
+				if (error.message.includes("FOREIGN KEY constraint failed")) throw new DbError("FK_VIOLATION", [{
 					path: "",
-					message: e.message
+					message: error.message
 				}]);
-				const uniqueMatch = e.message.match(/UNIQUE constraint failed:\s*\S+\.(\S+)/);
+				const uniqueMatch = error.message.match(/UNIQUE constraint failed:\s*\S+\.(\S+)/);
 				if (uniqueMatch) throw new DbError("CONFLICT", [{
 					path: uniqueMatch[1],
-					message: e.message
+					message: error.message
 				}]);
-				if (e.message.includes("UNIQUE constraint failed")) throw new DbError("CONFLICT", [{
+				if (error.message.includes("UNIQUE constraint failed")) throw new DbError("CONFLICT", [{
 					path: "",
-					message: e.message
+					message: error.message
 				}]);
 			}
-			throw e;
+			throw error;
 		}
 	}
 	async insertOne(data) {
-		const { sql, params } = buildInsert(this.resolveTableName(), data);
+		const { sql, params } = buildInsert$1(this.resolveTableName(), data);
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
-		return { insertedId: result.lastInsertRowid };
+		return { insertedId: this._resolveInsertedId(data, result.lastInsertRowid) };
 	}
 	async insertMany(data) {
 		return this.withTransaction(async () => {
 			const ids = [];
 			for (const row of data) {
-				const { sql, params } = buildInsert(this.resolveTableName(), row);
+				const { sql, params } = buildInsert$1(this.resolveTableName(), row);
 				this._log(sql, params);
 				const result = this._wrapConstraintError(() => this.driver.run(sql, params));
-				ids.push(result.lastInsertRowid);
+				ids.push(this._resolveInsertedId(row, result.lastInsertRowid));
 			}
 			return {
 				insertedCount: ids.length,
@@ -440,13 +258,13 @@ var SqliteAdapter = class extends BaseDbAdapter {
 			...query.controls,
 			$limit: 1
 		};
-		const { sql, params } = buildSelect(this.resolveTableName(), where, controls);
+		const { sql, params } = buildSelect$1(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);
+		const { sql, params } = buildSelect$1(this.resolveTableName(), where, query.controls);
 		this._log(sql, params);
 		return this.driver.all(sql, params);
 	}
@@ -458,6 +276,19 @@ var SqliteAdapter = class extends BaseDbAdapter {
 		const row = this.driver.get(sql, where.params);
 		return row?.cnt ?? 0;
 	}
+	async aggregate(query) {
+		const where = buildWhere(query.filter);
+		const tableName = this.resolveTableName();
+		if (query.controls.$count) {
+			const { sql: sql$1, params: params$1 } = buildAggregateCount$1(tableName, where, query.controls);
+			this._log(sql$1, params$1);
+			const row = this.driver.get(sql$1, params$1);
+			return [{ count: row?.count ?? 0 }];
+		}
+		const { sql, params } = buildAggregateSelect$1(tableName, where, query.controls);
+		this._log(sql, params);
+		return this.driver.all(sql, params);
+	}
 	async updateOne(filter, data) {
 		const where = buildWhere(filter);
 		const tableName = this.resolveTableName();
@@ -465,7 +296,7 @@ var SqliteAdapter = class extends BaseDbAdapter {
 		const setParams = [];
 		for (const [key, value] of Object.entries(data)) {
 			setClauses.push(`"${esc(key)}" = ?`);
-			setParams.push(toSqliteValue(value));
+			setParams.push(toSqlValue(value));
 		}
 		const sql = `UPDATE "${esc(tableName)}" SET ${setClauses.join(", ")} WHERE rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`;
 		const allParams = [...setParams, ...where.params];
@@ -478,7 +309,7 @@ var SqliteAdapter = class extends BaseDbAdapter {
 	}
 	async updateMany(filter, data) {
 		const where = buildWhere(filter);
-		const { sql, params } = buildUpdate(this.resolveTableName(), data, where);
+		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where);
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
@@ -493,7 +324,7 @@ var SqliteAdapter = class extends BaseDbAdapter {
 			sql: `rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`,
 			params: where.params
 		};
-		const { sql, params } = buildUpdate(tableName, data, limitedWhere);
+		const { sql, params } = buildUpdate$1(tableName, data, limitedWhere);
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
@@ -503,7 +334,7 @@ var SqliteAdapter = class extends BaseDbAdapter {
 	}
 	async replaceMany(filter, data) {
 		const where = buildWhere(filter);
-		const { sql, params } = buildUpdate(this.resolveTableName(), data, where);
+		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where);
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
@@ -521,7 +352,7 @@ var SqliteAdapter = class extends BaseDbAdapter {
 	}
 	async deleteMany(filter) {
 		const where = buildWhere(filter);
-		const { sql, params } = buildDelete(this.resolveTableName(), where);
+		const { sql, params } = buildDelete$1(this.resolveTableName(), where);
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return { deletedCount: result.changes };
@@ -531,10 +362,26 @@ var SqliteAdapter = class extends BaseDbAdapter {
 		const sql = buildCreateTable(this.resolveTableName(), this._table.fieldDescriptors, this._table.foreignKeys);
 		this._log(sql);
 		this.driver.exec(sql);
+		this._seedIncrementStart();
+	}
+	/**
+	* Seeds the sqlite_sequence table for auto-increment fields that have a start value.
+	* Only applies once per adapter instance (idempotent via INSERT OR IGNORE + flag).
+	*/ _seedIncrementStart() {
+		if (this._incrementSeeded) return;
+		this._incrementSeeded = true;
+		const tableName = this.resolveTableName();
+		for (const def of this._table.defaults.values()) if (def.kind === "fn" && def.fn === "increment" && typeof def.start === "number") {
+			const seedSql = `INSERT OR IGNORE INTO sqlite_sequence(name, seq) VALUES(?, ?)`;
+			const params = [tableName, def.start - 1];
+			this._log(seedSql, params);
+			this.driver.run(seedSql, params);
+			break;
+		}
 	}
 	async ensureView() {
 		const view = this._table;
-		const sql = buildCreateView(this.resolveTableName(), view.viewPlan, view.getViewColumnMappings(), (ref) => view.resolveFieldRef(ref));
+		const sql = buildCreateView$1(this.resolveTableName(), view.viewPlan, view.getViewColumnMappings(), (ref) => view.resolveFieldRef(ref));
 		this._log(sql);
 		this.driver.exec(sql);
 	}
@@ -555,8 +402,9 @@ var SqliteAdapter = class extends BaseDbAdapter {
 			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)}`;
+			if (field.defaultValue?.kind === "value") ddl += ` DEFAULT ${defaultValueToSqlLiteral(field.designType, field.defaultValue.value)}`;
 else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValueForType(field.designType)}`;
+			if (field.collate) ddl += ` COLLATE ${field.collate.toUpperCase()}`;
 			this._log(ddl);
 			this.driver.exec(ddl);
 			added.push(field.physicalName);
@@ -569,6 +417,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 	async recreateTable() {
 		const tableName = this.resolveTableName();
 		const tempName = `${tableName}__tmp_${Date.now()}`;
+		this._dropAllFtsTables(tableName);
 		this.driver.exec("PRAGMA foreign_keys = OFF");
 		this.driver.exec("PRAGMA legacy_alter_table = ON");
 		try {
@@ -585,7 +434,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 				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);
+						const fallback = field.defaultValue?.kind === "value" ? defaultValueToSqlLiteral(field.designType, field.defaultValue.value) : defaultValueForType(field.designType);
 						return `COALESCE("${esc(c)}", ${fallback}) AS "${esc(c)}"`;
 					}
 					return `"${esc(c)}"`;
@@ -605,6 +454,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 	}
 	async dropTable() {
 		const tableName = this.resolveTableName();
+		this._dropAllFtsTables(tableName);
 		const ddl = `DROP TABLE IF EXISTS "${esc(tableName)}"`;
 		this._log(ddl);
 		this.driver.exec(ddl);
@@ -620,6 +470,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 		});
 	}
 	async dropTableByName(tableName) {
+		this._dropAllFtsTables(tableName);
 		const ddl = `DROP TABLE IF EXISTS "${esc(tableName)}"`;
 		this._log(ddl);
 		this.driver.exec(ddl);
@@ -667,23 +518,151 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 			},
 			shouldSkipType: (type) => type === "fulltext"
 		});
+		this._syncFtsIndexes(tableName);
+	}
+	getSearchIndexes() {
+		return this._getFulltextIndexes().map((idx) => ({
+			name: idx.name,
+			description: `FTS5 index (${idx.fields.map((f) => f.name).join(", ")})`,
+			type: "text"
+		}));
+	}
+	async search(text, query, indexName) {
+		if (!text.trim()) return [];
+		const base = this._buildFtsBase(text, query.filter, indexName);
+		const controls = query.controls || {};
+		let cols = "t.*";
+		if (controls.$select?.asArray?.length) cols = controls.$select.asArray.map((c) => `t."${esc(c)}"`).join(", ");
+		let sql = `SELECT ${cols} ${base.fromWhere}`;
+		const params = [...base.params];
+		if (controls.$sort) {
+			const orderParts = [];
+			for (const [col, dir] of Object.entries(controls.$sort)) orderParts.push(`t."${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);
+		}
+		this._log(sql, params);
+		return this.driver.all(sql, params);
+	}
+	async searchWithCount(text, query, indexName) {
+		if (!text.trim()) return {
+			data: [],
+			count: 0
+		};
+		const data = await this.search(text, query, indexName);
+		const base = this._buildFtsBase(text, query.filter, indexName);
+		const countSql = `SELECT COUNT(*) as cnt ${base.fromWhere}`;
+		this._log(countSql, base.params);
+		const row = this.driver.get(countSql, base.params);
+		return {
+			data,
+			count: row?.cnt ?? 0
+		};
+	}
+	/** Builds FTS table name from index name: `<table>__fts__<indexName>`. */ _ftsTableName(indexName) {
+		return `${this.resolveTableName()}__fts__${indexName}`;
+	}
+	/** Returns fulltext indexes from table metadata. */ _getFulltextIndexes() {
+		const result = [];
+		for (const index of this._table.indexes.values()) if (index.type === "fulltext") result.push(index);
+		return result;
+	}
+	/** Resolves a fulltext index by name, or returns the first available. */ _resolveFtsIndex(indexName) {
+		const ftIndexes = this._getFulltextIndexes();
+		if (ftIndexes.length === 0) throw new Error("No search index available");
+		if (indexName) {
+			const found = ftIndexes.find((idx) => idx.name === indexName);
+			if (!found) throw new Error(`Search index "${indexName}" not found`);
+			return found;
+		}
+		return ftIndexes[0];
+	}
+	/**
+	* Builds the shared FROM+JOIN+WHERE fragment for FTS5 queries.
+	* Both data and count queries reuse this to avoid duplicating index resolution and filter translation.
+	*/ _buildFtsBase(text, filter, indexName) {
+		const ftsIndex = this._resolveFtsIndex(indexName);
+		const ftsTable = this._ftsTableName(ftsIndex.name);
+		const tableName = this.resolveTableName();
+		const where = buildPrefixedWhere("t", filter);
+		let fromWhere = `FROM "${esc(tableName)}" AS t`;
+		fromWhere += ` JOIN "${esc(ftsTable)}" AS fts ON t.rowid = fts.rowid`;
+		fromWhere += ` WHERE fts."${esc(ftsTable)}" MATCH ?`;
+		const params = [text];
+		if (where.sql !== "1=1") {
+			fromWhere += ` AND (${where.sql})`;
+			params.push(...where.params);
+		}
+		return {
+			fromWhere,
+			params
+		};
+	}
+	/**
+	* Creates/drops FTS5 virtual tables and sync triggers to match desired fulltext indexes.
+	*/ _syncFtsIndexes(tableName) {
+		const ftIndexes = this._getFulltextIndexes();
+		const desiredFtsTables = new Set(ftIndexes.map((idx) => this._ftsTableName(idx.name)));
+		const existingFts = this.driver.all(`SELECT name, sql FROM sqlite_master WHERE type='table' AND name LIKE ?`, [`${tableName}__fts__%`]).filter((r) => r.sql.startsWith("CREATE VIRTUAL TABLE")).map((r) => r.name);
+		for (const name of existingFts) if (!desiredFtsTables.has(name)) this._dropFtsTable(name);
+		const existingSet = new Set(existingFts);
+		for (const index of ftIndexes) {
+			const ftsTable = this._ftsTableName(index.name);
+			if (!existingSet.has(ftsTable)) this._createFtsTable(tableName, ftsTable, index);
+		}
+	}
+	/** Creates an FTS5 virtual table with sync triggers and rebuilds the index. */ _createFtsTable(tableName, ftsTable, index) {
+		const fieldNames = index.fields.map((f) => `"${esc(f.name)}"`);
+		const fieldList = fieldNames.join(", ");
+		const createSql = `CREATE VIRTUAL TABLE IF NOT EXISTS "${esc(ftsTable)}" USING fts5(${fieldList}, content='${tableName.replace(/'/g, "''")}', content_rowid='rowid')`;
+		this._log(createSql);
+		this.driver.exec(createSql);
+		const newFields = index.fields.map((f) => `new."${esc(f.name)}"`).join(", ");
+		const oldFields = index.fields.map((f) => `old."${esc(f.name)}"`).join(", ");
+		const ef = esc(ftsTable);
+		const aiSql = `CREATE TRIGGER IF NOT EXISTS "${esc(ftsTable + "__ai")}" AFTER INSERT ON "${esc(tableName)}" BEGIN INSERT INTO "${ef}"(rowid, ${fieldList}) VALUES (new.rowid, ${newFields}); END`;
+		this._log(aiSql);
+		this.driver.exec(aiSql);
+		const adSql = `CREATE TRIGGER IF NOT EXISTS "${esc(ftsTable + "__ad")}" AFTER DELETE ON "${esc(tableName)}" BEGIN INSERT INTO "${ef}"("${ef}", rowid, ${fieldList}) VALUES ('delete', old.rowid, ${oldFields}); END`;
+		this._log(adSql);
+		this.driver.exec(adSql);
+		const auSql = `CREATE TRIGGER IF NOT EXISTS "${esc(ftsTable + "__au")}" AFTER UPDATE ON "${esc(tableName)}" BEGIN INSERT INTO "${ef}"("${ef}", rowid, ${fieldList}) VALUES ('delete', old.rowid, ${oldFields}); INSERT INTO "${ef}"(rowid, ${fieldList}) VALUES (new.rowid, ${newFields}); END`;
+		this._log(auSql);
+		this.driver.exec(auSql);
+		const rebuildSql = `INSERT INTO "${ef}"("${ef}") VALUES ('rebuild')`;
+		this._log(rebuildSql);
+		this.driver.exec(rebuildSql);
+	}
+	/** Drops an FTS5 virtual table and its sync triggers. */ _dropFtsTable(ftsTable) {
+		for (const suffix of [
+			"__ai",
+			"__ad",
+			"__au"
+		]) this.driver.exec(`DROP TRIGGER IF EXISTS "${esc(ftsTable + suffix)}"`);
+		const sql = `DROP TABLE IF EXISTS "${esc(ftsTable)}"`;
+		this._log(sql);
+		this.driver.exec(sql);
+	}
+	/** Drops all FTS virtual tables and triggers for a content table. */ _dropAllFtsTables(tableName) {
+		const ftsTables = this.driver.all(`SELECT name, sql FROM sqlite_master WHERE type='table' AND name LIKE ?`, [`${tableName}__fts__%`]).filter((r) => r.sql.startsWith("CREATE VIRTUAL TABLE"));
+		for (const { name } of ftsTables) this._dropFtsTable(name);
 	}
 	constructor(driver) {
-		super(), _define_property(this, "driver", void 0), this.driver = driver;
+		super(), _define_property(this, "driver", void 0), _define_property(this, "_incrementSeeded", void 0), this.driver = driver, this._incrementSeeded = false;
 		this.driver.exec("PRAGMA foreign_keys = ON");
 	}
 };
-/** 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 "''";
-	}
-}
 /** 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 === null) return undefined;
 	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
 	return value;
 }