@ocap/statedb-fs 1.28.9 → 1.29.1

package/lib/table/account.cjs

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_table_base = require('./base.cjs');
+let _ocap_state_lib_states_account = require("@ocap/state/lib/states/account");
+
+//#region src/table/account.ts
+/**
+* Account 表
+* 扩展基础表，增加账户迁移追踪功能
+*/
+var AccountTable = class extends require_table_base.default {
+	async _get(address, context = {}) {
+		const { traceMigration = true, ...restContext } = context;
+		const current = await super._get((0, _ocap_state_lib_states_account.ensureChecksumAddress)(address), restContext);
+		if (current && traceMigration && Array.isArray(current.migratedTo) && current.migratedTo.length) return this._get(current.migratedTo[0], context);
+		return current;
+	}
+	_create(key, attrs = {}, ctx) {
+		const address = (0, _ocap_state_lib_states_account.ensureChecksumAddress)(key);
+		return super._create(address, {
+			...attrs,
+			address
+		}, ctx);
+	}
+};
+var account_default = AccountTable;
+
+//#endregion
+exports.default = account_default;

package/lib/table/account.d.cts

@@ -0,0 +1,17 @@
+import FsTable from "./base.cjs";
+import { IAccountState, IOperationContext } from "@ocap/types";
+
+//#region src/table/account.d.ts
+interface AccountOperationContext extends IOperationContext {
+  traceMigration?: boolean;
+}
+/**
+ * Account 表
+ * 扩展基础表，增加账户迁移追踪功能
+ */
+declare class AccountTable extends FsTable<IAccountState> {
+  _get(address: string | Record<string, unknown>, context?: AccountOperationContext): Promise<IAccountState | null>;
+  _create(key: string | Record<string, unknown>, attrs?: Partial<IAccountState>, ctx?: IOperationContext): Promise<IAccountState>;
+}
+//#endregion
+export { AccountTable as default };

package/lib/table/balance.cjs

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_table_base = require('./base.cjs');
+
+//#region src/table/balance.ts
+/**
+* Balance 表
+* 扩展基础表，增加余额管理功能
+*/
+var BalanceTable = class extends require_table_base.default {
+	async getBalance(address, _context) {
+		return (await this.collection.find({ address }) || []).reduce((acc, token) => {
+			acc[token.tokenAddress] = token.balance;
+			return acc;
+		}, {});
+	}
+	async updateBalance({ address, tokens, context = {} }, ctx) {
+		if (!Object.keys(tokens).length) return {};
+		const tokenBalances = await this.getBalance(address);
+		const updatedTokens = Object.keys(tokens).filter((token) => tokenBalances[token] && tokenBalances[token] !== "0" || tokens[token] && tokens[token] !== "0").filter((token) => tokenBalances[token] !== tokens[token]);
+		await Promise.all(updatedTokens.map(async (token) => {
+			const key = {
+				address,
+				tokenAddress: token
+			};
+			if (tokenBalances[token]) await this.update(key, {
+				...key,
+				balance: tokens[token],
+				context
+			}, ctx);
+			else await this.create(key, {
+				...key,
+				balance: tokens[token],
+				context
+			}, ctx);
+			tokenBalances[token] = tokens[token];
+		}));
+		return tokens;
+	}
+};
+var balance_default = BalanceTable;
+
+//#endregion
+exports.default = balance_default;

package/lib/table/balance.d.cts

@@ -0,0 +1,23 @@
+import FsTable from "./base.cjs";
+import { IBalanceState, IOperationContext } from "@ocap/types";
+
+//#region src/table/balance.d.ts
+
+/**
+ * Balance 表
+ * 扩展基础表，增加余额管理功能
+ */
+declare class BalanceTable extends FsTable<IBalanceState> {
+  getBalance(address: string, _context?: IOperationContext): Promise<Record<string, string>>;
+  updateBalance({
+    address,
+    tokens,
+    context
+  }: {
+    address: string;
+    tokens: Record<string, string>;
+    context?: unknown;
+  }, ctx?: IOperationContext): Promise<Record<string, string>>;
+}
+//#endregion
+export { BalanceTable as default };

package/lib/table/base.cjs

