@atscript/db-sqlite 0.1.28

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Atscript
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,208 @@
+# @atscript/db-sqlite
+
+SQLite adapter for `@atscript/utils-db` with a swappable driver architecture. Define your schema once in Atscript, then use it with any SQLite engine.
+
+## Architecture
+
+```
+AtscriptDbTable ──delegates──▶ SqliteAdapter ──delegates──▶ TSqliteDriver
+                                (extends BaseDbAdapter)      (interface)
+                                                                │
+                                                     ┌─────────┴──────────┐
+                                                     │                    │
+                                            BetterSqlite3Driver    (your own driver)
+                                            (ships with package)    node:sqlite
+                                                                    sql.js, etc.
+```
+
+The adapter defines a minimal `TSqliteDriver` interface — just raw SQL primitives (`run`, `all`, `get`, `exec`, `close`). The actual SQLite engine is injected, not hardcoded.
+
+## Installation
+
+```bash
+pnpm add @atscript/db-sqlite better-sqlite3
+```
+
+`better-sqlite3` is an **optional peer dependency** — only required if you use the built-in `BetterSqlite3Driver`. Bring your own driver if you prefer a different engine.
+
+## Quick Start
+
+```typescript
+import { AtscriptDbTable } from '@atscript/utils-db'
+import { SqliteAdapter, BetterSqlite3Driver } from '@atscript/db-sqlite'
+import { User } from './user.as'
+
+// 1. Create a driver (in-memory or file-based)
+const driver = new BetterSqlite3Driver(':memory:')
+// or: new BetterSqlite3Driver('./data.db')
+
+// 2. Create adapter + table
+const adapter = new SqliteAdapter(driver)
+const users = new AtscriptDbTable(User, adapter)
+
+// 3. Set up schema
+await users.ensureTable()   // CREATE TABLE IF NOT EXISTS
+await users.syncIndexes()   // CREATE INDEX / DROP INDEX
+
+// 4. CRUD
+await users.insertOne({ name: 'John', email: 'john@example.com' })
+const john = await users.findOne({ name: 'John' })
+await users.findMany({ status: 'active' }, { limit: 10, sort: { name: 1 } })
+await users.count({ status: 'active' })
+await users.updateMany({ status: 'inactive' }, { status: 'archived' })
+await users.deleteOne(123)
+await users.deleteMany({ status: 'archived' })
+```
+
+## Swapping the Driver
+
+The `TSqliteDriver` interface is minimal — implement these 5 methods:
+
+```typescript
+interface TSqliteDriver {
+  run(sql: string, params?: unknown[]): TSqliteRunResult
+  all<T>(sql: string, params?: unknown[]): T[]
+  get<T>(sql: string, params?: unknown[]): T | null
+  exec(sql: string): void
+  close(): void
+}
+
+interface TSqliteRunResult {
+  changes: number
+  lastInsertRowid: number | bigint
+}
+```
+
+### Example: Custom driver
+
+```typescript
+import { SqliteAdapter, type TSqliteDriver } from '@atscript/db-sqlite'
+
+class MyDriver implements TSqliteDriver {
+  run(sql: string, params?: unknown[]) {
+    // your implementation
+    return { changes: 0, lastInsertRowid: 0 }
+  }
+  all(sql: string, params?: unknown[]) { /* ... */ }
+  get(sql: string, params?: unknown[]) { /* ... */ }
+  exec(sql: string) { /* ... */ }
+  close() { /* ... */ }
+}
+
+const adapter = new SqliteAdapter(new MyDriver())
+```
+
+### Example: node:sqlite (Node 22.5+)
+
+```typescript
+import { DatabaseSync } from 'node:sqlite'
+import { SqliteAdapter, type TSqliteDriver } from '@atscript/db-sqlite'
+
+class NodeSqliteDriver implements TSqliteDriver {
+  private db: DatabaseSync
+
+  constructor(path: string) {
+    this.db = new DatabaseSync(path)
+  }
+
+  run(sql: string, params?: unknown[]) {
+    const stmt = this.db.prepare(sql)
+    stmt.run(...(params ?? []))
+    return {
+      changes: this.db.changes,
+      lastInsertRowid: this.db.lastInsertRowId,
+    }
+  }
+
+  all<T>(sql: string, params?: unknown[]): T[] {
+    return this.db.prepare(sql).all(...(params ?? [])) as T[]
+  }
+
+  get<T>(sql: string, params?: unknown[]): T | null {
+    return (this.db.prepare(sql).get(...(params ?? [])) as T) ?? null
+  }
+
+  exec(sql: string) { this.db.exec(sql) }
+  close() { this.db.close() }
+}
+
+const adapter = new SqliteAdapter(new NodeSqliteDriver(':memory:'))
+```
+
+## Filter Syntax
+
+Filters use MongoDB-style query objects (same format as URLQL):
+
+| Filter | SQL |
+|---|---|
+| `{ field: value }` | `field = ?` |
+| `{ field: { $gt: 5 } }` | `field > ?` |
+| `{ field: { $gte: 5 } }` | `field >= ?` |
+| `{ field: { $lt: 5 } }` | `field < ?` |
+| `{ field: { $lte: 5 } }` | `field <= ?` |
+| `{ field: { $ne: value } }` | `field != ?` |
+| `{ field: { $in: [1, 2] } }` | `field IN (?, ?)` |
+| `{ field: { $nin: [1, 2] } }` | `field NOT IN (?, ?)` |
+| `{ field: { $exists: true } }` | `field IS NOT NULL` |
+| `{ field: { $regex: '^abc' } }` | `field LIKE 'abc%'` |
+| `{ $and: [...] }` | `(... AND ...)` |
+| `{ $or: [...] }` | `(... OR ...)` |
+| `{ $not: {...} }` | `NOT (...)` |
+
+All values are parameterized — no SQL injection risk.
+
+## Schema Operations
+
+### `ensureTable()`
+
+Generates `CREATE TABLE IF NOT EXISTS` from the Atscript type:
+- Column types inferred from `designType` (`string` → TEXT, `number` → REAL, `boolean` → INTEGER)
+- Primary keys from `@meta.id`
+- `NOT NULL` for required fields
+- `@db.column` mappings applied (logical → physical column names)
+- `@db.ignore` fields excluded
+
+### `syncIndexes()`
+
+Compares existing indexes with `@db.index.*` annotations:
+- Creates missing indexes (`CREATE INDEX` / `CREATE UNIQUE INDEX`)
+- Drops stale indexes no longer in the definition
+- Supports `@db.index.plain`, `@db.index.unique`
+- `@db.index.fulltext` is skipped (requires FTS5 virtual tables — not auto-managed)
+
+## Write Pipeline
+
+When you call `insertOne(payload)`, `AtscriptDbTable` automatically:
+
+1. Applies `@db.default.value` defaults for missing fields
+2. Validates against the Atscript type
+3. Strips `@db.ignore` fields
+4. Maps `@db.column` logical names to physical column names
+5. Delegates to `SqliteAdapter.insertOne()` which generates and runs the SQL
+
+## Exports
+
+```typescript
+// Classes
+export { SqliteAdapter } from './sqlite-adapter'
+export { BetterSqlite3Driver } from './better-sqlite3-driver'
+
+// Utilities
+export { buildWhere } from './filter-builder'
+
+// Types
+export type { TSqliteDriver, TSqliteRunResult } from './types'
+export type { TSqlFragment } from './filter-builder'
+```
+
+## Why Sync Driver Interface?
+
+The driver interface is **synchronous** because:
+- SQLite is an embedded engine — no network I/O
+- `better-sqlite3` and `node:sqlite` are both synchronous
+- The `SqliteAdapter` wraps sync calls in promises for the async `BaseDbAdapter` contract
+- For truly async drivers, implement the interface with a synchronous wrapper or create a custom adapter subclass
+
+## License
+
+ISC

