@mitsuru793/vitest-sqlite 0.0.0-stage → 0.0.1-alpha.1

package/README.md

@@ -1,3 +1,140 @@
-# Temporary Holding Version
+# vitest-sqlite
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Vitest matchers and adapters for testing SQLite databases, with `better-sqlite3` support.
+
+## Installation
+
+Install the library and Vitest:
+
+```sh
+npm install --save-dev @mitsuru793/vitest-sqlite vitest
+```
+
+The `better-sqlite3` package is installed as a dependency of this library.
+
+## Setup with Vitest
+
+Import the Vitest integration once from a setup file:
+
+```ts
+// vitest.setup.ts
+import "@mitsuru793/vitest-sqlite/vitest";
+```
+
+Register that file in your Vitest configuration:
+
+```ts
+// vitest.config.ts
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    setupFiles: ["./vitest.setup.ts"],
+  },
+});
+```
+
+The integration registers the matchers and adds their TypeScript types.
+
+## Setup with Vite+
+
+When running tests with Vite+, import the Vite+ integration instead:
+
+```ts
+// test/setup.ts
+import "@mitsuru793/vitest-sqlite/vite-plus";
+```
+
+Add the setup file to the `test` configuration in `vite.config.ts`:
+
+```ts
+import { defineConfig } from "vite-plus";
+
+export default defineConfig({
+  test: {
+    setupFiles: ["./test/setup.ts"],
+  },
+});
+```
+
+## Usage
+
+Create a `better-sqlite3` database, wrap it in an adapter, and use `table()` to
+create a reference for table-specific matchers:
+
+```ts
+import Database from "better-sqlite3";
+import { expect, test } from "vitest";
+import { BetterSqlite3Adapter, table } from "@mitsuru793/vitest-sqlite/better-sqlite3";
+
+test("checks database tables and rows", () => {
+  const client = new Database(":memory:");
+  try {
+    client.exec(`
+      CREATE TABLE users (name TEXT, role TEXT);
+      INSERT INTO users VALUES ('Ada', 'admin');
+    `);
+
+    const db = BetterSqlite3Adapter.create(client);
+    const users = table(db, "users");
+
+    expect(db).toHaveTable("users");
+    expect(users).toHaveColumn("name", { type: "TEXT" });
+    expect(users).toHaveRow({ name: "Ada", role: "admin" });
+    expect(users).toHaveRowCount(1);
+    expect(users).not.toBeEmptyTable();
+  } finally {
+    client.close();
+  }
+});
+```
+
+## Matchers
+
+The matcher types are receiver-specific: table matchers are available for
+`TableRef` values created by `table()`, while `toHaveTable` is available for
+`DbAdapter` values.
+
+### `expect(db).toHaveTable(name)`
+
+checks whether a table exists.
+
+### `expect(tableRef).toHaveColumn(name, { type? })`
+
+checks for a column and, optionally, its SQLite type (`TEXT`, `INTEGER`, `REAL`, or `BLOB`).
+
+The `unique` option checks for a single-column UNIQUE constraint or a
+non-partial single-column unique index. Composite, partial, and expression
+indexes do not make an individual column unique.
+
+### `expect(tableRef).toHaveRow(where)`
+
+checks whether at least one row matches.
+
+### `expect(tableRef).toHaveRowCount(count, where?)`
+
+checks the matching row count, or the total count if `where` is omitted.
+
+### `expect(tableRef).toBeEmptyTable()`
+
+checks that the table has no rows.
+
+## `where` Option
+
+`where` can be an object of column values or a SQL condition with parameters:
+
+```ts
+expect(users).toHaveRow({ role: "admin" });
+expect(users).toHaveRow({ sql: "name = ?", params: ["Ada"] });
+```
+
+## Development
+
+Install dependencies and run the checks, tests, or package build with Vite+:
+
+```sh
+vp install
+vp check
+vp test
+vp run build
+```

package/dist/better-sqlite3.d.mts

