@atscript/db-sqlite 0.1.39 → 0.1.41

package/dist/index.mjs

@@ -1,19 +1,39 @@
-import { AtscriptDbView, BaseDbAdapter, DbError, DbSpace } from "@atscript/db";
 import { createRequire } from "node:module";
+import { AtscriptDbView, BaseDbAdapter, DbError, DbSpace } from "@atscript/db";
 import { buildAggregateCount, buildAggregateSelect, buildCreateView, buildDelete, buildInsert, buildSelect, buildUpdate, buildWhere as buildWhere$1, defaultValueForType, defaultValueToSqlLiteral, refActionToSql, toSqlValue } from "@atscript/db-sql-tools";
-
-//#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;
-}
+//#region src/better-sqlite3-driver.ts
+/**
+* {@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
+* ```
+*/
 var BetterSqlite3Driver = class {
+	db;
+	constructor(pathOrDb, options) {
+		if (typeof pathOrDb === "string") this.db = new (createRequire(import.meta.url)("better-sqlite3"))(pathOrDb, options);
+		else this.db = pathOrDb;
+	}
 	run(sql, params) {
 		const stmt = this.db.prepare(sql);
 		const result = params ? stmt.run(...params) : stmt.run();
@@ -36,18 +56,9 @@ var BetterSqlite3Driver = class {
 	close() {
 		this.db.close();
 	}
-	constructor(pathOrDb, options) {
-		_define_property$1(this, "db", void 0);
-		if (typeof pathOrDb === "string") {
-			const req = createRequire(import.meta.url);
-			const Database = req("better-sqlite3");
-			this.db = new Database(pathOrDb, options);
-		} else this.db = pathOrDb;
-	}
 };
-
 //#endregion
-//#region packages/db-sqlite/src/sql-builder.ts
+//#region src/sql-builder.ts
 function esc(name) {
 	return name.replace(/"/g, "\"\"");
 }
@@ -57,7 +68,8 @@ function esc(name) {
 * - `abc$` → `%abc`
 * - `^abc$` → `abc`
 * - `abc` → `%abc%`
-*/ function regexToLike(pattern) {
+*/
+function regexToLike(pattern) {
 	const hasStart = pattern.startsWith("^");
 	const hasEnd = pattern.endsWith("$");
 	let core = pattern;
@@ -80,7 +92,7 @@ const sqliteDialect = {
 	unlimitedLimit: "-1",
 	toValue: toSqlValue,
 	toParam(value) {
-		if (value === undefined) return null;
+		if (value === void 0) return null;
 		return typeof value === "boolean" ? value ? 1 : 0 : value;
 	},
 	regex(quotedCol, value) {
@@ -92,27 +104,60 @@ const sqliteDialect = {
 	},
 	createViewPrefix: "CREATE VIEW IF NOT EXISTS"
 };
+/**
+* Builds an INSERT statement.
+*
+* @param table - Table name.
+* @param data - Column→value map.
+* @returns `{ sql, params }` ready for `driver.run()`.
+*/
 function buildInsert$1(table, data) {
 	return buildInsert(sqliteDialect, table, data);
 }
+/**
+* Builds a SELECT statement with optional sort, limit, offset, projection.
+*/
 function buildSelect$1(table, where, controls) {
 	return buildSelect(sqliteDialect, table, where, controls);
 }
-function buildUpdate$1(table, data, where) {
-	return buildUpdate(sqliteDialect, table, data, where);
+/**
+* Builds an UPDATE ... SET ... WHERE statement.
+*/
+function buildUpdate$1(table, data, where, ops) {
+	return buildUpdate(sqliteDialect, table, data, where, void 0, ops);
 }
+/**
+* Builds a DELETE ... WHERE statement.
+*/
 function buildDelete$1(table, where) {
 	return buildDelete(sqliteDialect, table, where);
 }
+/**
+* Builds a CREATE VIEW IF NOT EXISTS statement from a view plan and column mappings.
+*
+* @param viewName - The view name.
+* @param plan - Resolved view plan (entry table, joins, filter).
+* @param columns - Column mappings (view column → source table.column).
+* @param resolveFieldRef - Resolves a query field ref to `"table"."column"` SQL.
+*/
 function buildCreateView$1(viewName, plan, columns, resolveFieldRef) {
 	return buildCreateView(sqliteDialect, viewName, plan, columns, resolveFieldRef);
 }
+/**
+* Builds a SELECT ... GROUP BY statement with aggregate functions.
+*/
 function buildAggregateSelect$1(table, where, controls) {
 	return buildAggregateSelect(sqliteDialect, table, where, controls);
 }
+/**
+* Builds a COUNT query for the number of distinct groups.
+*/
 function buildAggregateCount$1(table, where, controls) {
 	return buildAggregateCount(sqliteDialect, table, where, controls);
 }
+/**
+* Maps Atscript design types to SQLite storage types.
+*/
 function sqliteTypeFromDesignType(designType) {
 	switch (designType) {
 		case "number":
@@ -123,6 +168,10 @@ function sqliteTypeFromDesignType(designType) {
 		default: return "TEXT";
 	}
 }
+/**
+* Builds a CREATE TABLE IF NOT EXISTS statement from field descriptors.
+* Uses pre-computed {@link TDbFieldMeta} — no raw type introspection needed.
+*/
 function buildCreateTable(table, fields, foreignKeys) {
 	const colDefs = [];
 	const primaryKeys = fields.filter((f) => f.isPrimaryKey);
@@ -153,12 +202,21 @@ function buildCreateTable(table, fields, foreignKeys) {
 	}
 	return `CREATE TABLE IF NOT EXISTS "${esc(table)}" (${colDefs.join(", ")})`;
 }
-
 //#endregion
-//#region packages/db-sqlite/src/filter-builder.ts
+//#region src/filter-builder.ts
+/**
+* Translates a uniqu filter expression into a parameterized SQL WHERE clause.
+*
+* @returns `{ sql, params }` — the WHERE clause (without "WHERE") and bound params.
+*          Returns `{ sql: '1=1', params: [] }` for empty/null filters.
+*/
 function buildWhere(filter) {
 	return buildWhere$1(sqliteDialect, filter);
 }
+/**
+* Like {@link buildWhere} but prefixes all column references with a table alias.
+* Produces `alias."col"` instead of `"col"` — needed for JOINed queries (e.g. FTS5 search).
+*/
 function buildPrefixedWhere(alias, filter) {
 	return buildWhere$1({
 		...sqliteDialect,
@@ -167,27 +225,35 @@ function buildPrefixedWhere(alias, filter) {
 		}
 	}, filter);
 }
-
 //#endregion
-//#region packages/db-sqlite/src/sqlite-adapter.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 src/sqlite-adapter.ts
+/**
+* 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)
+* ```
+*/
 var SqliteAdapter = class extends BaseDbAdapter {
 	supportsNativeValueDefaults() {
 		return true;
 	}
+	constructor(driver) {
+		super();
+		this.driver = driver;
+		this.driver.exec("PRAGMA foreign_keys = ON");
+	}
 	async _beginTransaction() {
 		this._log("BEGIN");
 		this.driver.exec("BEGIN");
-		return undefined;
 	}
 	async _commitTransaction() {
 		this._log("COMMIT");
@@ -197,10 +263,12 @@ var SqliteAdapter = class extends BaseDbAdapter {
 		this._log("ROLLBACK");
 		this.driver.exec("ROLLBACK");
 	}
-	/** SQLite does not use schemas — override to always exclude schema. */ resolveTableName() {
+	/** 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() {
+	/** SQLite enforces FK constraints natively via PRAGMA foreign_keys. */
+	supportsNativeForeignKeys() {
 		return true;
 	}
 	prepareId(id, _fieldType) {
@@ -209,7 +277,8 @@ var SqliteAdapter = class extends BaseDbAdapter {
 	/**
 	* Wraps a write operation to catch native SQLite constraint errors
 	* and rethrow as structured `DbError`.
-	*/ _wrapConstraintError(fn) {
+	*/
+	_wrapConstraintError(fn) {
 		try {
 			return fn();
 		} catch (error) {
@@ -270,46 +339,39 @@ var SqliteAdapter = class extends BaseDbAdapter {
 	}
 	async count(query) {
 		const where = buildWhere(query.filter);
-		const tableName = this.resolveTableName();
-		const sql = `SELECT COUNT(*) as cnt FROM "${esc(tableName)}" WHERE ${where.sql}`;
+		const sql = `SELECT COUNT(*) as cnt FROM "${esc(this.resolveTableName())}" WHERE ${where.sql}`;
 		this._log(sql, where.params);
-		const row = this.driver.get(sql, where.params);
-		return row?.cnt ?? 0;
+		return this.driver.get(sql, where.params)?.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 } = buildAggregateCount$1(tableName, where, query.controls);
+			this._log(sql, params);
+			return [{ count: this.driver.get(sql, params)?.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) {
+	async updateOne(filter, data, ops) {
 		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(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];
-		this._log(sql, allParams);
-		const result = this._wrapConstraintError(() => this.driver.run(sql, allParams));
+		const { sql, params } = buildUpdate$1(tableName, data, {
+			sql: `rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`,
+			params: where.params
+		}, ops);
+		this._log(sql, params);
+		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
 			matchedCount: result.changes,
 			modifiedCount: result.changes
 		};
 	}
-	async updateMany(filter, data) {
+	async updateMany(filter, data, ops) {
 		const where = buildWhere(filter);
-		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where);
+		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where, ops);
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
@@ -320,11 +382,10 @@ var SqliteAdapter = class extends BaseDbAdapter {
 	async replaceOne(filter, data) {
 		const where = buildWhere(filter);
 		const tableName = this.resolveTableName();
-		const limitedWhere = {
+		const { sql, params } = buildUpdate$1(tableName, data, {
 			sql: `rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`,
 			params: where.params
-		};
-		const { sql, params } = buildUpdate$1(tableName, data, limitedWhere);
+		});
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
@@ -347,15 +408,13 @@ var SqliteAdapter = class extends BaseDbAdapter {
 		const tableName = this.resolveTableName();
 		const sql = `DELETE FROM "${esc(tableName)}" WHERE rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`;
 		this._log(sql, where.params);
-		const result = this._wrapConstraintError(() => this.driver.run(sql, where.params));
-		return { deletedCount: result.changes };
+		return { deletedCount: this._wrapConstraintError(() => this.driver.run(sql, where.params)).changes };
 	}
 	async deleteMany(filter) {
 		const where = buildWhere(filter);
 		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 };
+		return { deletedCount: this._wrapConstraintError(() => this.driver.run(sql, params)).changes };
 	}
 	async ensureTable() {
 		if (this._table instanceof AtscriptDbView) return this.ensureView();
@@ -364,10 +423,12 @@ var SqliteAdapter = class extends BaseDbAdapter {
 		this.driver.exec(sql);
 		this._seedIncrementStart();
 	}
+	_incrementSeeded = false;
 	/**
 	* 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() {
+	*/
+	_seedIncrementStart() {
 		if (this._incrementSeeded) return;
 		this._incrementSeeded = true;
 		const tableName = this.resolveTableName();
@@ -403,7 +464,7 @@ var SqliteAdapter = class extends BaseDbAdapter {
 			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 ${defaultValueToSqlLiteral(field.designType, field.defaultValue.value)}`;
-else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValueForType(field.designType)}`;
+			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);
@@ -491,8 +552,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 		return sqliteTypeFromDesignType(field.designType);
 	}
 	async getExistingColumnsForTable(tableName) {
-		const rows = this.driver.all(`PRAGMA table_info("${esc(tableName)}")`);
-		return rows.map((r) => ({
+		return this.driver.all(`PRAGMA table_info("${esc(tableName)}")`).map((r) => ({
 			name: r.name,
 			type: r.type,
 			notnull: r.notnull === 1,
@@ -540,12 +600,12 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 			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) {
+		if (controls.$limit !== void 0) {
 			sql += ` LIMIT ?`;
 			params.push(controls.$limit);
 		}
-		if (controls.$skip !== undefined) {
-			if (controls.$limit === undefined) sql += ` LIMIT -1`;
+		if (controls.$skip !== void 0) {
+			if (controls.$limit === void 0) sql += ` LIMIT -1`;
 			sql += ` OFFSET ?`;
 			params.push(controls.$skip);
 		}
@@ -561,21 +621,23 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 		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
+			count: this.driver.get(countSql, base.params)?.cnt ?? 0
 		};
 	}
-	/** Builds FTS table name from index name: `<table>__fts__<indexName>`. */ _ftsTableName(indexName) {
+	/** Builds FTS table name from index name: `<table>__fts__<indexName>`. */
+	_ftsTableName(indexName) {
 		return `${this.resolveTableName()}__fts__${indexName}`;
 	}
-	/** Returns fulltext indexes from table metadata. */ _getFulltextIndexes() {
+	/** 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) {
+	/** 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) {
@@ -588,7 +650,8 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 	/**
 	* 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) {
+	*/
+	_buildFtsBase(text, filter, indexName) {
 		const ftsIndex = this._resolveFtsIndex(indexName);
 		const ftsTable = this._ftsTableName(ftsIndex.name);
 		const tableName = this.resolveTableName();
@@ -608,7 +671,8 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 	}
 	/**
 	* Creates/drops FTS5 virtual tables and sync triggers to match desired fulltext indexes.
-	*/ _syncFtsIndexes(tableName) {
+	*/
+	_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);
@@ -619,9 +683,9 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 			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(", ");
+	/** Creates an FTS5 virtual table with sync triggers and rebuilds the index. */
+	_createFtsTable(tableName, ftsTable, index) {
+		const fieldList = index.fields.map((f) => `"${esc(f.name)}"`).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);
@@ -641,7 +705,8 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 		this._log(rebuildSql);
 		this.driver.exec(rebuildSql);
 	}
-	/** Drops an FTS5 virtual table and its sync triggers. */ _dropFtsTable(ftsTable) {
+	/** Drops an FTS5 virtual table and its sync triggers. */
+	_dropFtsTable(ftsTable) {
 		for (const suffix of [
 			"__ai",
 			"__ad",
@@ -651,28 +716,24 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 		this._log(sql);
 		this.driver.exec(sql);
 	}
-	/** Drops all FTS virtual tables and triggers for a content table. */ _dropAllFtsTables(tableName) {
+	/** 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), _define_property(this, "_incrementSeeded", void 0), this.driver = driver, this._incrementSeeded = false;
-		this.driver.exec("PRAGMA foreign_keys = ON");
-	}
 };
 /** 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;
+*  PRAGMA returns `'active'` (SQL-quoted), we store `active` (raw). */
+function normalizeSqliteDefault(value) {
+	if (value === null) return;
 	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
 	return value;
 }
-
 //#endregion
-//#region packages/db-sqlite/src/index.ts
+//#region src/index.ts
 function createAdapter(connection, options) {
 	const driver = new BetterSqlite3Driver(connection, options);
 	return new DbSpace(() => new SqliteAdapter(driver));
 }
-
 //#endregion
-export { BetterSqlite3Driver, SqliteAdapter, buildWhere, createAdapter };
+export { BetterSqlite3Driver, SqliteAdapter, buildWhere, createAdapter };

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@atscript/db-sqlite",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "SQLite adapter for @atscript/db with swappable driver support.",
   "keywords": [
     "atscript",
     "database",
     "sqlite"
   ],
-  "homepage": "https://github.com/moostjs/atscript/tree/main/packages/db-sqlite#readme",
+  "homepage": "https://github.com/moostjs/atscript-db/tree/main/packages/db-sqlite#readme",
   "bugs": {
-    "url": "https://github.com/moostjs/atscript/issues"
+    "url": "https://github.com/moostjs/atscript-db/issues"
   },
   "license": "MIT",
   "author": "Artem Maltsev",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/moostjs/atscript.git",
+    "url": "git+https://github.com/moostjs/atscript-db.git",
     "directory": "packages/db-sqlite"
   },
   "files": [
@@ -23,27 +23,33 @@
   ],
   "type": "module",
   "main": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "types": "dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
     },
     "./package.json": "./package.json"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "devDependencies": {
-    "better-sqlite3": "^12.6.2",
+    "@atscript/core": "^0.1.39",
+    "@atscript/typescript": "^0.1.39",
     "@types/better-sqlite3": "^7.6.13",
-    "vitest": "3.2.4"
+    "@uniqu/core": "^0.1.2",
+    "better-sqlite3": "^12.6.2",
+    "unplugin-atscript": "^0.1.39"
   },
   "peerDependencies": {
+    "@atscript/core": "^0.1.39",
+    "@atscript/typescript": "^0.1.39",
     "@uniqu/core": "^0.1.2",
     "better-sqlite3": ">=11.0.0",
-    "@atscript/db-sql-tools": "^0.1.39",
-    "@atscript/core": "^0.1.39",
-    "@atscript/db": "^0.1.39",
-    "@atscript/typescript": "^0.1.39"
+    "@atscript/db-sql-tools": "^0.1.41",
+    "@atscript/db": "^0.1.41"
   },
   "peerDependenciesMeta": {
     "better-sqlite3": {
@@ -51,7 +57,10 @@
     }
   },
   "scripts": {
-    "pub": "pnpm publish --access public",
-    "test": "vitest"
+    "postinstall": "asc -f dts",
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
   }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-present Artem Maltsev
-
-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.