package/dist/index.cjs

@@ -0,0 +1,478 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __atscript_utils_db = __toESM(require("@atscript/utils-db"));
+
+//#region packages/db-sqlite/src/filter-builder.ts
+function buildWhere(filter) {
+	if (!filter || Object.keys(filter).length === 0) return {
+		sql: "1=1",
+		params: []
+	};
+	const parts = [];
+	const params = [];
+	for (const [key, value] of Object.entries(filter)) if (key === "$and") {
+		const sub = value.map((f) => buildWhere(f));
+		parts.push(`(${sub.map((s) => s.sql).join(" AND ")})`);
+		for (const s of sub) params.push(...s.params);
+	} else if (key === "$or") {
+		const sub = value.map((f) => buildWhere(f));
+		parts.push(`(${sub.map((s) => s.sql).join(" OR ")})`);
+		for (const s of sub) params.push(...s.params);
+	} else if (key === "$not") {
+		const sub = buildWhere(value);
+		parts.push(`NOT (${sub.sql})`);
+		params.push(...sub.params);
+	} else if (typeof value === "object" && value !== null && !Array.isArray(value)) for (const [op, opVal] of Object.entries(value)) {
+		const fragment = buildOperator(key, op, opVal);
+		parts.push(fragment.sql);
+		params.push(...fragment.params);
+	}
+else if (value === null) parts.push(`"${escapeIdent(key)}" IS NULL`);
+else {
+		parts.push(`"${escapeIdent(key)}" = ?`);
+		params.push(value);
+	}
+	return {
+		sql: parts.join(" AND "),
+		params
+	};
+}
+function buildOperator(field, op, value) {
+	const col = `"${escapeIdent(field)}"`;
+	switch (op) {
+		case "$gt": return {
+			sql: `${col} > ?`,
+			params: [value]
+		};
+		case "$gte": return {
+			sql: `${col} >= ?`,
+			params: [value]
+		};
+		case "$lt": return {
+			sql: `${col} < ?`,
+			params: [value]
+		};
+		case "$lte": return {
+			sql: `${col} <= ?`,
+			params: [value]
+		};
+		case "$ne": {
+			if (value === null) return {
+				sql: `${col} IS NOT NULL`,
+				params: []
+			};
+			return {
+				sql: `${col} != ?`,
+				params: [value]
+			};
+		}
+		case "$in": {
+			const arr = value;
+			if (arr.length === 0) return {
+				sql: "0=1",
+				params: []
+			};
+			const placeholders = arr.map(() => "?").join(", ");
+			return {
+				sql: `${col} IN (${placeholders})`,
+				params: [...arr]
+			};
+		}
+		case "$nin": {
+			const arr = value;
+			if (arr.length === 0) return {
+				sql: "1=1",
+				params: []
+			};
+			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(String(value));
+			return {
+				sql: `${col} LIKE ?`,
+				params: [pattern]
+			};
+		}
+		default: throw new Error(`Unsupported filter operator: ${op}`);
+	}
+}
+/**
+* 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}%`;
+}
+/**
+* Escapes a SQL identifier to prevent injection.
+* Doubles any embedded double-quotes.
+*/ function escapeIdent(name) {
+	return name.replace(/"/g, "\"\"");
+}
+
+//#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, options) {
+	const cols = buildProjection(options?.projection);
+	let sql = `SELECT ${cols} FROM "${esc$1(table)}" WHERE ${where.sql}`;
+	const params = [...where.params];
+	if (options?.sort) {
+		const orderParts = [];
+		for (const [col, dir] of Object.entries(options.sort)) orderParts.push(`"${esc$1(col)}" ${dir === -1 ? "DESC" : "ASC"}`);
+		if (orderParts.length > 0) sql += ` ORDER BY ${orderParts.join(", ")}`;
+	}
+	if (options?.limit !== undefined) {
+		sql += ` LIMIT ?`;
+		params.push(options.limit);
+	}
+	if (options?.skip !== undefined) {
+		if (options.limit === undefined) sql += ` LIMIT -1`;
+		sql += ` OFFSET ?`;
+		params.push(options.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) {
+	const colDefs = [];
+	const primaryKeys = fields.filter((f) => f.isPrimaryKey);
+	for (const field of fields) {
+		if (field.ignored) continue;
+		const sqlType = 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})`);
+	}
+	return `CREATE TABLE IF NOT EXISTS "${esc$1(table)}" (${colDefs.join(", ")})`;
+}
+function sqliteTypeFromDesignType(designType) {
+	switch (designType) {
+		case "number":
+		case "integer": return "REAL";
+		case "boolean": return "INTEGER";
+		case "string": return "TEXT";
+		default: return "TEXT";
+	}
+}
+function buildProjection(projection) {
+	if (!projection) return "*";
+	if (Array.isArray(projection)) {
+		if (projection.length === 0) return "*";
+		return projection.map((k) => `"${esc$1(k)}"`).join(", ");
+	}
+	const entries = Object.entries(projection);
+	if (entries.length === 0) return "*";
+	const firstVal = entries[0][1];
+	if (firstVal === 1) return entries.filter(([_, v]) => v === 1).map(([k]) => `"${esc$1(k)}"`).join(", ");
+	return "*";
+}
+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) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
+	/** SQLite does not use schemas — override to always exclude schema. */ resolveTableName() {
+		return super.resolveTableName(false);
+	}
+	prepareId(id, _fieldType) {
+		return id;
+	}
+	async insertOne(data) {
+		const { sql, params } = buildInsert(this.resolveTableName(), data);
+		const result = this.driver.run(sql, params);
+		return { insertedId: result.lastInsertRowid };
+	}
+	async insertMany(data) {
+		const ids = [];
+		this.driver.exec("BEGIN");
+		try {
+			for (const row of data) {
+				const { sql, params } = buildInsert(this.resolveTableName(), row);
+				const result = 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
+		};
+	}
+	async findOne(filter, options) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildSelect(this.resolveTableName(), where, {
+			...options,
+			limit: 1
+		});
+		return this.driver.get(sql, params);
+	}
+	async findMany(filter, options) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildSelect(this.resolveTableName(), where, options);
+		return this.driver.all(sql, params);
+	}
+	async count(filter) {
+		const where = buildWhere(filter);
+		const tableName = this.resolveTableName();
+		const sql = `SELECT COUNT(*) as cnt FROM "${esc(tableName)}" WHERE ${where.sql}`;
+		const row = this.driver.get(sql, where.params);
+		return row?.cnt ?? 0;
+	}
+	async updateOne(filter, data) {
+		const where = buildWhere(filter);
+		const tableName = this.resolveTableName();
+		const setClauses = [];
+		const setParams = [];
+		for (const [key, value] of Object.entries(data)) {
+			setClauses.push(`"${esc(key)}" = ?`);
+			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]);
+		return {
+			matchedCount: result.changes,
+			modifiedCount: result.changes
+		};
+	}
+	async updateMany(filter, data) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildUpdate(this.resolveTableName(), data, where);
+		const result = this.driver.run(sql, params);
+		return {
+			matchedCount: result.changes,
+			modifiedCount: result.changes
+		};
+	}
+	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;
+		}
+	}
+	async replaceMany(filter, data) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildUpdate(this.resolveTableName(), data, where);
+		const result = this.driver.run(sql, params);
+		return {
+			matchedCount: result.changes,
+			modifiedCount: result.changes
+		};
+	}
+	async deleteOne(filter) {
+		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);
+		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);
+		return { deletedCount: result.changes };
+	}
+	async ensureTable() {
+		const sql = buildCreateTable(this.resolveTableName(), this._table.fieldDescriptors);
+		this.driver.exec(sql);
+	}
+	async syncIndexes() {
+		const tableName = this.resolveTableName();
+		const columnMap = this._table.columnMap;
+		await this.syncIndexesWithDiff({
+			listExisting: async () => this.driver.all(`PRAGMA index_list("${esc(tableName)}")`).filter((i) => !i.name.startsWith("sqlite_")),
+			createIndex: async (index) => {
+				const unique = index.type === "unique" ? "UNIQUE " : "";
+				const cols = index.fields.map((f) => {
+					const physical = columnMap.get(f.name) ?? f.name;
+					return `"${esc(physical)}" ${f.sort === "desc" ? "DESC" : "ASC"}`;
+				}).join(", ");
+				this.driver.exec(`CREATE ${unique}INDEX IF NOT EXISTS "${esc(index.key)}" ON "${esc(tableName)}" (${cols})`);
+			},
+			dropIndex: async (name) => {
+				this.driver.exec(`DROP INDEX IF EXISTS "${esc(name)}"`);
+			},
+			shouldSkipType: (type) => type === "fulltext"
+		});
+	}
+	constructor(driver) {
+		super(), _define_property$1(this, "driver", void 0), this.driver = driver;
+	}
+};
+function esc(name) {
+	return name.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;
+}
+
+//#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;
+}
+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

package/dist/index.d.ts

@@ -0,0 +1,144 @@
+import { TAtscriptAnnotatedType } from '@atscript/typescript/utils';
+import { BaseDbAdapter, TDbInsertResult, TDbInsertManyResult, TDbFilter, TDbFindOptions, TDbUpdateResult, TDbDeleteResult } from '@atscript/utils-db';
+import * as better_sqlite3 from 'better-sqlite3';
+
+/**
+ * Result of a SQL statement that modifies data (INSERT, UPDATE, DELETE).
+ */
+interface TSqliteRunResult {
+    /** Number of rows changed by the statement. */
+    changes: number;
+    /** Rowid of the last inserted row (for INSERT statements). */
+    lastInsertRowid: number | bigint;
+}
+/**
+ * Minimal driver interface for SQLite engines.
+ *
+ * Intentionally synchronous — SQLite is an embedded engine with no network I/O.
+ * Both `better-sqlite3` and `node:sqlite` (DatabaseSync) are synchronous.
+ * The {@link SqliteAdapter} wraps these calls in promises for the async
+ * {@link BaseDbAdapter} contract.
+ *
+ * For async drivers (e.g., `sql.js`), create a synchronous wrapper
+ * or implement a custom adapter.
+ */
+interface TSqliteDriver {
+    /**
+     * Execute a SQL statement that doesn't return rows.
+     * Used for INSERT, UPDATE, DELETE, CREATE, DROP, etc.
+     */
+    run(sql: string, params?: unknown[]): TSqliteRunResult;
+    /**
+     * Execute a query and return all matching rows.
+     */
+    all<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
+    /**
+     * Execute a query and return the first matching row, or null.
+     */
+    get<T = Record<string, unknown>>(sql: string, params?: unknown[]): T | null;
+    /**
+     * Execute raw SQL without returning results.
+     * Used for multi-statement strings like PRAGMA or BEGIN/COMMIT.
+     */
+    exec(sql: string): void;
+    /**
+     * Close the database connection.
+     */
+    close(): void;
+}
+
+/**
+ * SQLite adapter for {@link AtscriptDbTable}.
+ *
+ * Accepts any {@link TSqliteDriver} implementation — the actual SQLite engine
+ * is fully swappable (better-sqlite3, node:sqlite, sql.js, etc.).
+ *
+ * Usage:
+ * ```typescript
+ * import { BetterSqlite3Driver } from '@atscript/db-sqlite'
+ *
+ * const driver = new BetterSqlite3Driver(':memory:')
+ * const adapter = new SqliteAdapter(driver)
+ * const users = new AtscriptDbTable(UsersType, adapter)
+ * ```
+ */
+declare class SqliteAdapter extends BaseDbAdapter {
+    protected readonly driver: TSqliteDriver;
+    constructor(driver: TSqliteDriver);
+    /** SQLite does not use schemas — override to always exclude schema. */
+    resolveTableName(): string;
+    prepareId(id: unknown, _fieldType: TAtscriptAnnotatedType): unknown;
+    insertOne(data: Record<string, unknown>): Promise<TDbInsertResult>;
+    insertMany(data: Array<Record<string, unknown>>): Promise<TDbInsertManyResult>;
+    findOne(filter: TDbFilter, options?: TDbFindOptions): Promise<Record<string, unknown> | null>;
+    findMany(filter: TDbFilter, options?: TDbFindOptions): Promise<Array<Record<string, unknown>>>;
+    count(filter: TDbFilter): Promise<number>;
+    updateOne(filter: TDbFilter, data: Record<string, unknown>): Promise<TDbUpdateResult>;
+    updateMany(filter: TDbFilter, data: Record<string, unknown>): Promise<TDbUpdateResult>;
+    replaceOne(filter: TDbFilter, data: Record<string, unknown>): Promise<TDbUpdateResult>;
+    replaceMany(filter: TDbFilter, data: Record<string, unknown>): Promise<TDbUpdateResult>;
+    deleteOne(filter: TDbFilter): Promise<TDbDeleteResult>;
+    deleteMany(filter: TDbFilter): Promise<TDbDeleteResult>;
+    ensureTable(): Promise<void>;
+    syncIndexes(): Promise<void>;
+}
+
+/**
+ * {@link TSqliteDriver} implementation backed by `better-sqlite3`.
+ *
+ * Accepts either a file path (opens a new database) or a pre-created
+ * `Database` instance from `better-sqlite3`.
+ *
+ * ```typescript
+ * import { BetterSqlite3Driver } from '@atscript/db-sqlite'
+ *
+ * // In-memory database
+ * const driver = new BetterSqlite3Driver(':memory:')
+ *
+ * // File-based database
+ * const driver = new BetterSqlite3Driver('./my-data.db')
+ *
+ * // Pre-created instance
+ * import Database from 'better-sqlite3'
+ * const db = new Database(':memory:', { verbose: console.log })
+ * const driver = new BetterSqlite3Driver(db)
+ * ```
+ *
+ * Requires `better-sqlite3` to be installed:
+ * ```bash
+ * pnpm add better-sqlite3
+ * ```
+ */
+declare class BetterSqlite3Driver implements TSqliteDriver {
+    private db;
+    constructor(pathOrDb: string | better_sqlite3.Database, options?: Record<string, unknown>);
+    run(sql: string, params?: unknown[]): TSqliteRunResult;
+    all<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
+    get<T = Record<string, unknown>>(sql: string, params?: unknown[]): T | null;
+    exec(sql: string): void;
+    close(): void;
+}
+
+interface TSqlFragment {
+    sql: string;
+    params: unknown[];
+}
+/**
+ * Translates a MongoDB-style filter object into a SQL WHERE clause
+ * with parameterized values.
+ *
+ * Supports:
+ * - Equality: `{ field: value }`
+ * - Comparison: `$gt`, `$gte`, `$lt`, `$lte`, `$ne`
+ * - Set: `$in`, `$nin`
+ * - Existence: `$exists`
+ * - Pattern: `$regex` (converted to LIKE)
+ * - Logical: `$and`, `$or`, `$not`
+ *
+ * @returns `{ sql, params }` — the WHERE clause (without "WHERE") and bound params.
+ *          Returns `{ sql: '1=1', params: [] }` for empty filters.
+ */
+declare function buildWhere(filter: TDbFilter): TSqlFragment;
+
+export { BetterSqlite3Driver, SqliteAdapter, buildWhere };
+export type { TSqlFragment, TSqliteDriver, TSqliteRunResult };

package/dist/index.mjs

@@ -0,0 +1,459 @@
+import { BaseDbAdapter } from "@atscript/utils-db";
+
+//#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/filter-builder.ts
+function buildWhere(filter) {
+	if (!filter || Object.keys(filter).length === 0) return {
+		sql: "1=1",
+		params: []
+	};
+	const parts = [];
+	const params = [];
+	for (const [key, value] of Object.entries(filter)) if (key === "$and") {
+		const sub = value.map((f) => buildWhere(f));
+		parts.push(`(${sub.map((s) => s.sql).join(" AND ")})`);
+		for (const s of sub) params.push(...s.params);
+	} else if (key === "$or") {
+		const sub = value.map((f) => buildWhere(f));
+		parts.push(`(${sub.map((s) => s.sql).join(" OR ")})`);
+		for (const s of sub) params.push(...s.params);
+	} else if (key === "$not") {
+		const sub = buildWhere(value);
+		parts.push(`NOT (${sub.sql})`);
+		params.push(...sub.params);
+	} else if (typeof value === "object" && value !== null && !Array.isArray(value)) for (const [op, opVal] of Object.entries(value)) {
+		const fragment = buildOperator(key, op, opVal);
+		parts.push(fragment.sql);
+		params.push(...fragment.params);
+	}
+else if (value === null) parts.push(`"${escapeIdent(key)}" IS NULL`);
+else {
+		parts.push(`"${escapeIdent(key)}" = ?`);
+		params.push(value);
+	}
+	return {
+		sql: parts.join(" AND "),
+		params
+	};
+}
+function buildOperator(field, op, value) {
+	const col = `"${escapeIdent(field)}"`;
+	switch (op) {
+		case "$gt": return {
+			sql: `${col} > ?`,
+			params: [value]
+		};
+		case "$gte": return {
+			sql: `${col} >= ?`,
+			params: [value]
+		};
+		case "$lt": return {
+			sql: `${col} < ?`,
+			params: [value]
+		};
+		case "$lte": return {
+			sql: `${col} <= ?`,
+			params: [value]
+		};
+		case "$ne": {
+			if (value === null) return {
+				sql: `${col} IS NOT NULL`,
+				params: []
+			};
+			return {
+				sql: `${col} != ?`,
+				params: [value]
+			};
+		}
+		case "$in": {
+			const arr = value;
+			if (arr.length === 0) return {
+				sql: "0=1",
+				params: []
+			};
+			const placeholders = arr.map(() => "?").join(", ");
+			return {
+				sql: `${col} IN (${placeholders})`,
+				params: [...arr]
+			};
+		}
+		case "$nin": {
+			const arr = value;
+			if (arr.length === 0) return {
+				sql: "1=1",
+				params: []
+			};
+			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(String(value));
+			return {
+				sql: `${col} LIKE ?`,
+				params: [pattern]
+			};
+		}
+		default: throw new Error(`Unsupported filter operator: ${op}`);
+	}
+}
+/**
+* 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}%`;
+}
+/**
+* Escapes a SQL identifier to prevent injection.
+* Doubles any embedded double-quotes.
+*/ function escapeIdent(name) {
+	return name.replace(/"/g, "\"\"");
+}
+
+//#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, options) {
+	const cols = buildProjection(options?.projection);
+	let sql = `SELECT ${cols} FROM "${esc$1(table)}" WHERE ${where.sql}`;
+	const params = [...where.params];
+	if (options?.sort) {
+		const orderParts = [];
+		for (const [col, dir] of Object.entries(options.sort)) orderParts.push(`"${esc$1(col)}" ${dir === -1 ? "DESC" : "ASC"}`);
+		if (orderParts.length > 0) sql += ` ORDER BY ${orderParts.join(", ")}`;
+	}
+	if (options?.limit !== undefined) {
+		sql += ` LIMIT ?`;
+		params.push(options.limit);
+	}
+	if (options?.skip !== undefined) {
+		if (options.limit === undefined) sql += ` LIMIT -1`;
+		sql += ` OFFSET ?`;
+		params.push(options.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) {
+	const colDefs = [];
+	const primaryKeys = fields.filter((f) => f.isPrimaryKey);
+	for (const field of fields) {
+		if (field.ignored) continue;
+		const sqlType = 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})`);
+	}
+	return `CREATE TABLE IF NOT EXISTS "${esc$1(table)}" (${colDefs.join(", ")})`;
+}
+function sqliteTypeFromDesignType(designType) {
+	switch (designType) {
+		case "number":
+		case "integer": return "REAL";
+		case "boolean": return "INTEGER";
+		case "string": return "TEXT";
+		default: return "TEXT";
+	}
+}
+function buildProjection(projection) {
+	if (!projection) return "*";
+	if (Array.isArray(projection)) {
+		if (projection.length === 0) return "*";
+		return projection.map((k) => `"${esc$1(k)}"`).join(", ");
+	}
+	const entries = Object.entries(projection);
+	if (entries.length === 0) return "*";
+	const firstVal = entries[0][1];
+	if (firstVal === 1) return entries.filter(([_, v]) => v === 1).map(([k]) => `"${esc$1(k)}"`).join(", ");
+	return "*";
+}
+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) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var SqliteAdapter = class extends BaseDbAdapter {
+	/** SQLite does not use schemas — override to always exclude schema. */ resolveTableName() {
+		return super.resolveTableName(false);
+	}
+	prepareId(id, _fieldType) {
+		return id;
+	}
+	async insertOne(data) {
+		const { sql, params } = buildInsert(this.resolveTableName(), data);
+		const result = this.driver.run(sql, params);
+		return { insertedId: result.lastInsertRowid };
+	}
+	async insertMany(data) {
+		const ids = [];
+		this.driver.exec("BEGIN");
+		try {
+			for (const row of data) {
+				const { sql, params } = buildInsert(this.resolveTableName(), row);
+				const result = 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
+		};
+	}
+	async findOne(filter, options) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildSelect(this.resolveTableName(), where, {
+			...options,
+			limit: 1
+		});
+		return this.driver.get(sql, params);
+	}
+	async findMany(filter, options) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildSelect(this.resolveTableName(), where, options);
+		return this.driver.all(sql, params);
+	}
+	async count(filter) {
+		const where = buildWhere(filter);
+		const tableName = this.resolveTableName();
+		const sql = `SELECT COUNT(*) as cnt FROM "${esc(tableName)}" WHERE ${where.sql}`;
+		const row = this.driver.get(sql, where.params);
+		return row?.cnt ?? 0;
+	}
+	async updateOne(filter, data) {
+		const where = buildWhere(filter);
+		const tableName = this.resolveTableName();
+		const setClauses = [];
+		const setParams = [];
+		for (const [key, value] of Object.entries(data)) {
+			setClauses.push(`"${esc(key)}" = ?`);
+			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]);
+		return {
+			matchedCount: result.changes,
+			modifiedCount: result.changes
+		};
+	}
+	async updateMany(filter, data) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildUpdate(this.resolveTableName(), data, where);
+		const result = this.driver.run(sql, params);
+		return {
+			matchedCount: result.changes,
+			modifiedCount: result.changes
+		};
+	}
+	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;
+		}
+	}
+	async replaceMany(filter, data) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildUpdate(this.resolveTableName(), data, where);
+		const result = this.driver.run(sql, params);
+		return {
+			matchedCount: result.changes,
+			modifiedCount: result.changes
+		};
+	}
+	async deleteOne(filter) {
+		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);
+		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);
+		return { deletedCount: result.changes };
+	}
+	async ensureTable() {
+		const sql = buildCreateTable(this.resolveTableName(), this._table.fieldDescriptors);
+		this.driver.exec(sql);
+	}
+	async syncIndexes() {
+		const tableName = this.resolveTableName();
+		const columnMap = this._table.columnMap;
+		await this.syncIndexesWithDiff({
+			listExisting: async () => this.driver.all(`PRAGMA index_list("${esc(tableName)}")`).filter((i) => !i.name.startsWith("sqlite_")),
+			createIndex: async (index) => {
+				const unique = index.type === "unique" ? "UNIQUE " : "";
+				const cols = index.fields.map((f) => {
+					const physical = columnMap.get(f.name) ?? f.name;
+					return `"${esc(physical)}" ${f.sort === "desc" ? "DESC" : "ASC"}`;
+				}).join(", ");
+				this.driver.exec(`CREATE ${unique}INDEX IF NOT EXISTS "${esc(index.key)}" ON "${esc(tableName)}" (${cols})`);
+			},
+			dropIndex: async (name) => {
+				this.driver.exec(`DROP INDEX IF EXISTS "${esc(name)}"`);
+			},
+			shouldSkipType: (type) => type === "fulltext"
+		});
+	}
+	constructor(driver) {
+		super(), _define_property$1(this, "driver", void 0), this.driver = driver;
+	}
+};
+function esc(name) {
+	return name.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;
+}
+
+//#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;
+}
+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
+export { BetterSqlite3Driver, SqliteAdapter, buildWhere };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@atscript/db-sqlite",
+  "version": "0.1.28",
+  "description": "SQLite adapter for @atscript/utils-db with swappable driver support.",
+  "keywords": [
+    "atscript",
+    "database",
+    "sqlite"
+  ],
+  "homepage": "https://github.com/moostjs/atscript/tree/main/packages/db-sqlite#readme",
+  "bugs": {
+    "url": "https://github.com/moostjs/atscript/issues"
+  },
+  "license": "ISC",
+  "author": "Artem Maltsev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/atscript.git",
+    "directory": "packages/db-sqlite"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "better-sqlite3": "^12.6.2",
+    "@types/better-sqlite3": "^7.6.13",
+    "vitest": "3.2.4"
+  },
+  "peerDependencies": {
+    "better-sqlite3": ">=11.0.0",
+    "@atscript/core": "^0.1.28",
+    "@atscript/utils-db": "^0.1.28",
+    "@atscript/typescript": "^0.1.28"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "pub": "pnpm publish --access public",
+    "test": "vitest"
+  }
+}