@@ -0,0 +1,11 @@
+import { i as db_adapter_d_exports, n as table_ref_d_exports, r as Type, t as Type$1 } from "./index-DZsTinBh.mjs";
+import { Database } from "better-sqlite3";
+declare namespace adapter_d_exports {
+  export { create };
+}
+declare function create(db: Database): Type;
+//#endregion
+//#region src/sqlite-better-sqlite-3/table-ref.d.ts
+export declare function table(db: Type, name: string): Type$1;
+//#endregion
+export { adapter_d_exports as BetterSqlite3Adapter };

package/dist/better-sqlite3.mjs

@@ -0,0 +1,101 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { i as bindParse, n as buildWhere, r as quote } from "./matchers-8Jn4xSIt.mjs";
+import { type } from "arktype";
+//#region src/sqlite-better-sqlite-3/adapter/operates/table_exists.ts
+const bindTableExists = (db) => (table) => {
+	return db.prepare("SELECT 1 FROM sqlite_master WHERE type IN ('table','view') AND name = ?").get(table) !== void 0;
+};
+//#endregion
+//#region src/sqlite-better-sqlite-3/queries/get_table_foreign_keys.ts
+const ForeignKeyInfoList = type({
+	id: "number",
+	seq: "number",
+	table: "string > 0",
+	from: "string > 0",
+	to: "string > 0",
+	on_update: "string > 0",
+	on_delete: "string > 0",
+	match: "string > 0"
+}).array();
+const parse = bindParse({
+	schema: ForeignKeyInfoList,
+	name: "ForeignKeyInfoList"
+});
+const getTableForeignKeys = (db) => (table) => {
+	const rows = db.prepare(`
+        SELECT key_lists.*
+        FROM sqlite_schema schema
+        JOIN pragma_foreign_key_list(schema.name) key_lists
+        WHERE schema.type = 'table'
+          AND schema.name = ?;
+      `).all(table);
+	return parse(rows);
+};
+//#endregion
+//#region src/sqlite-better-sqlite-3/adapter/operates/get_columns.ts
+const bindGetColumns = (db) => (table) => {
+	const rows = db.prepare(`PRAGMA table_info(${quote(table)})`).all();
+	const fkInfoList = getTableForeignKeys(db)(table);
+	const uniqueInfoList = db.prepare(`
+      SELECT
+        iList.name AS index_name,
+        iList.origin,
+        iList.partial,
+        iInfo.seqno,
+        iInfo.name AS column_name
+      FROM pragma_index_list(?) AS iList
+        JOIN pragma_index_info(iList.name) AS iInfo
+      WHERE iList."unique" = 1
+        AND iList.partial = 0
+      ORDER BY iList.name, iInfo.seqno;
+    `).bind(table).all();
+	return rows.map((row) => {
+		const foreignKey = fkInfoList.find((fk) => fk.from === row.name);
+		const unique = uniqueInfoList.some((info) => info.column_name === row.name);
+		return {
+			name: row.name,
+			type: row.type,
+			notNull: row.notnull === 1,
+			primaryKey: row.pk > 0,
+			foreignKey: foreignKey ? {
+				table: foreignKey.table,
+				column: foreignKey.to
+			} : false,
+			unique
+		};
+	});
+};
+//#endregion
+//#region src/sqlite-better-sqlite-3/adapter/operates/count.ts
+const bindCount = (db) => (table, where) => {
+	const { clause, params } = buildWhere(where);
+	return db.prepare(`SELECT COUNT(*) AS c FROM ${quote(table)}${clause}`).get(...params).c;
+};
+//#endregion
+//#region src/sqlite-better-sqlite-3/adapter/operates/find_rows.ts
+const bindFindRows = (db) => (table, where) => {
+	const { clause, params } = buildWhere(where);
+	return db.prepare(`SELECT * FROM ${quote(table)}${clause}`).all(...params);
+};
+//#endregion
+//#region src/sqlite-better-sqlite-3/adapter/adapter.ts
+var adapter_exports = /* @__PURE__ */ __exportAll({ create: () => create });
+function create(db) {
+	return {
+		tableExists: bindTableExists(db),
+		getColumns: bindGetColumns(db),
+		count: bindCount(db),
+		findRows: bindFindRows(db)
+	};
+}
+//#endregion
+//#region src/sqlite-better-sqlite-3/table-ref.ts
+function table(db, name) {
+	return {
+		__dbTestingTable: true,
+		adapter: db,
+		name
+	};
+}
+//#endregion
+export { adapter_exports as BetterSqlite3Adapter, table };

