@ocap/indexdb-sqlite 1.29.5

package/esm/package.mjs

@@ -0,0 +1,70 @@
+//#region package.json
+var package_default = {
+	name: "@ocap/indexdb-sqlite",
+	description: "OCAP indexdb adapter that uses SQLite as backend",
+	version: "1.0.0",
+	author: "wangshijun <shijun@arcblock.io> (https://www.arcblock.io)",
+	bugs: {
+		"url": "https://github.com/ArcBlock/blockchain/issues",
+		"email": "shijun@arcblock.io"
+	},
+	publishConfig: { "access": "public" },
+	contributors: ["wangshijun <shijun@arcblock.io> (https://www.arcblock.io)"],
+	devDependencies: { "@ocap/indexdb-test": "workspace:*" },
+	homepage: "https://github.com/ArcBlock/blockchain/tree/master/indexdb/sqlite",
+	keywords: [
+		"ocap",
+		"indexdb",
+		"sqlite",
+		"kysely"
+	],
+	license: "Apache-2.0",
+	type: "module",
+	main: "./lib/index.cjs",
+	module: "./esm/index.mjs",
+	types: "./esm/index.d.mts",
+	exports: {
+		".": {
+			"types": "./esm/index.d.mts",
+			"import": "./esm/index.mjs",
+			"default": "./lib/index.cjs"
+		},
+		"./lib/*.js": {
+			"types": "./esm/*.d.mts",
+			"import": "./esm/*.mjs",
+			"default": "./lib/*.cjs"
+		},
+		"./lib/*": {
+			"types": "./esm/*.d.mts",
+			"import": "./esm/*.mjs",
+			"default": "./lib/*.cjs"
+		}
+	},
+	files: ["lib", "esm"],
+	repository: {
+		"type": "git",
+		"url": "https://github.com/ArcBlock/blockchain/tree/master/indexdb/sqlite"
+	},
+	scripts: {
+		"build": "tsdown",
+		"prebuild": "rm -rf lib esm",
+		"lint": "biome check",
+		"lint:fix": "biome check --write",
+		"test": "bun test",
+		"coverage": "npm run test -- --coverage"
+	},
+	dependencies: {
+		"@arcblock/did": "workspace:*",
+		"@ocap/indexdb": "workspace:*",
+		"@ocap/types": "workspace:*",
+		"@ocap/util": "workspace:*",
+		"debug": "^4.4.3",
+		"better-sqlite3": "^11.8.1",
+		"kysely": "^0.27.0",
+		"kysely-bun-sqlite": "^0.4.0",
+		"lodash": "^4.17.23"
+	}
+};
+
+//#endregion
+export { package_default as default };

package/esm/table/base.d.mts

@@ -0,0 +1,107 @@
+import { Database, SqliteOperationContext } from "../interfaces.mjs";
+import { Kysely, Transaction } from "kysely";
+import { BaseIndex } from "@ocap/indexdb";
+import { IIndexTable } from "@ocap/types";
+
+//#region src/table/base.d.ts
+
+/**
+ * Table schema configuration
+ */
+interface TableSchema {
+  /** Column names that contain JSON data */
+  jsonFields?: string[];
+  /** Column names that contain boolean data (stored as integer 0/1 in SQLite) */
+  booleanFields?: string[];
+  /** Column name mapping (e.g., 'from' -> 'from_' for reserved keywords) */
+  columnMapping?: Record<string, string>;
+  /** Numeric column mapping (field name -> numeric field name for sorting) */
+  numericFields?: Record<string, string>;
+  /** Known column names for this table (used to filter unknown fields) */
+  knownColumns?: string[];
+}
+/**
+ * Table configuration
+ */
+interface SqliteTableConfig {
+  name: string;
+  uniqIndex: string | string[];
+  db: Kysely<Database>;
+  schema?: TableSchema;
+}
+/**
+ * SQLite Index Table base class
+ * Extends IndexDBTable to provide SQLite-specific implementation
+ */
+declare class SqliteTable<T = unknown> extends BaseIndex<T> implements IIndexTable<T> {
+  name: string;
+  db: Kysely<Database>;
+  schema: TableSchema;
+  constructor(config: SqliteTableConfig);
+  /**
+   * Get the Kysely executor (use transaction if available)
+   */
+  protected getExecutor(context?: SqliteOperationContext): Kysely<Database> | Transaction<Database>;
+  /**
+   * Generate primary key from document
+   * Handles both simple string keys and composite keys
+   */
+  generatePrimaryKey(doc: string | Record<string, unknown>): string;
+  /**
+   * Map column name for reserved keywords
+   */
+  protected mapColumnName(name: string): string;
+  /**
+   * Reverse map column name
+   */
+  protected unmapColumnName(name: string): string;
+  /**
+   * Serialize data for database insert
+   * - Converts objects/arrays to JSON strings
+   * - Converts booleans to integers (0/1) for SQLite
+   * - Maps column names for reserved keywords
+   * - Adds numeric fields for sorting
+   * - Stores unknown fields in the 'data' column as JSON
+   */
+  protected serializeForDb(data: Record<string, unknown>): Record<string, unknown>;
+  /**
+   * Serialize data for database update
+   * Preserves unknown fields from existing document's data column
+   */
+  protected serializeForDbUpdate(updates: Record<string, unknown>, existing: Record<string, unknown>): Record<string, unknown>;
+  /**
+   * Convert a big number string to a sortable numeric string
+   * Pads with leading zeros to ensure lexicographic sorting works
+   */
+  protected toSortableNumeric(value: string): string;
+  /**
+   * Deserialize data from database read
+   * - Parses JSON strings back to objects
+   * - Converts integers (0/1) back to booleans
+   * - Unmaps column names
+   * - Extracts unknown fields from 'data' column back to top level
+   */
+  protected deserializeFromDb(data: Record<string, unknown> | undefined | null): Record<string, unknown> | null;
+  /**
+   * Internal get implementation - called by BaseIndex.get() via hooks
+   */
+  _get(key: string | Record<string, unknown>): Promise<T | null>;
+  /**
+   * Internal insert implementation - called by BaseIndex.insert() via hooks
+   */
+  _insert(doc: T | Record<string, unknown>): Promise<T>;
+  /**
+   * Internal update implementation - called by BaseIndex.update() via hooks
+   */
+  _update(key: string | Record<string, unknown>, updates: Partial<T>): Promise<T>;
+  /**
+   * Count documents matching a query
+   */
+  count(query?: unknown): Promise<number>;
+  /**
+   * Internal reset implementation - called by BaseIndex.reset() via hooks
+   */
+  _reset(): Promise<void>;
+}
+//#endregion
+export { SqliteTableConfig, TableSchema, SqliteTable as default };