@@ -0,0 +1,115 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_package = require('../package.cjs');
+let _ocap_statedb = require("@ocap/statedb");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let lodash_omit = require("lodash/omit");
+lodash_omit = require_rolldown_runtime.__toESM(lodash_omit);
+let lokijs = require("lokijs");
+lokijs = require_rolldown_runtime.__toESM(lokijs);
+let lokijs_src_loki_fs_structured_adapter = require("lokijs/src/loki-fs-structured-adapter");
+lokijs_src_loki_fs_structured_adapter = require_rolldown_runtime.__toESM(lokijs_src_loki_fs_structured_adapter);
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+
+//#region src/table/base.ts
+const debug$1 = (0, debug.default)(require_package.name);
+/**
+* 文件系统表基类
+* 使用 LokiJS + FSAdapter 作为底层存储
+*/
+var FsTable = class FsTable extends _ocap_statedb.StateDBTable {
+	constructor({ name: name$1, dataDir, uniqIndex, balanceTable, syncBalance = false }) {
+		super(uniqIndex);
+		this.name = name$1;
+		this.dataDir = dataDir;
+		this.collection = null;
+		this.balanceTable = balanceTable;
+		this.syncBalance = syncBalance;
+		if (this.syncBalance && !this.balanceTable) throw new Error("balanceTable is required when syncBalance is true");
+		const adapter = new lokijs_src_loki_fs_structured_adapter.default();
+		const db = new lokijs.default(node_path.default.join(dataDir, `${name$1}.db`), {
+			adapter,
+			autoload: true,
+			autosave: true,
+			autosaveInterval: 1e3,
+			autoloadCallback: () => {
+				this.collection = db.getCollection(name$1);
+				if (this.collection === null) this.collection = db.addCollection(name$1, {
+					unique: [this.primaryKey],
+					clone: true
+				});
+				this.markReady();
+			}
+		});
+	}
+	async _create(key, attrs = {}, _context) {
+		const id = this.generatePrimaryKey(key);
+		if (await FsTable.prototype._get.call(this, id)) throw new Error(`${this.name} already exists: ${key}`);
+		debug$1(`insert ${this.name}`, attrs);
+		const insertAttrs = { ...attrs };
+		if (this.syncBalance) delete insertAttrs.tokens;
+		const result = await this.collection.insert({
+			[this.primaryKey]: id,
+			...insertAttrs
+		});
+		if (this.syncBalance && attrs.tokens) {
+			debug$1(`update balance for ${this.name}`, attrs);
+			result.tokens = await this.balanceTable.updateBalance({
+				address: attrs.address,
+				tokens: attrs.tokens,
+				context: attrs.context
+			});
+		}
+		return result;
+	}
+	async _get(key, _context) {
+		if (!key) return null;
+		const id = this.generatePrimaryKey(key);
+		const result = await this.collection.by(this.primaryKey, id);
+		if (result && this.syncBalance) {
+			const balance = await this.balanceTable.getBalance(result.address);
+			result.tokens = {
+				...result.tokens || {},
+				...balance
+			};
+		}
+		return result;
+	}
+	_history(_key, _context) {
+		return [];
+	}
+	async _update(key, updates, _context) {
+		const id = this.generatePrimaryKey(key);
+		const doc = await FsTable.prototype._get.call(this, id);
+		if (!doc) throw new Error(`${this.name} does not exists: ${key}`);
+		Object.assign(doc, updates);
+		const updateAttrs = { ...doc };
+		if (this.syncBalance) delete updateAttrs.tokens;
+		await this.collection.update(updateAttrs);
+		if (this.syncBalance && doc.tokens) {
+			debug$1(`update balance for ${this.name}`, doc);
+			doc.tokens = await this.balanceTable.updateBalance({
+				address: doc.address,
+				tokens: doc.tokens,
+				context: doc.context
+			});
+		}
+		return doc;
+	}
+	updateOrCreate(exist, state, ctx) {
+		const id = this.generatePrimaryKey(state);
+		const attrs = (0, lodash_omit.default)(state, this.primaryKey);
+		if (!id) throw new Error("Cannot update or create without uniq index");
+		if (exist) return this.update(id, attrs, ctx);
+		return this.create(id, attrs, ctx);
+	}
+	_reset(_context) {
+		this.collection.removeWhere({});
+	}
+};
+var base_default = FsTable;
+
+//#endregion
+exports.default = base_default;

package/lib/table/base.d.cts