package/dist/index-DZsTinBh.d.mts

@@ -0,0 +1,106 @@
+import "vitest";
+import { type } from "arktype";
+//#region src/arktype-helper/arktype-helpers.d.ts
+type Parse<T> = (value: unknown) => T;
+declare namespace column_info_d_exports {
+  export { ColumnInfo, Type$3 as Type, parse$2 as parse, schema$5 as schema };
+}
+type ColumnInfo = typeof schema$5.inferOut;
+type Type$3 = ColumnInfo;
+declare const schema$5: import("arktype/internal/variants/object.ts").ObjectType<{
+  name: string;
+  type: string;
+  notNull: boolean;
+  primaryKey: boolean;
+  foreignKey: boolean | {
+    table: string;
+    column: string;
+  };
+  unique: boolean;
+}, {}>;
+declare const parse$2: Parse<{
+  name: string;
+  type: string;
+  notNull: boolean;
+  primaryKey: boolean;
+  foreignKey: boolean | {
+    table: string;
+    column: string;
+  };
+  unique: boolean;
+}>;
+declare namespace where_d_exports {
+  export { Type$2 as Type, buildWhere, schema$4 as schema };
+}
+type Where = typeof Where.inferOut;
+/** Row filter: an object of column = value (null means IS NULL), or a raw SQL WHERE clause. */
+type Type$2 = Where;
+declare const Where: import("arktype/internal/variants/object.ts").ObjectType<{
+  [x: string]: string | number | null;
+} | {
+  sql: string;
+  params?: unknown[] | undefined;
+}, {}>;
+declare const schema$4: import("arktype/internal/variants/object.ts").ObjectType<{
+  [x: string]: string | number | null;
+} | {
+  sql: string;
+  params?: unknown[] | undefined;
+}, {}>;
+declare function buildWhere(where?: Where): {
+  clause: string;
+  params: unknown[];
+};
+//#endregion
+//#region src/sqlite/domain/row.d.ts
+type Row = typeof schema$3.inferOut;
+declare const schema$3: import("arktype/internal/variants/object.ts").ObjectType<{
+  [x: string]: string | number | null;
+}, {}>;
+declare namespace db_adapter_d_exports {
+  export { DbAdapter, Type$1 as Type, isDbAdapter, parse$1 as parse, schema$2 as schema };
+}
+type DbAdapter = typeof schema$2.inferOut;
+type Type$1 = DbAdapter;
+declare const schema$2: import("arktype/internal/variants/object.ts").ObjectType<{
+  tableExists: (table: string) => boolean;
+  getColumns: (table: string) => Type$3[];
+  count: (table: string, where?: Type$2) => number;
+  findRows: (table: string, where?: Type$2) => Row[];
+}, {}>;
+declare function isDbAdapter(value: unknown): value is Type$1;
+declare const parse$1: Parse<{
+  tableExists: (table: string) => boolean;
+  getColumns: (table: string) => Type$3[];
+  count: (table: string, where?: Type$2) => number;
+  findRows: (table: string, where?: Type$2) => Row[];
+}>;
+declare namespace table_ref_d_exports {
+  export { CreateTableRefFromDbAdapter, TableRef, Type, parse, schema$1 as schema };
+}
+/** Accepts a DbAdapter or a better-sqlite3 Database (e.g. drizzle's `db.$client`). */
+type TableRef = typeof schema$1.inferOut;
+type Type = TableRef;
+declare const schema$1: import("arktype/internal/variants/object.ts").ObjectType<{
+  __dbTestingTable: true;
+  adapter: {
+    tableExists: (table: string) => boolean;
+    getColumns: (table: string) => Type$3[];
+    count: (table: string, where?: Type$2) => number;
+    findRows: (table: string, where?: Type$2) => Row[];
+  };
+  name: string;
+}, {}>;
+declare const parse: Parse<{
+  __dbTestingTable: true;
+  adapter: {
+    tableExists: (table: string) => boolean;
+    getColumns: (table: string) => Type$3[];
+    count: (table: string, where?: Type$2) => number;
+    findRows: (table: string, where?: Type$2) => Row[];
+  };
+  name: string;
+}>;
+type CreateTableRefFromDbAdapter = (db: Type$1, name: string) => TableRef;
+//#endregion
+export { Type$2 as a, db_adapter_d_exports as i, table_ref_d_exports as n, where_d_exports as o, Type$1 as r, Type as t };