package/esm/table/base.mjs

@@ -0,0 +1,262 @@
+import crypto from "node:crypto";
+import { BaseIndex } from "@ocap/indexdb";
+
+//#region src/table/base.ts
+/**
+* SQLite Index Table base class
+* Extends IndexDBTable to provide SQLite-specific implementation
+*/
+var SqliteTable = class extends BaseIndex {
+	constructor(config) {
+		super(config.name, config.uniqIndex);
+		this.name = config.name;
+		this.db = config.db;
+		this.schema = config.schema || {};
+		this.markReady();
+	}
+	/**
+	* Get the Kysely executor (use transaction if available)
+	*/
+	getExecutor(context) {
+		return context?.txn || this.db;
+	}
+	/**
+	* Generate primary key from document
+	* Handles both simple string keys and composite keys
+	*/
+	generatePrimaryKey(doc) {
+		if (typeof doc === "string") return doc;
+		if (Array.isArray(this.uniqIndex)) {
+			const key = this.uniqIndex.map((id) => doc[id]).map((item) => typeof item === "object" ? JSON.stringify(item) : item).join("-");
+			return crypto.createHash("md5").update(key).digest("hex");
+		}
+		return doc[this.uniqIndex];
+	}
+	/**
+	* Map column name for reserved keywords
+	*/
+	mapColumnName(name) {
+		return this.schema.columnMapping?.[name] ?? name;
+	}
+	/**
+	* Reverse map column name
+	*/
+	unmapColumnName(name) {
+		const mapping = this.schema.columnMapping;
+		if (!mapping) return name;
+		for (const [original, mapped] of Object.entries(mapping)) if (mapped === name) return original;
+		return name;
+	}
+	/**
+	* Serialize data for database insert
+	* - Converts objects/arrays to JSON strings
+	* - Converts booleans to integers (0/1) for SQLite
+	* - Maps column names for reserved keywords
+	* - Adds numeric fields for sorting
+	* - Stores unknown fields in the 'data' column as JSON
+	*/
+	serializeForDb(data) {
+		const result = {};
+		const jsonFields = new Set(this.schema.jsonFields || []);
+		const booleanFields = new Set(this.schema.booleanFields || []);
+		const numericFields = this.schema.numericFields || {};
+		const knownColumns = this.schema.knownColumns ? new Set(this.schema.knownColumns) : null;
+		const unknownFields = {};
+		for (const [key, value] of Object.entries(data)) {
+			const mappedKey = this.mapColumnName(key);
+			if (knownColumns && !knownColumns.has(key) && key !== "data") {
+				unknownFields[key] = value;
+				continue;
+			}
+			if (value === void 0) result[mappedKey] = null;
+			else if (booleanFields.has(key) && typeof value === "boolean") result[mappedKey] = value ? 1 : 0;
+			else if (jsonFields.has(key) || value !== null && typeof value === "object") result[mappedKey] = JSON.stringify(value);
+			else result[mappedKey] = value;
+			if (numericFields[key] && value) result[numericFields[key]] = this.toSortableNumeric(String(value));
+		}
+		if (Object.keys(unknownFields).length > 0) {
+			let existingData = {};
+			if (result.data && typeof result.data === "string") try {
+				existingData = JSON.parse(result.data);
+			} catch {
+				existingData = {};
+			}
+			else if (data.data && typeof data.data === "object") existingData = data.data;
+			result.data = JSON.stringify({
+				...existingData,
+				...unknownFields
+			});
+		}
+		return result;
+	}
+	/**
+	* Serialize data for database update
+	* Preserves unknown fields from existing document's data column
+	*/
+	serializeForDbUpdate(updates, existing) {
+		const result = {};
+		const jsonFields = new Set(this.schema.jsonFields || []);
+		const booleanFields = new Set(this.schema.booleanFields || []);
+		const numericFields = this.schema.numericFields || {};
+		const knownColumns = this.schema.knownColumns ? new Set(this.schema.knownColumns) : null;
+		const unknownFields = {};
+		for (const [key, value] of Object.entries(updates)) {
+			const mappedKey = this.mapColumnName(key);
+			if (knownColumns && !knownColumns.has(key) && key !== "data") {
+				unknownFields[key] = value;
+				continue;
+			}
+			if (value === void 0) result[mappedKey] = null;
+			else if (booleanFields.has(key) && typeof value === "boolean") result[mappedKey] = value ? 1 : 0;
+			else if (jsonFields.has(key) || value !== null && typeof value === "object") result[mappedKey] = JSON.stringify(value);
+			else result[mappedKey] = value;
+			if (numericFields[key] && value) result[numericFields[key]] = this.toSortableNumeric(String(value));
+		}
+		if (knownColumns) {
+			const existingUnknownFields = {};
+			for (const [key, value] of Object.entries(existing)) if (!knownColumns.has(key) && key !== "data") existingUnknownFields[key] = value;
+			const mergedUnknownFields = {
+				...existingUnknownFields,
+				...unknownFields
+			};
+			if (Object.keys(mergedUnknownFields).length > 0) {
+				let baseData = {};
+				if (result.data && typeof result.data === "string") try {
+					baseData = JSON.parse(result.data);
+				} catch {
+					baseData = {};
+				}
+				else if (updates.data && typeof updates.data === "object") baseData = updates.data;
+				result.data = JSON.stringify({
+					...baseData,
+					...mergedUnknownFields
+				});
+			}
+		}
+		return result;
+	}
+	/**
+	* Convert a big number string to a sortable numeric string
+	* Pads with leading zeros to ensure lexicographic sorting works
+	*/
+	toSortableNumeric(value) {
+		return (value.replace(/^0+/, "") || "0").padStart(40, "0");
+	}
+	/**
+	* Deserialize data from database read
+	* - Parses JSON strings back to objects
+	* - Converts integers (0/1) back to booleans
+	* - Unmaps column names
+	* - Extracts unknown fields from 'data' column back to top level
+	*/
+	deserializeFromDb(data) {
+		if (!data) return null;
+		const result = {};
+		const jsonFields = new Set(this.schema.jsonFields || []);
+		const booleanFields = new Set(this.schema.booleanFields || []);
+		const numericFieldValues = new Set(Object.values(this.schema.numericFields || {}));
+		const knownColumns = this.schema.knownColumns ? new Set(this.schema.knownColumns) : null;
+		for (const [key, value] of Object.entries(data)) {
+			if (numericFieldValues.has(key)) continue;
+			const unmappedKey = this.unmapColumnName(key);
+			if (booleanFields.has(unmappedKey) && typeof value === "number") result[unmappedKey] = value === 1;
+			else if (jsonFields.has(unmappedKey) && typeof value === "string") try {
+				result[unmappedKey] = JSON.parse(value);
+			} catch {
+				result[unmappedKey] = value;
+			}
+			else result[unmappedKey] = value;
+		}
+		if (knownColumns && result.data && typeof result.data === "object") {
+			const dataObj = result.data;
+			for (const [key, value] of Object.entries(dataObj)) if (!knownColumns.has(key)) result[key] = value;
+		}
+		delete result.$loki;
+		delete result.meta;
+		return result;
+	}
+	/**
+	* Internal get implementation - called by BaseIndex.get() via hooks
+	*/
+	async _get(key) {
+		if (!key) return null;
+		let query;
+		if (Array.isArray(this.uniqIndex)) if (typeof key === "object") {
+			const keyObj = key;
+			query = Object.fromEntries(this.uniqIndex.map((k) => [this.mapColumnName(k), keyObj[k]]));
+		} else return null;
+		else {
+			const id = typeof key === "string" ? key : key[this.primaryKey];
+			query = { [this.mapColumnName(this.primaryKey)]: id };
+		}
+		let qb = this.db.selectFrom(this.name).selectAll();
+		for (const [k, v] of Object.entries(query)) {
+			if (v === void 0) continue;
+			qb = qb.where(k, "=", v);
+		}
+		const result = await qb.executeTakeFirst();
+		return this.deserializeFromDb(result);
+	}
+	/**
+	* Internal insert implementation - called by BaseIndex.insert() via hooks
+	*/
+	async _insert(doc) {
+		const data = doc;
+		const serialized = this.serializeForDb(data);
+		await this.db.insertInto(this.name).values(serialized).execute();
+		return data;
+	}
+	/**
+	* Internal update implementation - called by BaseIndex.update() via hooks
+	*/
+	async _update(key, updates) {
+		const existing = await this._get(key);
+		if (!existing) throw new Error(`${this.name} does not exist: ${JSON.stringify(key)}`);
+		let query;
+		if (Array.isArray(this.uniqIndex)) {
+			const keyObj = typeof key === "object" ? key : existing;
+			query = Object.fromEntries(this.uniqIndex.map((k) => [this.mapColumnName(k), keyObj[k]]));
+		} else {
+			const id = typeof key === "string" ? key : key[this.primaryKey];
+			query = { [this.mapColumnName(this.primaryKey)]: id };
+		}
+		const updateAttrs = { ...updates };
+		if (Array.isArray(this.uniqIndex)) for (const k of this.uniqIndex) delete updateAttrs[k];
+		else delete updateAttrs[this.primaryKey];
+		if (Object.keys(updateAttrs).length > 0) {
+			const serialized = this.serializeForDbUpdate(updateAttrs, existing);
+			let qb = this.db.updateTable(this.name).set(serialized);
+			for (const [k, v] of Object.entries(query)) {
+				if (v === void 0) continue;
+				qb = qb.where(k, "=", v);
+			}
+			await qb.execute();
+		}
+		return {
+			...existing,
+			...updateAttrs
+		};
+	}
+	/**
+	* Count documents matching a query
+	*/
+	async count(query) {
+		let qb = this.db.selectFrom(this.name).select(this.db.fn.countAll().as("count"));
+		if (query && typeof query === "object") for (const [k, v] of Object.entries(query)) {
+			const mappedKey = this.mapColumnName(k);
+			if (v && typeof v === "object" && "$in" in v) qb = qb.where(mappedKey, "in", v.$in);
+			else qb = qb.where(mappedKey, "=", v);
+		}
+		return (await qb.executeTakeFirst())?.count ?? 0;
+	}
+	/**
+	* Internal reset implementation - called by BaseIndex.reset() via hooks
+	*/
+	async _reset() {
+		await this.db.deleteFrom(this.name).execute();
+	}
+};
+var base_default = SqliteTable;
+
+//#endregion
+export { base_default as default };