@@ -0,0 +1,38 @@
+import { StateDBTable } from "@ocap/statedb";
+import { IBalanceTable, IOperationContext } from "@ocap/types";
+import Lokijs from "lokijs";
+
+//#region src/table/base.d.ts
+interface FsTableOptions {
+  name: string;
+  dataDir: string;
+  uniqIndex: string | string[];
+  balanceTable?: IBalanceTable;
+  syncBalance?: boolean;
+}
+/**
+ * 文件系统表基类
+ * 使用 LokiJS + FSAdapter 作为底层存储
+ */
+declare class FsTable<T = unknown> extends StateDBTable<T> {
+  name: string;
+  dataDir: string;
+  collection: Lokijs.Collection | null;
+  balanceTable?: IBalanceTable;
+  syncBalance: boolean;
+  constructor({
+    name,
+    dataDir,
+    uniqIndex,
+    balanceTable,
+    syncBalance
+  }: FsTableOptions);
+  _create(key: string | Record<string, unknown>, attrs?: Partial<T>, _context?: IOperationContext): Promise<T>;
+  _get(key: string | Record<string, unknown>, _context?: IOperationContext): Promise<T | null>;
+  _history(_key?: string | Record<string, unknown>, _context?: IOperationContext): T[];
+  _update(key: string | Record<string, unknown>, updates: Partial<T>, _context?: IOperationContext): Promise<T>;
+  updateOrCreate(exist: unknown, state: Partial<T>, ctx?: IOperationContext): Promise<T>;
+  _reset(_context?: IOperationContext): void;
+}
+//#endregion
+export { FsTable as default };

package/lib/table/rollup.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_table_base = require('./base.cjs');
+
+//#region src/table/rollup.ts
+/**
+* Rollup 表
+* 扩展基础表，增加按代币查询功能
+*/
+var RollupTable = class extends require_table_base.default {
+	async existByToken(token) {
+		if (!token) return false;
+		return this.collection.count({
+			tokenAddress: token,
+			paused: false
+		}) > 0;
+	}
+};
+var rollup_default = RollupTable;
+
+//#endregion
+exports.default = rollup_default;

package/lib/table/rollup.d.cts

@@ -0,0 +1,14 @@
+import FsTable from "./base.cjs";
+import { IRollupState } from "@ocap/types";
+
+//#region src/table/rollup.d.ts
+
+/**
+ * Rollup 表
+ * 扩展基础表，增加按代币查询功能
+ */
+declare class RollupTable extends FsTable<IRollupState> {
+  existByToken(token?: string | null): Promise<boolean>;
+}
+//#endregion
+export { RollupTable as default };

package/lib/table/token.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_table_base = require('./base.cjs');
+
+//#region src/table/token.ts
+/**
+* Token 表
+* 扩展基础表，增加按符号查询功能
+*/
+var TokenTable = class extends require_table_base.default {
+	async existBySymbol(symbol) {
+		if (!symbol) throw new Error("param symbol is required");
+		return this.collection.count({ symbol }) > 0;
+	}
+};
+var token_default = TokenTable;
+
+//#endregion
+exports.default = token_default;

package/lib/table/token.d.cts

@@ -0,0 +1,14 @@
+import FsTable from "./base.cjs";
+import { ITokenState } from "@ocap/types";
+
+//#region src/table/token.d.ts
+
+/**
+ * Token 表
+ * 扩展基础表，增加按符号查询功能
+ */
+declare class TokenTable extends FsTable<ITokenState> {
+  existBySymbol(symbol?: string | null): Promise<boolean>;
+}
+//#endregion
+export { TokenTable as default };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ocap/statedb-fs",
   "description": "OCAP statedb adapter that uses fs as backend",
-  "version": "1.28.9",
+  "version": "1.29.1",
   "author": "wangshijun <shijun@arcblock.io> (https://www.arcblock.io)",
   "bugs": {
     "url": "https://github.com/ArcBlock/blockchain/issues",
@@ -21,27 +21,51 @@
     "fs"
   ],
   "license": "Apache-2.0",
-  "main": "./lib/index.js",
+  "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"
+    "lib",
+    "esm"
   ],
   "repository": {
     "type": "git",
     "url": "https://github.com/ArcBlock/blockchain/tree/master/statedb/fs"
   },
   "scripts": {
+    "build": "tsdown",
+    "prebuild": "rm -rf lib esm",
     "lint": "biome check",
     "lint:fix": "biome check --write",
     "test": "bun test",
-    "coverage": "npm run test -- --coverage & exit 0"
+    "coverage": "npm run test -- --coverage"
   },
   "gitHead": "87990c8b5e215107fc587c1ced0d6b3e2cd2483e",
   "dependencies": {
-    "@ocap/state": "1.28.9",
-    "@ocap/statedb": "1.28.9",
-    "@ocap/util": "1.28.9",
-    "debug": "^4.3.6",
-    "lodash": "^4.17.21",
+    "@ocap/state": "1.29.1",
+    "@ocap/statedb": "1.29.1",
+    "@ocap/types": "1.29.1",
+    "@ocap/util": "1.29.1",
+    "debug": "^4.4.3",
+    "lodash": "^4.17.23",
     "lokijs": "^1.5.12"
   }
 }