package/dist/matchers-8Jn4xSIt.mjs

@@ -0,0 +1,189 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { type } from "arktype";
+import { ErrorFactory } from "@praha/error-factory";
+//#region src/arktype-helper/errors.ts
+var SchemaParseError = class extends ErrorFactory({
+	name: "SchemaParseError",
+	message: ({ schema, value }) => `failed to parse value of ${schema}: ${JSON.stringify(value)}`,
+	fields: ErrorFactory.fields()
+}) {};
+//#endregion
+//#region src/arktype-helper/arktype-helpers.ts
+const bindParse = ({ schema, name }) => (value) => {
+	const parsed = schema(value);
+	if (parsed instanceof type.errors) throw new SchemaParseError({
+		schema: name,
+		value,
+		cause: parsed
+	});
+	return parsed;
+};
+//#endregion
+//#region src/sqlite/domain/column-info.ts
+const schema$4 = type({
+	name: "string > 0",
+	type: "string",
+	notNull: "boolean",
+	primaryKey: "boolean",
+	foreignKey: type({
+		table: "string > 0",
+		column: "string > 0"
+	}).or("boolean"),
+	unique: "boolean"
+});
+bindParse({
+	schema: schema$4,
+	name: "ColumnInfo"
+});
+//#endregion
+//#region src/sqlite/quote.ts
+const quote = (id) => `"${id.replace(/"/g, "\"\"")}"`;
+//#endregion
+//#region src/sqlite/domain/row.ts
+const RowValue = type("null | string | number");
+bindParse({
+	schema: type({ "[string]": RowValue }),
+	name: "Row"
+});
+//#endregion
+//#region src/sqlite/domain/where.ts
+const RowWhere = type({ "[string]": RowValue });
+const SqlWhere = type({
+	sql: "string",
+	"params?": "unknown[]"
+});
+const schema$2 = type(RowWhere).or(SqlWhere);
+function buildWhere(where) {
+	if (!where) return {
+		clause: "",
+		params: []
+	};
+	if (SqlWhere.allows(where)) return {
+		clause: ` WHERE (${where.sql})`,
+		params: where.params ?? []
+	};
+	const rowWhereList = Object.entries(where);
+	if (rowWhereList.length === 0) return {
+		clause: "",
+		params: []
+	};
+	const parts = [];
+	const params = [];
+	for (const [col, value] of rowWhereList) if (value === null) parts.push(`${quote(col)} IS NULL`);
+	else {
+		parts.push(`${quote(col)} = ?`);
+		params.push(typeof value === "boolean" ? Number(value) : value);
+	}
+	return {
+		clause: ` WHERE ${parts.join(" AND ")}`,
+		params
+	};
+}
+//#endregion
+//#region src/sqlite/domain/db-adapter.ts
+const schema$1 = type({
+	tableExists: type("Function").pipe(type.fn("string", ":", "boolean")).as(),
+	getColumns: type("Function").pipe(type.fn("string", ":", schema$4.array())).as(),
+	count: type("Function").pipe(type.fn("string", schema$2.optional(), ":", "number")).as(),
+	findRows: type("Function").pipe(type.fn("string", schema$2.optional(), ":", "number")).as()
+});
+const parse$1 = bindParse({
+	schema: schema$1,
+	name: "DbAdapter"
+});
+const parse = bindParse({
+	schema: type({
+		__dbTestingTable: "true",
+		adapter: schema$1,
+		name: "string"
+	}),
+	name: "TableRef"
+});
+//#endregion
+//#region src/sqlite/matchers/db-adapter/to_have_table.ts
+function toHaveTable(received, name) {
+	const pass = parse$1(received).tableExists(name);
+	return {
+		pass,
+		message: () => pass ? `expected table "${name}" not to exist` : `expected table "${name}" to exist`
+	};
+}
+//#endregion
+//#region src/sqlite/matchers/_helper/show.ts
+const show = (v) => JSON.stringify(v);
+//#endregion
+//#region src/sqlite/matchers/table-ref/to_have_column.ts
+function toHaveColumn(received, name, opts = {}) {
+	const tableRef = parse(received);
+	const actual = tableRef.adapter.getColumns(tableRef.name).find((c) => c.name === name);
+	let pass = actual !== void 0;
+	let mismatch;
+	if (actual) {
+		if (opts.type !== void 0 && actual.type !== opts.type) {
+			pass = false;
+			mismatch ??= `expected column "${tableRef.name}.${name}" to be of type ${opts.type}, but it is ${actual.type}`;
+		}
+		if (opts.notNull !== void 0 && actual.notNull !== opts.notNull) {
+			pass = false;
+			mismatch ??= `expected column "${tableRef.name}.${name}" to be ${opts.notNull ? "NOT NULL" : "nullable"}, but it is ${actual.notNull ? "NOT NULL" : "nullable"}`;
+		}
+		if (opts.foreignKey !== void 0) {
+			if (!(typeof opts.foreignKey === "boolean" ? !!actual.foreignKey === opts.foreignKey : typeof actual.foreignKey === "object" && actual.foreignKey.table === opts.foreignKey.table && actual.foreignKey.column === opts.foreignKey.column)) {
+				pass = false;
+				mismatch ??= `expected column "${tableRef.name}.${name}" to have foreign key ${show(opts.foreignKey)}, but it has ${show(actual.foreignKey)}`;
+			}
+		}
+		if (opts.unique !== void 0 && actual.unique !== opts.unique) {
+			pass = false;
+			mismatch ??= `expected column "${tableRef.name}.${name}" to be ${opts.unique ? "unique" : "not unique"}, but it is ${actual.unique ? "unique" : "not unique"}`;
+		}
+	}
+	const type = opts.type ? ` of type ${opts.type}` : "";
+	return {
+		pass,
+		message: () => pass ? `expected table "${tableRef.name}" not to have column "${name}"${type}` : actual ? mismatch ?? `expected table "${tableRef.name}" to have column "${name}"${type}` : `expected table "${tableRef.name}" to have column "${name}"${type}`
+	};
+}
+//#endregion
+//#region src/sqlite/matchers/table-ref/to_have_row.ts
+function toHaveRow(received, where) {
+	const tableRef = parse(received);
+	const pass = tableRef.adapter.count(tableRef.name, where) > 0;
+	return {
+		pass,
+		message: () => pass ? `expected table "${tableRef.name}" not to have a row matching ${show(where)}` : `expected table "${tableRef.name}" to have a row matching ${show(where)}`
+	};
+}
+//#endregion
+//#region src/sqlite/matchers/table-ref/to_have_row_count.ts
+function toHaveRowCount(received, expected, where) {
+	const tableRef = parse(received);
+	const actual = where === void 0 ? tableRef.adapter.count(tableRef.name) : tableRef.adapter.count(tableRef.name, where);
+	const pass = actual === expected;
+	return {
+		pass,
+		message: () => pass ? `expected table "${tableRef.name}" not to have ${expected} rows matching ${show(where)}` : `expected table "${tableRef.name}" to have ${expected} rows matching ${show(where)}, but it has ${actual}`
+	};
+}
+//#endregion
+//#region src/sqlite/matchers/table-ref/to_be_empty_table.ts
+function toBeEmptyTable(received) {
+	const tableRef = parse(received);
+	const actual = tableRef.adapter.count(tableRef.name);
+	const pass = actual === 0;
+	return {
+		pass,
+		message: () => pass ? `expected table "${tableRef.name}" not to be empty` : `expected table "${tableRef.name}" to be empty, but it has ${actual} rows`
+	};
+}
+//#endregion
+//#region src/sqlite/matchers/index.ts
+var matchers_exports = /* @__PURE__ */ __exportAll({
+	toBeEmptyTable: () => toBeEmptyTable,
+	toHaveColumn: () => toHaveColumn,
+	toHaveRow: () => toHaveRow,
+	toHaveRowCount: () => toHaveRowCount,
+	toHaveTable: () => toHaveTable
+});
+//#endregion
+export { bindParse as i, buildWhere as n, quote as r, matchers_exports as t };

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/vite-plus.d.mts

