@ocap/indexdb-memory 1.28.8 → 1.29.0

package/README.md

@@ -1,6 +1,5 @@
 # [**@ocap/indexdb-memory**](https://github.com/arcblock/blockchain)
 
-[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 
 > OCAP indexdb adapter that stores data in memory through lokijs
 
@@ -15,7 +14,7 @@ bun install @ocap/indexdb-memory
 ## Usage
 
 ```js
-const MemoryIndexDB = require('@ocap/indexdb-memory');
+const MemoryIndexDB = require('@ocap/indexdb-memory').default;
 
 const indexdb = new MemoryIndexDB();
 ```

package/esm/db/base.d.mts

@@ -0,0 +1,20 @@
+import { BaseIndexDB } from "@ocap/indexdb";
+import { IIndexDB, IListAccountsResult, IListAssetsResult, IListDelegationsResult, IListFactoriesResult, IListRollupBlocksResult, IListRollupValidatorsResult, IListRollupsResult, IListStakesResult, IListTokenFactoriesResult, IListTokensResult, IListTransactionsResult, TRequestListAssets, TRequestListDelegations, TRequestListFactories, TRequestListRollupBlocks, TRequestListRollupValidators, TRequestListRollups, TRequestListStakes, TRequestListTokenFactories, TRequestListTokens, TRequestListTopAccounts, TRequestListTransactions } from "@ocap/types";
+
+//#region src/db/base.d.ts
+declare class LocalBaseIndexDB extends BaseIndexDB implements IIndexDB {
+  listTransactions(params?: Partial<TRequestListTransactions>): IListTransactionsResult;
+  getRelatedAddresses(address: string): Promise<string[]>;
+  listAssets(params?: Partial<TRequestListAssets>): Promise<IListAssetsResult>;
+  listTopAccounts(params?: Partial<TRequestListTopAccounts>): Promise<IListAccountsResult>;
+  listTokens(params?: Partial<TRequestListTokens>): Promise<IListTokensResult>;
+  listTokenFactories(params?: Partial<TRequestListTokenFactories>): Promise<IListTokenFactoriesResult>;
+  listFactories(params?: Partial<TRequestListFactories>): Promise<IListFactoriesResult>;
+  listStakes(params?: Partial<TRequestListStakes>): IListStakesResult;
+  listRollups(params?: Partial<TRequestListRollups>): Promise<IListRollupsResult>;
+  listRollupBlocks(params?: Partial<TRequestListRollupBlocks>): IListRollupBlocksResult;
+  listRollupValidators(params?: Partial<TRequestListRollupValidators>): IListRollupValidatorsResult;
+  listDelegations(params?: Partial<TRequestListDelegations>): IListDelegationsResult;
+}
+//#endregion
+export { LocalBaseIndexDB as default };

package/esm/db/base.mjs

@@ -0,0 +1,430 @@
+import { name } from "../package.mjs";
+import { BaseIndexDB, formatDelegationAfterRead, formatNextPagination, formatPagination, parseDateTime } from "@ocap/indexdb";
+import debugFactory from "debug";
+import { toChecksumAddress } from "@arcblock/did/lib/type";
+import { BN } from "@ocap/util";
+import { DEFAULT_TOKEN_DECIMAL } from "@ocap/util/lib/constant";
+import omit from "lodash/omit.js";
+
+//#region src/db/base.ts
+const debug = debugFactory(name);
+const MAX_REQUEST_FACTORY_ADDRESS_SIZE = 100;
+/** Helper to safely get collection from IIndexTable */
+function getCollection(table) {
+	return table.collection;
+}
+function applyTimeFilter(query, timeFilter, defaultField, validFields) {
+	let { startDateTime, endDateTime, field = defaultField } = timeFilter;
+	startDateTime = parseDateTime(startDateTime);
+	endDateTime = parseDateTime(endDateTime);
+	if (!validFields.includes(field)) field = defaultField;
+	if (startDateTime && endDateTime) query.where((x) => x[field] > startDateTime && x[field] <= endDateTime);
+	else if (startDateTime) query.where((x) => x[field] > startDateTime);
+	else if (endDateTime) query.where((x) => x[field] <= endDateTime);
+}
+function applyArrayFilter(query, items, fieldName, isArrayField) {
+	if (!items.length) return;
+	if (isArrayField) query.where((x) => x[fieldName].some((f) => items.includes(f)));
+	else query.where((x) => items.includes(x[fieldName]));
+}
+function buildPagingResult(total, pagination, itemCount) {
+	return {
+		cursor: String(pagination.cursor + itemCount),
+		next: itemCount >= pagination.size,
+		total
+	};
+}
+var LocalBaseIndexDB = class extends BaseIndexDB {
+	listTransactions(params = {}) {
+		const { addressFilter = {}, paging = {}, timeFilter = {}, typeFilter = {}, assetFilter = {}, factoryFilter = {}, tokenFilter = {}, accountFilter = {}, validityFilter = {}, txFilter = {}, rollupFilter = {}, stakeFilter = {}, delegationFilter = {}, tokenFactoryFilter = {}, includeItxData = false } = params;
+		const query = getCollection(this.tx).chain();
+		const { sender, receiver, direction = "UNION" } = addressFilter;
+		const { types = [] } = typeFilter;
+		const { factories = [] } = factoryFilter;
+		const { assets = [] } = assetFilter;
+		const { tokens = [] } = tokenFilter;
+		const { accounts = [] } = accountFilter;
+		const { txs = [] } = txFilter;
+		const { rollups = [] } = rollupFilter;
+		const { stakes = [] } = stakeFilter;
+		const { delegations = [] } = delegationFilter;
+		const { tokenFactories = [] } = tokenFactoryFilter;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "time"
+		});
+		debug("listTransactions", {
+			sender,
+			receiver,
+			pagination,
+			types,
+			factories,
+			assets,
+			tokens,
+			accounts,
+			rollups,
+			stakes,
+			delegations,
+			includeItxData
+		});
+		if (sender && receiver) {
+			if (direction === "MUTUAL") query.where((x) => x.sender === sender && x.receiver === receiver || x.sender === receiver && x.receiver === sender);
+			else if (direction === "ONE_WAY") query.where((x) => x.sender === sender && x.receiver === receiver);
+			else if (direction === "UNION") query.where((x) => x.sender === sender || x.receiver === receiver);
+		} else if (sender) query.where((x) => x.sender === sender);
+		else if (receiver) query.where((x) => x.receiver === receiver);
+		applyArrayFilter(query, types, "type", false);
+		applyArrayFilter(query, factories, "factories", true);
+		applyArrayFilter(query, assets, "assets", true);
+		applyArrayFilter(query, tokens, "tokens", true);
+		applyArrayFilter(query, accounts, "accounts", true);
+		applyArrayFilter(query, tokenFactories, "tokenFactories", true);
+		applyArrayFilter(query, txs, "hash", false);
+		applyArrayFilter(query, rollups, "rollups", true);
+		applyArrayFilter(query, stakes, "stakes", true);
+		applyArrayFilter(query, delegations, "delegations", true);
+		applyTimeFilter(query, timeFilter, "time", ["time"]);
+		const { validity } = validityFilter;
+		if (validity === "VALID") query.where((x) => x.valid === true);
+		else if (validity === "INVALID") query.where((x) => x.valid === false);
+		let transactions = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		if (!includeItxData) transactions = transactions.map((tx) => {
+			if (tx.tx && tx.tx?.itxJson) return {
+				...tx,
+				tx: {
+					...tx.tx,
+					itxJson: omit(tx.tx.itxJson, ["data"])
+				}
+			};
+			return tx;
+		});
+		const total = query.count();
+		return {
+			transactions,
+			paging: buildPagingResult(total, pagination, transactions.length)
+		};
+	}
+	async getRelatedAddresses(address) {
+		let account = await this.account.get(address);
+		if (!account) return [];
+		const related = [address];
+		while (account?.migratedFrom && related.length <= 8) {
+			const migratedFrom = account.migratedFrom;
+			related.push(migratedFrom);
+			account = await this.account.get(migratedFrom);
+		}
+		return related.filter(Boolean);
+	}
+	async listAssets(params = {}) {
+		const { ownerAddress, factoryAddress, paging, timeFilter = {} } = params;
+		if (!ownerAddress && !factoryAddress) return {
+			assets: [],
+			account: null,
+			paging: {
+				cursor: "0",
+				next: false,
+				total: 0
+			}
+		};
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime"
+		});
+		const { field = "renaissanceTime" } = timeFilter;
+		if ([
+			"genesisTime",
+			"renaissanceTime",
+			"consumedTime"
+		].includes(field) === false) throw new Error("invalid field specified in timeFilter");
+		const query = getCollection(this.asset).chain();
+		if (ownerAddress) {
+			const possibleOwners = await this.getRelatedAddresses(ownerAddress);
+			if (possibleOwners.length) query.where((x) => possibleOwners.includes(x.owner));
+			else return {
+				assets: [],
+				account: null,
+				paging: {
+					cursor: "0",
+					next: false,
+					total: 0
+				}
+			};
+		}
+		if (factoryAddress) query.where((x) => x.parent === factoryAddress);
+		applyTimeFilter(query, timeFilter, "renaissanceTime", [
+			"genesisTime",
+			"renaissanceTime",
+			"consumedTime"
+		]);
+		debug("listAssets", {
+			ownerAddress,
+			factoryAddress,
+			timeFilter,
+			paging,
+			pagination
+		});
+		const assets = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		const total = query.count();
+		return {
+			assets,
+			account: ownerAddress ? await this.account.get(ownerAddress) : null,
+			paging: formatNextPagination(total, pagination)
+		};
+	}
+	async listTopAccounts(params = {}) {
+		const { paging, tokenAddress } = params;
+		const query = getCollection(this.account).chain();
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "balance",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"balance",
+				"moniker"
+			]
+		});
+		debug("listTopAccounts", {
+			tokenAddress,
+			paging,
+			pagination
+		});
+		query.where((x) => {
+			const owned = x.tokens.find((t) => t.address === tokenAddress);
+			return owned ? owned.balance > "0" : false;
+		});
+		if (pagination.order.field === "balance") {
+			const descending = pagination.order.type === "desc";
+			query.sort((a, b) => {
+				const tokenA = a.tokens.find((t) => t.address === tokenAddress);
+				const tokenB = b.tokens.find((t) => t.address === tokenAddress);
+				const balanceA = new BN(tokenA ? tokenA.balance : "0");
+				const balanceB = new BN(tokenB ? tokenB.balance : "0");
+				if (balanceB.gt(balanceA)) return descending ? 1 : -1;
+				if (balanceB.eq(balanceA)) return 0;
+				return descending ? -1 : 1;
+			});
+		} else query.simplesort(pagination.order.field, pagination.order.type === "desc");
+		const accounts = query.offset(pagination.cursor).limit(pagination.size).data();
+		const total = query.count();
+		accounts.forEach((account) => {
+			const acc = account;
+			if (Array.isArray(acc.tokens) && acc.tokens.length) acc.tokens = acc.tokens.map((token) => {
+				token.decimal = typeof token.decimal === "undefined" ? DEFAULT_TOKEN_DECIMAL : token.decimal;
+				return token;
+			});
+		});
+		return {
+			accounts,
+			paging: formatNextPagination(total, pagination)
+		};
+	}
+	async listTokens(params = {}) {
+		const { issuerAddress, paging } = params;
+		const conditions = {};
+		if (issuerAddress) conditions.issuer = issuerAddress;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"issuer",
+				"symbol",
+				"totalSupply"
+			]
+		});
+		debug("listTokens", {
+			issuerAddress,
+			paging,
+			conditions,
+			pagination
+		});
+		let tokens = getCollection(this.token).chain().find(conditions).simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		tokens = tokens.map((token) => {
+			const t = token;
+			t.decimal = typeof t.decimal === "undefined" ? DEFAULT_TOKEN_DECIMAL : t.decimal;
+			return t;
+		});
+		const total = this.token.count(Object.keys(conditions).length ? conditions : void 0);
+		return {
+			tokens,
+			paging: formatNextPagination(total, pagination)
+		};
+	}
+	async listTokenFactories(params = {}) {
+		const { owner, reserveAddress, tokenAddress, paging } = params;
+		const conditions = {};
+		if (owner) conditions.owner = owner;
+		if (reserveAddress) conditions.reserveAddress = reserveAddress;
+		if (tokenAddress) conditions.tokenAddress = tokenAddress;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"reserveBalance",
+				"currentSupply"
+			]
+		});
+		debug("listTokenFactories", {
+			owner,
+			reserveAddress,
+			tokenAddress,
+			paging,
+			conditions,
+			pagination
+		});
+		return {
+			tokenFactories: getCollection(this.tokenFactory).chain().find(conditions).simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data(),
+			paging: formatNextPagination(this.tokenFactory.count(Object.keys(conditions).length ? conditions : void 0), pagination)
+		};
+	}
+	async listFactories(params = {}) {
+		const { ownerAddress, addressList, paging } = params;
+		const conditions = {};
+		if (ownerAddress) conditions.owner = ownerAddress;
+		if (Array.isArray(addressList) && addressList.length > 0) {
+			if (addressList.length > MAX_REQUEST_FACTORY_ADDRESS_SIZE) throw new Error(`The length of 'addressList' cannot exceed the length of ${MAX_REQUEST_FACTORY_ADDRESS_SIZE}`);
+			conditions.address = { $in: addressList };
+		}
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"owner",
+				"numMinted",
+				"limit",
+				"name"
+			]
+		});
+		debug("listFactories", {
+			ownerAddress,
+			paging,
+			conditions,
+			pagination
+		});
+		return {
+			factories: getCollection(this.factory).chain().find(conditions).simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data(),
+			paging: formatNextPagination(this.factory.count(Object.keys(conditions).length ? conditions : void 0), pagination)
+		};
+	}
+	listStakes(params = {}) {
+		const { addressFilter = {}, paging = {}, timeFilter = {}, assetFilter = {} } = params;
+		const query = getCollection(this.stake).chain();
+		const { sender, receiver } = addressFilter;
+		const { assets = [] } = assetFilter;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		if (sender && receiver) query.where((x) => x.sender === sender && x.receiver === receiver);
+		else if (sender) query.where((x) => x.sender === sender);
+		else if (receiver) query.where((x) => x.receiver === receiver);
+		applyArrayFilter(query, assets, "assets", true);
+		applyTimeFilter(query, timeFilter, "renaissanceTime", ["genesisTime", "renaissanceTime"]);
+		const stakes = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		return {
+			stakes,
+			paging: buildPagingResult(query.count(), pagination, stakes.length)
+		};
+	}
+	async listRollups(params = {}) {
+		const { paging, tokenAddress = "", erc20TokenAddress = "", foreignTokenAddress = "" } = params;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		const query = getCollection(this.rollup).chain();
+		if (tokenAddress) query.where((x) => x.tokenAddress === tokenAddress);
+		const foreignTokenAddr = foreignTokenAddress || erc20TokenAddress;
+		if (erc20TokenAddress) query.where((x) => x.foreignToken.contractAddress === toChecksumAddress(foreignTokenAddr));
+		debug("listRollups", {
+			paging,
+			pagination
+		});
+		return {
+			rollups: query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data(),
+			paging: formatNextPagination(query.count(), pagination)
+		};
+	}
+	listRollupBlocks(params = {}) {
+		const { paging = {}, rollupAddress = "", tokenAddress = "", proposer = "", height = "", timeFilter = {}, txFilter = {}, validatorFilter = {} } = params;
+		const query = getCollection(this.rollupBlock).chain();
+		const { txs = [] } = txFilter;
+		const { validators = [] } = validatorFilter;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "genesisTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		if (rollupAddress) query.where((x) => x.rollup === rollupAddress);
+		if (Number(height) > 0) query.where((x) => Number(x.height) === Number(height));
+		if (proposer) query.where((x) => x.proposer === proposer);
+		if (tokenAddress) query.where((x) => x.tokenInfo.address === tokenAddress);
+		applyArrayFilter(query, txs, "txs", true);
+		applyArrayFilter(query, validators, "validators", true);
+		applyTimeFilter(query, timeFilter, "genesisTime", ["genesisTime", "renaissanceTime"]);
+		const blocks = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		return {
+			blocks,
+			paging: buildPagingResult(query.count(), pagination, blocks.length)
+		};
+	}
+	listRollupValidators(params = {}) {
+		const { paging = {}, rollupAddress = "" } = params;
+		const query = getCollection(this.rollupValidator).chain();
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "genesisTime",
+			supportedSortFields: [
+				"joinTime",
+				"leaveTime",
+				"genesisTime",
+				"renaissanceTime"
+			]
+		});
+		if (rollupAddress) query.where((x) => x.rollup === rollupAddress);
+		const validators = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		return {
+			validators,
+			paging: buildPagingResult(query.count(), pagination, validators.length)
+		};
+	}
+	listDelegations(params = {}) {
+		const { from, to, paging = {}, timeFilter = {} } = params;
+		if (!from && !to) return {
+			delegations: [],
+			paging: {
+				cursor: "0",
+				next: false,
+				total: 0
+			}
+		};
+		const query = getCollection(this.delegation).chain();
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		if (from && to) query.where((x) => x.from === from && x.to === to);
+		else if (from) query.where((x) => x.from === from);
+		else if (to) query.where((x) => x.to === to);
+		applyTimeFilter(query, timeFilter, "renaissanceTime", ["genesisTime", "renaissanceTime"]);
+		const delegations = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		const total = query.count();
+		return {
+			delegations: delegations.map((d) => formatDelegationAfterRead(d)),
+			paging: buildPagingResult(total, pagination, delegations.length)
+		};
+	}
+};
+var base_default = LocalBaseIndexDB;
+
+//#endregion
+export { base_default as default };