package/lib/db.js

@@ -1,54 +0,0 @@
-const { StateDB } = require('@ocap/statedb');
-
-const Table = require('./table/base');
-const Account = require('./table/account');
-const Token = require('./table/token');
-const Rollup = require('./table/rollup');
-const Balance = require('./table/balance');
-
-const { name, version } = require('../package.json');
-
-class FsStateDB extends StateDB {
-  constructor(dataDir) {
-    super();
-
-    this.name = name;
-    this.version = version;
-
-    this.balance = new Balance({ name: 'balance', dataDir, uniqIndex: ['address', 'tokenAddress'] });
-    this.account = new Account({
-      name: 'account',
-      dataDir,
-      uniqIndex: 'address',
-      balanceTable: this.balance,
-      syncBalance: true,
-    });
-    this.factory = new Table({
-      name: 'factory',
-      dataDir,
-      uniqIndex: 'address',
-      syncBalance: true,
-      balanceTable: this.balance,
-    });
-    this.stake = new Table({
-      name: 'stake',
-      dataDir,
-      uniqIndex: 'address',
-      syncBalance: true,
-      balanceTable: this.balance,
-    });
-    this.asset = new Table({ name: 'asset', dataDir, uniqIndex: 'address' });
-    this.delegation = new Table({ name: 'delegation', dataDir, uniqIndex: 'address' });
-    this.tx = new Table({ name: 'tx', dataDir, uniqIndex: 'hash' });
-    this.token = new Token({ name: 'token', dataDir, uniqIndex: 'address' });
-    this.chain = new Table({ name: 'chain', dataDir, uniqIndex: 'address' });
-    this.rollup = new Rollup({ name: 'rollup', dataDir, uniqIndex: 'address' });
-    this.rollupBlock = new Table({ name: 'rollupBlock', dataDir, uniqIndex: 'hash' });
-    this.evidence = new Table({ name: 'evidence', dataDir, uniqIndex: 'hash' });
-    this.tokenFactory = new Table({ name: 'tokenFactory', dataDir, uniqIndex: 'address' });
-
-    this.attachReadyListeners();
-  }
-}
-
-module.exports = FsStateDB;

package/lib/index.js

@@ -1 +0,0 @@
-module.exports = require('./db');

package/lib/table/account.js

@@ -1,20 +0,0 @@
-const { ensureChecksumAddress } = require('@ocap/state/lib/states/account');
-const FsTable = require('./base');
-
-class AccountTable extends FsTable {
-  async _get(address, { traceMigration = true } = {}) {
-    const current = await super._get(ensureChecksumAddress(address));
-    if (current && traceMigration && Array.isArray(current.migratedTo) && current.migratedTo.length) {
-      return this._get(current.migratedTo[0]);
-    }
-
-    return current;
-  }
-
-  _create(key, attrs = {}, ctx = {}) {
-    const address = ensureChecksumAddress(key);
-    return super._create(address, { ...attrs, address }, ctx);
-  }
-}
-
-module.exports = AccountTable;

package/lib/table/balance.js

@@ -1,41 +0,0 @@
-const FsTable = require('./base');
-
-class BalanceTable extends FsTable {
-  async getBalance(address) {
-    const tokens = await this.collection.find({ address });
-
-    return (tokens || []).reduce((acc, token) => {
-      acc[token.tokenAddress] = token.balance;
-      return acc;
-    }, {});
-  }
-
-  async updateBalance({ address, tokens, context = {} }, ctx) {
-    if (!Object.keys(tokens).length) return {};
-
-    const tokenBalances = await this.getBalance(address);
-    const updatedTokens = Object.keys(tokens)
-      .filter(
-        (token) => (tokenBalances[token] && tokenBalances[token] !== '0') || (tokens[token] && tokens[token] !== '0')
-      )
-      .filter((token) => tokenBalances[token] !== tokens[token]);
-
-    await Promise.all(
-      updatedTokens.map(async (token) => {
-        const key = { address, tokenAddress: token };
-
-        if (tokenBalances[token]) {
-          await this.update(key, { ...key, balance: tokens[token], context }, ctx);
-        } else {
-          await this.create(key, { ...key, balance: tokens[token], context }, ctx);
-        }
-
-        tokenBalances[token] = tokens[token];
-      })
-    );
-
-    return tokens;
-  }
-}
-
-module.exports = BalanceTable;