@@ -0,0 +1,7 @@
+import { n as TableRefMatchers, t as DbAdapterMatchers } from "./vitest-DjF_zZFj.mjs";
+import "vite-plus/test";
+//#region src/vite-plus.d.ts
+declare module "vite-plus/test" {
+  interface Matchers<R, T> extends DbAdapterMatchers<R, T>, TableRefMatchers<R, T> {}
+}
+//#endregion

package/dist/vite-plus.mjs

@@ -0,0 +1 @@
+export {};

package/dist/vitest-DjF_zZFj.d.mts

@@ -0,0 +1,33 @@
+import { a as Type$3, i as db_adapter_d_exports, n as table_ref_d_exports, o as where_d_exports, r as Type$1, t as Type$2 } from "./index-DZsTinBh.mjs";
+declare namespace sqlite_column_type_d_exports {
+  export { Type };
+}
+declare const all: readonly ["TEXT", "INTEGER", "REAL", "BLOB"];
+type Type = (typeof all)[number];
+//#endregion
+//#region src/vitest.d.ts
+interface DbAdapterMatchers<R, T> {
+  /** expect(db).toHaveTable('users') */
+  toHaveTable: T extends Type$1 ? (name: string) => R : never;
+}
+interface TableRefMatchers<R, T> {
+  /** expect(table(db, 'users')).toHaveColumn('name', { type: 'TEXT' }) */
+  toHaveColumn: T extends Type$2 ? (name: string, opts?: {
+    type?: Type;
+    notNull?: boolean;
+    foreignKey?: boolean | {
+      table: string;
+      column: string;
+    };
+    unique?: boolean;
+  }) => R : never;
+  /** expect(table(db, 'users')).toHaveRow({ role: 'admin' }) or ({ sql: 'age > ?', params: [20] }) */
+  toHaveRow: T extends Type$2 ? (where: Type$3) => R : never;
+  toHaveRowCount: T extends Type$2 ? (expected: number, where?: Type$3) => R : never;
+  toBeEmptyTable: T extends Type$2 ? () => R : never;
+}
+declare module "vitest" {
+  interface Matchers<R, T> extends DbAdapterMatchers<R, T>, TableRefMatchers<R, T> {}
+}
+//#endregion
+export { TableRefMatchers as n, DbAdapterMatchers as t };

