@ocap/indexdb-sqlite 1.29.5

package/lib/package.cjs

@@ -0,0 +1,76 @@
+
+//#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
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return package_default;
+  }
+});

package/lib/table/base.cjs

@@ -0,0 +1,265 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto);
+let _ocap_indexdb = require("@ocap/indexdb");
+
+//#region src/table/base.ts
+/**
+* SQLite Index Table base class
+* Extends IndexDBTable to provide SQLite-specific implementation
+*/
+var SqliteTable = class extends _ocap_indexdb.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 node_crypto.default.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
+exports.default = base_default;

package/lib/table/base.d.cts

@@ -0,0 +1,107 @@
+import { Database, SqliteOperationContext } from "../interfaces.cjs";
+import { BaseIndex } from "@ocap/indexdb";
+import { IIndexTable } from "@ocap/types";
+import { Kysely, Transaction } from "kysely";
+
+//#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/lib/table/transaction.cjs

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_table_base = require('./base.cjs');
+let _ocap_indexdb = require("@ocap/indexdb");
+
+//#region src/table/transaction.ts
+/**
+* Transaction table for SQLite IndexDB
+* Extends base table to call formatTxBeforeInsert on insert
+*/
+var TransactionTable = class extends require_table_base.default {
+	/**
+	* Override _insert to format transaction before inserting
+	* This populates assets, tokens, factories, etc. from itxJson
+	*/
+	async _insert(row) {
+		const formatted = (0, _ocap_indexdb.formatTxBeforeInsert)(row);
+		return super._insert(formatted);
+	}
+};
+var transaction_default = TransactionTable;
+
+//#endregion
+exports.default = transaction_default;

package/lib/table/transaction.d.cts

@@ -0,0 +1,18 @@
+import SqliteTable from "./base.cjs";
+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/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@ocap/indexdb-sqlite",
+  "description": "OCAP indexdb adapter that uses SQLite as backend",
+  "version": "1.29.5",
+  "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": "1.29.5"
+  },
+  "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": "1.29.5",
+    "@ocap/indexdb": "1.29.5",
+    "@ocap/types": "1.29.5",
+    "@ocap/util": "1.29.5",
+    "debug": "^4.4.3",
+    "better-sqlite3": "^11.8.1",
+    "kysely": "^0.27.0",
+    "kysely-bun-sqlite": "^0.4.0",
+    "lodash": "^4.17.23"
+  }
+}