package/lib/table/base.js

@@ -1,150 +0,0 @@
-const path = require('node:path');
-const omit = require('lodash/omit');
-const { StateDBTable } = require('@ocap/statedb');
-const Lokijs = require('lokijs');
-const FsAdapter = require('lokijs/src/loki-fs-structured-adapter');
-
-const debug = require('debug')(require('../../package.json').name);
-
-class FsTable extends StateDBTable {
-  /**
-   * @param {Object} param
-   * @param {string} param.name db name
-   * @param {string|string[]} param.uniqIndex primary keys
-   * @param {string} param.dataDir data directory for db
-   * @param {boolean} param.syncBalance sync balance table when create / update / get
-   * @param {BalanceTable} param.balanceTable balance table
-   */
-  constructor({ name, dataDir, uniqIndex, balanceTable, syncBalance = false }) {
-    super(uniqIndex);
-
-    this.name = name;
-    this.dataDir = dataDir;
-    this.uniqIndex = uniqIndex;
-    this.collection = null;
-    this.balanceTable = balanceTable;
-    this.syncBalance = syncBalance;
-
-    if (this.syncBalance && !this.balanceTable) {
-      throw new Error('balanceTable is required when syncBalance is true');
-    }
-
-    const adapter = new FsAdapter();
-    const db = new Lokijs(path.join(dataDir, `${name}.db`), {
-      adapter,
-      autoload: true,
-      autosave: true,
-      autosaveInterval: 1000,
-      autoloadCallback: () => {
-        this.collection = db.getCollection(name);
-
-        if (this.collection === null) {
-          this.collection = db.addCollection(name, { unique: [this.primaryKey], clone: true });
-        }
-
-        this.markReady();
-      },
-    });
-  }
-
-  async _create(key, attrs) {
-    const id = this.generatePrimaryKey(key);
-    // Don't call this._get here cause _get may be overwritten
-    const doc = await FsTable.prototype._get.call(this, id);
-    if (doc) {
-      throw new Error(`${this.name} already exists: ${key}`);
-    }
-
-    debug(`insert ${this.name}`, attrs);
-
-    const insertAttrs = { ...attrs };
-    // insert without tokens cause we've migrate token to balance table
-    if (this.syncBalance) {
-      delete insertAttrs.tokens;
-    }
-
-    const result = await this.collection.insert({ [this.primaryKey]: id, ...insertAttrs });
-
-    if (this.syncBalance && attrs.tokens) {
-      debug(`update balance for ${this.name}`, attrs);
-
-      result.tokens = await this.balanceTable.updateBalance({
-        address: attrs.address,
-        tokens: attrs.tokens,
-        context: attrs.context,
-      });
-    }
-
-    return result;
-  }
-
-  async _get(key) {
-    if (!key) return null;
-
-    const id = this.generatePrimaryKey(key);
-    const result = await this.collection.by(this.primaryKey, id);
-
-    if (result && this.syncBalance) {
-      const balance = await this.balanceTable.getBalance(result.address);
-      result.tokens = { ...(result.tokens || {}), ...balance };
-    }
-
-    return result;
-  }
-
-  _history() {
-    return [];
-  }
-
-  async _update(key, updates) {
-    const id = this.generatePrimaryKey(key);
-    // Don't call this._get here cause _get may be overwritten
-    const doc = await FsTable.prototype._get.call(this, id);
-    if (!doc) {
-      throw new Error(`${this.name} does not exists: ${key}`);
-    }
-
-    Object.assign(doc, updates);
-
-    const updateAttrs = { ...doc };
-    // insert without tokens cause we've migrate token to balance table
-    if (this.syncBalance) {
-      delete updateAttrs.tokens;
-    }
-
-    await this.collection.update(updateAttrs);
-
-    if (this.syncBalance && doc.tokens) {
-      debug(`update balance for ${this.name}`, doc);
-
-      doc.tokens = await this.balanceTable.updateBalance({
-        address: doc.address,
-        tokens: doc.tokens,
-        context: doc.context,
-      });
-    }
-
-    return doc;
-  }
-
-  updateOrCreate(exist, state, ctx) {
-    const id = this.generatePrimaryKey(state);
-    const attrs = omit(state, this.primaryKey);
-
-    if (!id) {
-      throw new Error('Cannot update or create without uniq index');
-    }
-
-    if (exist) {
-      return this.update(id, attrs, ctx);
-    }
-
-    return this.create(id, attrs, ctx);
-  }
-
-  _reset() {
-    this.collection.removeWhere({});
-  }
-}
-
-module.exports = FsTable;