package/esm/db/index.d.mts

@@ -0,0 +1,27 @@
+import LocalBaseIndexDB from "./base.mjs";
+import { md5 } from "@ocap/util/lib/md5";
+import Lokijs from "lokijs";
+import { IIndexDB, IIndexTable, IndexTableTypeMap } from "@ocap/types";
+
+//#region src/db/index.d.ts
+declare class MemoryIndexDB extends LocalBaseIndexDB implements IIndexDB {
+  name: string;
+  version: string;
+  md5: typeof md5;
+  db: Lokijs;
+  tx: IIndexTable<IndexTableTypeMap['tx']>;
+  account: IIndexTable<IndexTableTypeMap['account']>;
+  asset: IIndexTable<IndexTableTypeMap['asset']>;
+  token: IIndexTable<IndexTableTypeMap['token']>;
+  factory: IIndexTable<IndexTableTypeMap['factory']>;
+  stake: IIndexTable<IndexTableTypeMap['stake']>;
+  delegation: IIndexTable<IndexTableTypeMap['delegation']>;
+  rollup: IIndexTable<IndexTableTypeMap['rollup']>;
+  rollupBlock: IIndexTable<IndexTableTypeMap['rollupBlock']>;
+  rollupValidator: IIndexTable<IndexTableTypeMap['rollupValidator']>;
+  tokenDistribution: IIndexTable<IndexTableTypeMap['tokenDistribution']>;
+  tokenFactory: IIndexTable<IndexTableTypeMap['tokenFactory']>;
+  constructor();
+}
+//#endregion
+export { MemoryIndexDB as default };