package/dist/vitest.d.mts

@@ -0,0 +1,2 @@
+import { n as TableRefMatchers, t as DbAdapterMatchers } from "./vitest-DjF_zZFj.mjs";
+export { DbAdapterMatchers, TableRefMatchers };

package/dist/vitest.mjs

@@ -0,0 +1,6 @@
+import { t as matchers_exports } from "./matchers-8Jn4xSIt.mjs";
+import { expect } from "vitest";
+//#region src/vitest.ts
+expect.extend(matchers_exports);
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@mitsuru793/vitest-sqlite",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.1-alpha.1",
+  "description": "Vitest matchers and adapters for testing SQLite databases, with better-sqlite3 support.",
+  "homepage": "https://github.com/mitsuru793/vitest-sqlite#readme",
+  "bugs": {
+    "url": "https://github.com/mitsuru793/vitest-sqlite/issues"
+  },
+  "license": "MIT",
+  "author": "mitsuru793 <mitsuru793@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mitsuru793/vitest-sqlite.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./better-sqlite3": "./dist/better-sqlite3.mjs",
+    "./vite-plus": "./dist/vite-plus.mjs",
+    "./vitest": "./dist/vitest.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@praha/error-factory": "^1.4.1",
+    "arktype": "^2.2.8",
+    "better-sqlite3": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^26.6.5",
+    "bumpp": "^12.3.0",
+    "typescript": "^7.0.2",
+    "vite-plus": "1.1.0",
+    "vitest": "^5.0.0"
+  },
+  "peerDependencies": {
+    "vitest": "^5.0.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "12.14.0",
+      "onFail": "download"
+    }
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
 }