package/esm/table/transaction.d.mts

@@ -0,0 +1,18 @@
+import SqliteTable from "./base.mjs";
+import { TIndexedTransaction } from "@ocap/types";
+
+//#region src/table/transaction.d.ts
+
+/**
+ * Transaction table for SQLite IndexDB
+ * Extends base table to call formatTxBeforeInsert on insert
+ */
+declare class TransactionTable extends SqliteTable<TIndexedTransaction> {
+  /**
+   * Override _insert to format transaction before inserting
+   * This populates assets, tokens, factories, etc. from itxJson
+   */
+  _insert(row: TIndexedTransaction | Record<string, unknown>): Promise<TIndexedTransaction>;
+}
+//#endregion
+export { TransactionTable as default };

package/esm/table/transaction.mjs

@@ -0,0 +1,22 @@
+import base_default from "./base.mjs";
+import { formatTxBeforeInsert } from "@ocap/indexdb";
+
+//#region src/table/transaction.ts
+/**
+* Transaction table for SQLite IndexDB
+* Extends base table to call formatTxBeforeInsert on insert
+*/
+var TransactionTable = class extends base_default {
+	/**
+	* Override _insert to format transaction before inserting
+	* This populates assets, tokens, factories, etc. from itxJson
+	*/
+	async _insert(row) {
+		const formatted = formatTxBeforeInsert(row);
+		return super._insert(formatted);
+	}
+};
+var transaction_default = TransactionTable;
+
+//#endregion
+export { transaction_default as default };

package/lib/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,43 @@
+//#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 __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+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
+
+exports.__exportAll = __exportAll;
+exports.__toESM = __toESM;