package/esm/db/index.mjs

@@ -0,0 +1,37 @@
+import { name, version } from "../package.mjs";
+import base_default from "../table/base.mjs";
+import transaction_default from "../table/transaction.mjs";
+import base_default$1 from "./base.mjs";
+import { md5 } from "@ocap/util/lib/md5";
+import Lokijs from "lokijs";
+
+//#region src/db/index.ts
+let instanceCounter = 0;
+var MemoryIndexDB = class extends base_default$1 {
+	constructor() {
+		super();
+		this.name = name;
+		this.version = version;
+		this.md5 = md5;
+		instanceCounter += 1;
+		this.db = new Lokijs(`ocap-memory-indexdb-${instanceCounter}.db`);
+		this.account = new base_default("account", "address", this.db);
+		this.asset = new base_default("asset", "address", this.db);
+		this.delegation = new base_default("delegation", "address", this.db);
+		this.tx = new transaction_default("tx", "hash", this.db);
+		this.factory = new base_default("factory", "address", this.db);
+		this.token = new base_default("token", "address", this.db);
+		this.stake = new base_default("stake", "address", this.db);
+		this.rollup = new base_default("rollup", "address", this.db);
+		this.rollupBlock = new base_default("rollupBlock", "hash", this.db);
+		this.rollupValidator = new base_default("rollupValidator", "address", this.db);
+		this.tokenDistribution = new base_default("tokenDistribution", "tokenAddress", this.db);
+		this.balance = new base_default("balance", ["address", "tokenAddress"], this.db);
+		this.tokenFactory = new base_default("tokenFactory", "address", this.db);
+		this.attachReadyListeners();
+	}
+};
+var db_default = MemoryIndexDB;
+
+//#endregion
+export { db_default as default };

package/esm/main.d.mts

@@ -0,0 +1,3 @@
+import LocalBaseIndexDB from "./db/base.mjs";
+import MemoryIndexDB from "./db/index.mjs";
+export { LocalBaseIndexDB, MemoryIndexDB as default };

package/esm/main.mjs

@@ -0,0 +1,8 @@
+import base_default from "./db/base.mjs";
+import db_default from "./db/index.mjs";
+
+//#region src/main.ts
+var main_default = db_default;
+
+//#endregion
+export { base_default as LocalBaseIndexDB, main_default as default };

package/esm/package.mjs

@@ -0,0 +1,6 @@
+//#region package.json
+var name = "@ocap/indexdb-memory";
+var version = "1.20.2";
+
+//#endregion
+export { name, version };

package/esm/table/base.d.mts

@@ -0,0 +1,22 @@
+import Lokijs from "lokijs";
+import { BaseIndex } from "@ocap/indexdb";
+import { IIndexTable } from "@ocap/types";
+
+//#region src/table/base.d.ts
+type UniqueIndex = string | string[];
+declare class MemoryIndex<T = unknown> extends BaseIndex<T> implements IIndexTable<T> {
+  collection: Lokijs.Collection<T & Record<string, unknown>>;
+  /**
+   * @param name table name
+   * @param uniqIndex primary key(s)
+   * @param db LokiJS database instance
+   */
+  constructor(name: string, uniqIndex: UniqueIndex, db: Lokijs);
+  count(...args: Parameters<Lokijs.Collection['count']>): number;
+  _insert(row: Record<string, unknown>): T & Record<string, unknown>;
+  _get(key: string | Record<string, unknown>): (T & Record<string, unknown>) | null;
+  _update(key: string | Record<string, unknown>, updates: Record<string, unknown>): T & Record<string, unknown>;
+  _reset(): void;
+}
+//#endregion
+export { MemoryIndex as default };

package/esm/table/base.mjs

@@ -0,0 +1,52 @@
+import { name } from "../package.mjs";
+import { BaseIndex } from "@ocap/indexdb";
+import debugFactory from "debug";
+
+//#region src/table/base.ts
+const debug = debugFactory(name);
+var MemoryIndex = class MemoryIndex extends BaseIndex {
+	/**
+	* @param name table name
+	* @param uniqIndex primary key(s)
+	* @param db LokiJS database instance
+	*/
+	constructor(name$1, uniqIndex, db) {
+		super(name$1, uniqIndex);
+		if (!db) throw new Error("db is required for MemoryIndex");
+		this.collection = db.addCollection(name$1, {
+			unique: [this.primaryKey],
+			clone: true
+		});
+		this.markReady();
+	}
+	count(...args) {
+		return this.collection.count(...args);
+	}
+	_insert(row) {
+		debug(`insert ${this.name}`, row);
+		const id = this.generatePrimaryKey(row);
+		return this.collection.insert({
+			[this.primaryKey]: id,
+			...row
+		});
+	}
+	_get(key) {
+		const id = this.generatePrimaryKey(key);
+		return key ? this.collection.by(this.primaryKey, id) ?? null : null;
+	}
+	_update(key, updates) {
+		const id = this.generatePrimaryKey(key);
+		const doc = MemoryIndex.prototype._get.call(this, id);
+		if (!doc) throw new Error(`${this.name} does not exists: ${key}`);
+		Object.assign(doc, updates);
+		this.collection.update(doc);
+		return doc;
+	}
+	_reset() {
+		this.collection.removeWhere({});
+	}
+};
+var base_default = MemoryIndex;
+
+//#endregion
+export { base_default as default };

package/esm/table/transaction.d.mts

@@ -0,0 +1,9 @@
+import MemoryIndex from "./base.mjs";
+import { TIndexedTransaction } from "@ocap/types";
+
+//#region src/table/transaction.d.ts
+declare class Transaction extends MemoryIndex<TIndexedTransaction> {
+  _insert(row: Record<string, unknown>): TIndexedTransaction & Record<string, unknown>;
+}
+//#endregion
+export { Transaction as default };

package/esm/table/transaction.mjs

@@ -0,0 +1,13 @@
+import base_default from "./base.mjs";
+import { formatTxBeforeInsert } from "@ocap/indexdb";
+
+//#region src/table/transaction.ts
+var Transaction = class extends base_default {
+	_insert(row) {
+		return super._insert(formatTxBeforeInsert(row));
+	}
+};
+var transaction_default = Transaction;
+
+//#endregion
+export { transaction_default as default };