@ocap/gql 1.28.8 → 1.29.0

package/esm/index.d.mts

@@ -0,0 +1,76 @@
+import { Server } from "node:http";
+import { GraphQLError } from "graphql";
+import * as http0 from "http";
+import { IResolver, IResolverContext, TIndexedAccountState, TIndexedAssetState, TIndexedDelegationState, TIndexedFactoryState, TIndexedRollupBlock, TIndexedRollupState, TIndexedStakeState, TIndexedTokenState, TIndexedTransaction, TPageInfo } from "@ocap/types";
+import { Express } from "express";
+
+//#region src/index.d.ts
+interface ResolverResult {
+  paging?: TPageInfo;
+  [key: string]: any;
+}
+interface WrapResolverResult {
+  code: string;
+  page: TPageInfo | Record<string, never> | null;
+  [key: string]: any;
+}
+declare const wrapResolver: (_name: string, keys: string | string[], callback: () => Promise<ResolverResult | null> | ResolverResult | null | string) => Promise<WrapResolverResult>;
+interface RequestContext {
+  headers?: Record<string, string>;
+  ip?: string;
+  _remoteAddress?: string;
+  connection?: {
+    remoteAddress?: string;
+  };
+}
+declare const formatContext: (ctx?: RequestContext) => IResolverContext;
+type Resolver = IResolver;
+type ResolverFn = (args: unknown, ctx: unknown) => Promise<WrapResolverResult>;
+declare const createResolvers: (resolver: Resolver) => Record<string, ResolverFn>;
+interface HttpHandlerOptions {
+  resolver?: IResolver;
+  onError?: (err: GraphQLError) => void;
+  graphiql?: boolean;
+}
+declare const createHttpHandler: ({
+  resolver,
+  onError,
+  graphiql
+}: HttpHandlerOptions) => (request: http0.IncomingMessage & {
+  url: string;
+}, response: http0.ServerResponse & {
+  json?: (data: unknown) => void;
+}) => Promise<void>;
+/**
+ * IndexDB table with event subscription for WebSocket broadcasts
+ * Generic type T represents the indexed state type for the table
+ */
+interface IndexdbTable<T = unknown> {
+  on: (event: string, callback: (data: T) => void) => void;
+}
+/**
+ * IndexDB interface for WebSocket event broadcasting
+ * Uses specific indexed state types from @ocap/types
+ */
+interface Indexdb {
+  account: IndexdbTable<TIndexedAccountState>;
+  asset: IndexdbTable<TIndexedAssetState>;
+  delegation: IndexdbTable<TIndexedDelegationState>;
+  rollup: IndexdbTable<TIndexedRollupState>;
+  stake: IndexdbTable<TIndexedStakeState>;
+  tx: IndexdbTable<TIndexedTransaction>;
+  token: IndexdbTable<TIndexedTokenState>;
+  rollupBlock: IndexdbTable<TIndexedRollupBlock>;
+  factory: IndexdbTable<TIndexedFactoryState>;
+  [key: string]: IndexdbTable;
+}
+interface SocketHandlerOptions {
+  app: Express;
+  indexdb: Indexdb;
+}
+declare const createSocketHandler: ({
+  app,
+  indexdb
+}: SocketHandlerOptions) => Server;
+//#endregion
+export { type Resolver, createHttpHandler, createResolvers, createSocketHandler, formatContext, wrapResolver };

package/esm/index.mjs

@@ -0,0 +1,254 @@
+import createWebsocketServer from "./ws.mjs";
+import { createServer } from "node:http";
+import schemaSource from "@ocap/schema";
+import { graphqlHTTP } from "express-graphql";
+import { buildSchema } from "graphql";
+import get from "lodash/get.js";
+
+//#region src/index.ts
+const wrapResolver = async (_name, keys, callback) => {
+	const result = await callback();
+	const resultsMap = {};
+	if (Array.isArray(keys)) keys.forEach((key) => {
+		resultsMap[key] = result[key];
+	});
+	else resultsMap[keys] = result;
+	return {
+		code: "OK",
+		page: result ? result.paging || {} : null,
+		...resultsMap
+	};
+};
+const formatContext = (ctx = {}) => {
+	return {
+		featureSwitch: {},
+		gasStakeHeaders: {
+			token: get(ctx, "headers[x-gas-payer-sig]", ""),
+			pk: get(ctx, "headers[x-gas-payer-pk]", "")
+		},
+		request: {
+			userAgent: get(ctx, "headers.user-agent"),
+			ip: get(ctx, "headers.x-real-ip") || ctx.ip || ctx._remoteAddress || ctx.connection?.remoteAddress || "-",
+			id: get(ctx, "headers[x-request-id]") || get(ctx, "headers[X-Request-ID]") || "-"
+		}
+	};
+};
+const resolvers = [
+	{
+		fn: "sendTx",
+		dataKey: "hash"
+	},
+	{
+		fn: "subscribe",
+		dataKey: "value"
+	},
+	{
+		fn: "unsubscribe",
+		dataKey: "result"
+	},
+	{
+		fn: "getAccountState",
+		dataKey: "state"
+	},
+	{
+		fn: "getAssetState",
+		dataKey: "state"
+	},
+	{
+		fn: "getFactoryState",
+		dataKey: "state"
+	},
+	{
+		fn: "getDelegateState",
+		dataKey: "state"
+	},
+	{
+		fn: "getTokenState",
+		dataKey: "state"
+	},
+	{
+		fn: "getForgeState",
+		dataKey: "state"
+	},
+	{
+		fn: "getStakeState",
+		dataKey: "state"
+	},
+	{
+		fn: "getEvidenceState",
+		dataKey: "state"
+	},
+	{
+		fn: "getRollupState",
+		dataKey: "state"
+	},
+	{
+		fn: "getRollupBlock",
+		dataKey: "block"
+	},
+	{
+		fn: "getTokenFactoryState",
+		dataKey: "state"
+	},
+	{
+		fn: "getAccountTokens",
+		dataKey: "tokens"
+	},
+	{
+		fn: "getBlock",
+		dataKey: "block"
+	},
+	{
+		fn: "getBlocks",
+		dataKey: "blocks"
+	},
+	{
+		fn: "getChainInfo",
+		dataKey: "info"
+	},
+	{
+		fn: "getConfig",
+		dataKey: "config"
+	},
+	{
+		fn: "getForgeStats",
+		dataKey: "forgeStats"
+	},
+	{
+		fn: "getNetInfo",
+		dataKey: "netInfo"
+	},
+	{
+		fn: "getNodeInfo",
+		dataKey: "info"
+	},
+	{
+		fn: "getTx",
+		dataKey: "info"
+	},
+	{
+		fn: "getUnconfirmedTxs",
+		dataKey: "unconfirmedTxs"
+	},
+	{
+		fn: "getValidatorsInfo",
+		dataKey: "validatorsInfo"
+	},
+	{
+		fn: "getTokenDistribution",
+		dataKey: "data"
+	},
+	{
+		fn: "listTransactions",
+		dataKey: ["transactions"]
+	},
+	{
+		fn: "listAssets",
+		dataKey: ["assets", "account"]
+	},
+	{
+		fn: "listAssetTransactions",
+		dataKey: ["transactions"]
+	},
+	{
+		fn: "listFactories",
+		dataKey: ["factories"]
+	},
+	{
+		fn: "listTokens",
+		dataKey: ["tokens"]
+	},
+	{
+		fn: "listTokenFactories",
+		dataKey: ["tokenFactories"]
+	},
+	{
+		fn: "listTopAccounts",
+		dataKey: ["accounts"]
+	},
+	{
+		fn: "listBlocks",
+		dataKey: ["blocks"]
+	},
+	{
+		fn: "listStakes",
+		dataKey: ["stakes"]
+	},
+	{
+		fn: "listRollups",
+		dataKey: ["rollups"]
+	},
+	{
+		fn: "listRollupBlocks",
+		dataKey: ["blocks"]
+	},
+	{
+		fn: "listRollupValidators",
+		dataKey: ["validators"]
+	},
+	{
+		fn: "listDelegations",
+		dataKey: ["delegations"]
+	},
+	{
+		fn: "listTokenFlows",
+		dataKey: "data"
+	},
+	{
+		fn: "verifyAccountRisk",
+		dataKey: "data"
+	},
+	{
+		fn: "search",
+		dataKey: ["results"]
+	},
+	{
+		fn: "estimateGas",
+		dataKey: ["estimate"]
+	}
+];
+const createResolvers = (resolver) => resolvers.reduce((acc, { fn, dataKey }) => {
+	acc[fn] = (args, ctx) => wrapResolver(fn, dataKey, () => {
+		const method = resolver[fn];
+		if (typeof method === "function") return method.call(resolver, args, formatContext(ctx));
+		return null;
+	});
+	return acc;
+}, {});
+const defaultErrorHandler = (err) => {
+	if (process.env.NODE_ENV !== "test") console.error("GraphQLError", err.originalError || err);
+};
+const MAX_BATCH_SIZE = 40;
+const createHttpHandler = ({ resolver = {}, onError = defaultErrorHandler, graphiql = true }) => graphqlHTTP({
+	schema: buildSchema(schemaSource),
+	rootValue: createResolvers(resolver),
+	graphiql,
+	customValidateFn: (_schema, query) => {
+		if (query.definitions.map((x) => {
+			return (get(x, "selectionSet.selections") || []).map((y) => get(y, "name.value")).filter((name) => typeof name === "string");
+		}).reduce((arr, names) => {
+			arr.push(...names);
+			return arr;
+		}, []).length > MAX_BATCH_SIZE) throw new Error(`Batch query size exceeded allowed maximum batch size of ${MAX_BATCH_SIZE}`);
+		return true;
+	},
+	customFormatErrorFn: (err) => {
+		onError(err);
+		const isProd = process.env.NODE_ENV === "production";
+		return {
+			code: get(err, "originalError.code", "INTERNAL"),
+			message: err.message,
+			locations: err.locations || [],
+			stack: isProd ? [] : get(err, "originalError.stack", "").split("\n"),
+			path: err.path
+		};
+	}
+});
+const createSocketHandler = ({ app, indexdb }) => {
+	const httpServer = createServer(app);
+	createWebsocketServer({ indexdb }).attach(httpServer);
+	return httpServer;
+};
+
+//#endregion
+export { createHttpHandler, createResolvers, createSocketHandler, formatContext, wrapResolver };

package/esm/ws.d.mts

@@ -0,0 +1,37 @@
+import { Server } from "node:http";
+import { TIndexedAccountState, TIndexedAssetState, TIndexedDelegationState, TIndexedFactoryState, TIndexedRollupBlock, TIndexedRollupState, TIndexedStakeState, TIndexedTokenState, TIndexedTransaction } from "@ocap/types";
+
+//#region src/ws.d.ts
+
+/**
+ * IndexDB table with event subscription for WebSocket broadcasts
+ */
+interface IndexdbTable<T = unknown> {
+  on: (event: string, callback: (data: T) => void) => void;
+}
+/**
+ * IndexDB interface for WebSocket event broadcasting
+ */
+interface Indexdb {
+  account: IndexdbTable<TIndexedAccountState>;
+  asset: IndexdbTable<TIndexedAssetState>;
+  delegation: IndexdbTable<TIndexedDelegationState>;
+  rollup: IndexdbTable<TIndexedRollupState>;
+  stake: IndexdbTable<TIndexedStakeState>;
+  tx: IndexdbTable<TIndexedTransaction>;
+  token: IndexdbTable<TIndexedTokenState>;
+  rollupBlock: IndexdbTable<TIndexedRollupBlock>;
+  factory: IndexdbTable<TIndexedFactoryState>;
+  [key: string]: IndexdbTable;
+}
+interface WsServerInstance {
+  broadcast: (topic: string, data: unknown) => void;
+  attach: (server: Server) => void;
+}
+declare function createWebsocketServer({
+  indexdb
+}: {
+  indexdb: Indexdb;
+}): WsServerInstance;
+//#endregion
+export { createWebsocketServer as default };

package/esm/ws.mjs

@@ -0,0 +1,41 @@
+import { WsServer } from "@arcblock/ws";
+
+//#region src/ws.ts
+function createWebsocketServer({ indexdb }) {
+	const wsServer = new WsServer({});
+	const mutableTables = [
+		"account",
+		"asset",
+		"delegation",
+		"rollup",
+		"stake"
+	];
+	const appendOnlyTables = [
+		"tx",
+		"token",
+		"rollupBlock",
+		"factory"
+	];
+	const map = {
+		insert: "create",
+		update: "update"
+	};
+	mutableTables.forEach((table) => {
+		["insert", "update"].forEach((action) => {
+			indexdb[table].on(action, (data) => wsServer.broadcast([table, map[action]].join("."), data));
+		});
+	});
+	appendOnlyTables.forEach((table) => {
+		["insert"].forEach((action) => {
+			indexdb[table].on(action, (data) => wsServer.broadcast([table, map[action]].join("."), data));
+		});
+	});
+	indexdb.tx.on("insert", (tx) => {
+		const typeUrl = (tx.tx?.itxJson)?.type_url?.split(":").pop();
+		if (typeUrl) wsServer.broadcast(`tx.${typeUrl}`, tx);
+	});
+	return wsServer;
+}
+
+//#endregion
+export { createWebsocketServer as default };

package/lib/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#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 __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.__toESM = __toESM;

package/lib/index.cjs

@@ -0,0 +1,261 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_ws = require('./ws.cjs');
+let node_http = require("node:http");
+let _ocap_schema = require("@ocap/schema");
+_ocap_schema = require_rolldown_runtime.__toESM(_ocap_schema);
+let express_graphql = require("express-graphql");
+let graphql = require("graphql");
+let lodash_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+
+//#region src/index.ts
+const wrapResolver = async (_name, keys, callback) => {
+	const result = await callback();
+	const resultsMap = {};
+	if (Array.isArray(keys)) keys.forEach((key) => {
+		resultsMap[key] = result[key];
+	});
+	else resultsMap[keys] = result;
+	return {
+		code: "OK",
+		page: result ? result.paging || {} : null,
+		...resultsMap
+	};
+};
+const formatContext = (ctx = {}) => {
+	return {
+		featureSwitch: {},
+		gasStakeHeaders: {
+			token: (0, lodash_get.default)(ctx, "headers[x-gas-payer-sig]", ""),
+			pk: (0, lodash_get.default)(ctx, "headers[x-gas-payer-pk]", "")
+		},
+		request: {
+			userAgent: (0, lodash_get.default)(ctx, "headers.user-agent"),
+			ip: (0, lodash_get.default)(ctx, "headers.x-real-ip") || ctx.ip || ctx._remoteAddress || ctx.connection?.remoteAddress || "-",
+			id: (0, lodash_get.default)(ctx, "headers[x-request-id]") || (0, lodash_get.default)(ctx, "headers[X-Request-ID]") || "-"
+		}
+	};
+};
+const resolvers = [
+	{
+		fn: "sendTx",
+		dataKey: "hash"
+	},
+	{
+		fn: "subscribe",
+		dataKey: "value"
+	},
+	{
+		fn: "unsubscribe",
+		dataKey: "result"
+	},
+	{
+		fn: "getAccountState",
+		dataKey: "state"
+	},
+	{
+		fn: "getAssetState",
+		dataKey: "state"
+	},
+	{
+		fn: "getFactoryState",
+		dataKey: "state"
+	},
+	{
+		fn: "getDelegateState",
+		dataKey: "state"
+	},
+	{
+		fn: "getTokenState",
+		dataKey: "state"
+	},
+	{
+		fn: "getForgeState",
+		dataKey: "state"
+	},
+	{
+		fn: "getStakeState",
+		dataKey: "state"
+	},
+	{
+		fn: "getEvidenceState",
+		dataKey: "state"
+	},
+	{
+		fn: "getRollupState",
+		dataKey: "state"
+	},
+	{
+		fn: "getRollupBlock",
+		dataKey: "block"
+	},
+	{
+		fn: "getTokenFactoryState",
+		dataKey: "state"
+	},
+	{
+		fn: "getAccountTokens",
+		dataKey: "tokens"
+	},
+	{
+		fn: "getBlock",
+		dataKey: "block"
+	},
+	{
+		fn: "getBlocks",
+		dataKey: "blocks"
+	},
+	{
+		fn: "getChainInfo",
+		dataKey: "info"
+	},
+	{
+		fn: "getConfig",
+		dataKey: "config"
+	},
+	{
+		fn: "getForgeStats",
+		dataKey: "forgeStats"
+	},
+	{
+		fn: "getNetInfo",
+		dataKey: "netInfo"
+	},
+	{
+		fn: "getNodeInfo",
+		dataKey: "info"
+	},
+	{
+		fn: "getTx",
+		dataKey: "info"
+	},
+	{
+		fn: "getUnconfirmedTxs",
+		dataKey: "unconfirmedTxs"
+	},
+	{
+		fn: "getValidatorsInfo",
+		dataKey: "validatorsInfo"
+	},
+	{
+		fn: "getTokenDistribution",
+		dataKey: "data"
+	},
+	{
+		fn: "listTransactions",
+		dataKey: ["transactions"]
+	},
+	{
+		fn: "listAssets",
+		dataKey: ["assets", "account"]
+	},
+	{
+		fn: "listAssetTransactions",
+		dataKey: ["transactions"]
+	},
+	{
+		fn: "listFactories",
+		dataKey: ["factories"]
+	},
+	{
+		fn: "listTokens",
+		dataKey: ["tokens"]
+	},
+	{
+		fn: "listTokenFactories",
+		dataKey: ["tokenFactories"]
+	},
+	{
+		fn: "listTopAccounts",
+		dataKey: ["accounts"]
+	},
+	{
+		fn: "listBlocks",
+		dataKey: ["blocks"]
+	},
+	{
+		fn: "listStakes",
+		dataKey: ["stakes"]
+	},
+	{
+		fn: "listRollups",
+		dataKey: ["rollups"]
+	},
+	{
+		fn: "listRollupBlocks",
+		dataKey: ["blocks"]
+	},
+	{
+		fn: "listRollupValidators",
+		dataKey: ["validators"]
+	},
+	{
+		fn: "listDelegations",
+		dataKey: ["delegations"]
+	},
+	{
+		fn: "listTokenFlows",
+		dataKey: "data"
+	},
+	{
+		fn: "verifyAccountRisk",
+		dataKey: "data"
+	},
+	{
+		fn: "search",
+		dataKey: ["results"]
+	},
+	{
+		fn: "estimateGas",
+		dataKey: ["estimate"]
+	}
+];
+const createResolvers = (resolver) => resolvers.reduce((acc, { fn, dataKey }) => {
+	acc[fn] = (args, ctx) => wrapResolver(fn, dataKey, () => {
+		const method = resolver[fn];
+		if (typeof method === "function") return method.call(resolver, args, formatContext(ctx));
+		return null;
+	});
+	return acc;
+}, {});
+const defaultErrorHandler = (err) => {
+	if (process.env.NODE_ENV !== "test") console.error("GraphQLError", err.originalError || err);
+};
+const MAX_BATCH_SIZE = 40;
+const createHttpHandler = ({ resolver = {}, onError = defaultErrorHandler, graphiql = true }) => (0, express_graphql.graphqlHTTP)({
+	schema: (0, graphql.buildSchema)(_ocap_schema.default),
+	rootValue: createResolvers(resolver),
+	graphiql,
+	customValidateFn: (_schema, query) => {
+		if (query.definitions.map((x) => {
+			return ((0, lodash_get.default)(x, "selectionSet.selections") || []).map((y) => (0, lodash_get.default)(y, "name.value")).filter((name) => typeof name === "string");
+		}).reduce((arr, names) => {
+			arr.push(...names);
+			return arr;
+		}, []).length > MAX_BATCH_SIZE) throw new Error(`Batch query size exceeded allowed maximum batch size of ${MAX_BATCH_SIZE}`);
+		return true;
+	},
+	customFormatErrorFn: (err) => {
+		onError(err);
+		const isProd = process.env.NODE_ENV === "production";
+		return {
+			code: (0, lodash_get.default)(err, "originalError.code", "INTERNAL"),
+			message: err.message,
+			locations: err.locations || [],
+			stack: isProd ? [] : (0, lodash_get.default)(err, "originalError.stack", "").split("\n"),
+			path: err.path
+		};
+	}
+});
+const createSocketHandler = ({ app, indexdb }) => {
+	const httpServer = (0, node_http.createServer)(app);
+	require_ws.default({ indexdb }).attach(httpServer);
+	return httpServer;
+};
+
+//#endregion
+exports.createHttpHandler = createHttpHandler;
+exports.createResolvers = createResolvers;
+exports.createSocketHandler = createSocketHandler;
+exports.formatContext = formatContext;
+exports.wrapResolver = wrapResolver;

package/lib/index.d.cts

@@ -0,0 +1,76 @@
+import * as http0 from "http";
+import { Server } from "node:http";
+import { IResolver, IResolverContext, TIndexedAccountState, TIndexedAssetState, TIndexedDelegationState, TIndexedFactoryState, TIndexedRollupBlock, TIndexedRollupState, TIndexedStakeState, TIndexedTokenState, TIndexedTransaction, TPageInfo } from "@ocap/types";
+import { Express } from "express";
+import { GraphQLError } from "graphql";
+
+//#region src/index.d.ts
+interface ResolverResult {
+  paging?: TPageInfo;
+  [key: string]: any;
+}
+interface WrapResolverResult {
+  code: string;
+  page: TPageInfo | Record<string, never> | null;
+  [key: string]: any;
+}
+declare const wrapResolver: (_name: string, keys: string | string[], callback: () => Promise<ResolverResult | null> | ResolverResult | null | string) => Promise<WrapResolverResult>;
+interface RequestContext {
+  headers?: Record<string, string>;
+  ip?: string;
+  _remoteAddress?: string;
+  connection?: {
+    remoteAddress?: string;
+  };
+}
+declare const formatContext: (ctx?: RequestContext) => IResolverContext;
+type Resolver = IResolver;
+type ResolverFn = (args: unknown, ctx: unknown) => Promise<WrapResolverResult>;
+declare const createResolvers: (resolver: Resolver) => Record<string, ResolverFn>;
+interface HttpHandlerOptions {
+  resolver?: IResolver;
+  onError?: (err: GraphQLError) => void;
+  graphiql?: boolean;
+}
+declare const createHttpHandler: ({
+  resolver,
+  onError,
+  graphiql
+}: HttpHandlerOptions) => (request: http0.IncomingMessage & {
+  url: string;
+}, response: http0.ServerResponse & {
+  json?: (data: unknown) => void;
+}) => Promise<void>;
+/**
+ * IndexDB table with event subscription for WebSocket broadcasts
+ * Generic type T represents the indexed state type for the table
+ */
+interface IndexdbTable<T = unknown> {
+  on: (event: string, callback: (data: T) => void) => void;
+}
+/**
+ * IndexDB interface for WebSocket event broadcasting
+ * Uses specific indexed state types from @ocap/types
+ */
+interface Indexdb {
+  account: IndexdbTable<TIndexedAccountState>;
+  asset: IndexdbTable<TIndexedAssetState>;
+  delegation: IndexdbTable<TIndexedDelegationState>;
+  rollup: IndexdbTable<TIndexedRollupState>;
+  stake: IndexdbTable<TIndexedStakeState>;
+  tx: IndexdbTable<TIndexedTransaction>;
+  token: IndexdbTable<TIndexedTokenState>;
+  rollupBlock: IndexdbTable<TIndexedRollupBlock>;
+  factory: IndexdbTable<TIndexedFactoryState>;
+  [key: string]: IndexdbTable;
+}
+interface SocketHandlerOptions {
+  app: Express;
+  indexdb: Indexdb;
+}
+declare const createSocketHandler: ({
+  app,
+  indexdb
+}: SocketHandlerOptions) => Server;
+//#endregion
+export { type Resolver, createHttpHandler, createResolvers, createSocketHandler, formatContext, wrapResolver };

package/lib/ws.cjs

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _arcblock_ws = require("@arcblock/ws");
+
+//#region src/ws.ts
+function createWebsocketServer({ indexdb }) {
+	const wsServer = new _arcblock_ws.WsServer({});
+	const mutableTables = [
+		"account",
+		"asset",
+		"delegation",
+		"rollup",
+		"stake"
+	];
+	const appendOnlyTables = [
+		"tx",
+		"token",
+		"rollupBlock",
+		"factory"
+	];
+	const map = {
+		insert: "create",
+		update: "update"
+	};
+	mutableTables.forEach((table) => {
+		["insert", "update"].forEach((action) => {
+			indexdb[table].on(action, (data) => wsServer.broadcast([table, map[action]].join("."), data));
+		});
+	});
+	appendOnlyTables.forEach((table) => {
+		["insert"].forEach((action) => {
+			indexdb[table].on(action, (data) => wsServer.broadcast([table, map[action]].join("."), data));
+		});
+	});
+	indexdb.tx.on("insert", (tx) => {
+		const typeUrl = (tx.tx?.itxJson)?.type_url?.split(":").pop();
+		if (typeUrl) wsServer.broadcast(`tx.${typeUrl}`, tx);
+	});
+	return wsServer;
+}
+
+//#endregion
+exports.default = createWebsocketServer;

package/lib/ws.d.cts

@@ -0,0 +1,37 @@
+import { Server } from "node:http";
+import { TIndexedAccountState, TIndexedAssetState, TIndexedDelegationState, TIndexedFactoryState, TIndexedRollupBlock, TIndexedRollupState, TIndexedStakeState, TIndexedTokenState, TIndexedTransaction } from "@ocap/types";
+
+//#region src/ws.d.ts
+
+/**
+ * IndexDB table with event subscription for WebSocket broadcasts
+ */
+interface IndexdbTable<T = unknown> {
+  on: (event: string, callback: (data: T) => void) => void;
+}
+/**
+ * IndexDB interface for WebSocket event broadcasting
+ */
+interface Indexdb {
+  account: IndexdbTable<TIndexedAccountState>;
+  asset: IndexdbTable<TIndexedAssetState>;
+  delegation: IndexdbTable<TIndexedDelegationState>;
+  rollup: IndexdbTable<TIndexedRollupState>;
+  stake: IndexdbTable<TIndexedStakeState>;
+  tx: IndexdbTable<TIndexedTransaction>;
+  token: IndexdbTable<TIndexedTokenState>;
+  rollupBlock: IndexdbTable<TIndexedRollupBlock>;
+  factory: IndexdbTable<TIndexedFactoryState>;
+  [key: string]: IndexdbTable;
+}
+interface WsServerInstance {
+  broadcast: (topic: string, data: unknown) => void;
+  attach: (server: Server) => void;
+}
+declare function createWebsocketServer({
+  indexdb
+}: {
+  indexdb: Indexdb;
+}): WsServerInstance;
+//#endregion
+export { createWebsocketServer as default };

package/package.json

@@ -3,13 +3,36 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.28.8",
+  "version": "1.29.0",
   "description": "Resolver middleware for ocap adapters",
-  "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"
   ],
   "scripts": {
+    "build": "tsdown",
+    "prebuild": "rm -rf lib esm",
     "lint": "biome check",
     "lint:fix": "biome check --write",
     "test": "bun test",
@@ -22,14 +45,16 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@arcblock/ws": "1.28.8",
-    "@ocap/schema": "1.28.8",
-    "debug": "^4.3.6",
+    "@arcblock/ws": "1.29.0",
+    "@ocap/schema": "1.29.0",
+    "debug": "^4.4.3",
     "express-graphql": "^0.12.0",
     "graphql": "16.5.0",
-    "lodash": "^4.17.21"
+    "lodash": "^4.17.23"
   },
   "devDependencies": {
-    "express": "^4.19.2"
+    "@types/express": "^4.17.23",
+    "@types/lodash": "^4.17.13",
+    "express": "^4.22.1"
   }
 }

package/lib/index.js

@@ -1,167 +0,0 @@
-const get = require('lodash/get');
-const { createServer } = require('node:http');
-const { graphqlHTTP } = require('express-graphql');
-const { buildSchema } = require('graphql');
-const schemaSource = require('@ocap/schema');
-
-// const debug = require('debug')(require('../package.json').name);
-const createWebSocketServer = require('./ws');
-
-const wrapResolver = async (_name, keys, callback) => {
-  const result = await callback();
-
-  const resultsMap = {};
-  if (Array.isArray(keys)) {
-    keys.forEach((key) => {
-      resultsMap[key] = result[key];
-    });
-  } else {
-    resultsMap[keys] = result;
-  }
-
-  return {
-    code: 'OK',
-    page: result ? result.paging || {} : null,
-    ...resultsMap,
-  };
-};
-
-const formatContext = (ctx = {}) => {
-  const featureSwitch = {};
-  const gasStakeHeaders = {
-    token: get(ctx, 'headers[x-gas-payer-sig]', ''),
-    pk: get(ctx, 'headers[x-gas-payer-pk]', ''),
-  };
-  const request = {
-    userAgent: get(ctx, 'headers.user-agent'),
-    ip: get(ctx, 'headers.x-real-ip') || ctx.ip || ctx._remoteAddress || ctx.connection?.remoteAddress || '-',
-    id: get(ctx, 'headers[x-request-id]') || get(ctx, 'headers[X-Request-ID]') || '-',
-  };
-  return {
-    featureSwitch,
-    gasStakeHeaders,
-    request,
-  };
-};
-
-const resolvers = [
-  { fn: 'sendTx', dataKey: 'hash' },
-
-  { fn: 'subscribe', dataKey: 'value' },
-  { fn: 'unsubscribe', dataKey: 'result' },
-
-  { fn: 'getAccountState', dataKey: 'state' },
-  { fn: 'getAssetState', dataKey: 'state' },
-  { fn: 'getFactoryState', dataKey: 'state' },
-  { fn: 'getDelegateState', dataKey: 'state' },
-  { fn: 'getTokenState', dataKey: 'state' },
-  { fn: 'getForgeState', dataKey: 'state' },
-  { fn: 'getStakeState', dataKey: 'state' },
-  { fn: 'getEvidenceState', dataKey: 'state' },
-  { fn: 'getRollupState', dataKey: 'state' },
-  { fn: 'getRollupBlock', dataKey: 'block' },
-  { fn: 'getTokenFactoryState', dataKey: 'state' },
-
-  { fn: 'getAccountTokens', dataKey: 'tokens' },
-  { fn: 'getBlock', dataKey: 'block' },
-  { fn: 'getBlocks', dataKey: 'blocks' },
-  { fn: 'getChainInfo', dataKey: 'info' },
-  { fn: 'getConfig', dataKey: 'config' },
-  { fn: 'getForgeStats', dataKey: 'forgeStats' },
-  { fn: 'getNetInfo', dataKey: 'netInfo' },
-  { fn: 'getNodeInfo', dataKey: 'info' },
-  { fn: 'getTx', dataKey: 'info' },
-  { fn: 'getUnconfirmedTxs', dataKey: 'unconfirmedTxs' },
-  { fn: 'getValidatorsInfo', dataKey: 'validatorsInfo' },
-  { fn: 'getTokenDistribution', dataKey: 'data' },
-
-  { fn: 'listTransactions', dataKey: ['transactions'] },
-  { fn: 'listAssets', dataKey: ['assets', 'account'] },
-  { fn: 'listAssetTransactions', dataKey: ['transactions'] },
-  { fn: 'listFactories', dataKey: ['factories'] },
-  { fn: 'listTokens', dataKey: ['tokens'] },
-  { fn: 'listTokenFactories', dataKey: ['tokenFactories'] },
-  { fn: 'listTopAccounts', dataKey: ['accounts'] },
-  { fn: 'listBlocks', dataKey: ['blocks'] },
-  { fn: 'listStakes', dataKey: ['stakes'] },
-  { fn: 'listRollups', dataKey: ['rollups'] },
-  { fn: 'listRollupBlocks', dataKey: ['blocks'] },
-  { fn: 'listRollupValidators', dataKey: ['validators'] },
-  { fn: 'listDelegations', dataKey: ['delegations'] },
-  { fn: 'listTokenFlows', dataKey: 'data' },
-  { fn: 'verifyAccountRisk', dataKey: 'data' },
-
-  { fn: 'search', dataKey: ['results'] },
-
-  { fn: 'estimateGas', dataKey: ['estimate'] },
-];
-
-const createResolvers = (resolver) =>
-  resolvers.reduce((acc, { fn, dataKey }) => {
-    acc[fn] = (args, ctx) => wrapResolver(fn, dataKey, () => resolver[fn](args, formatContext(ctx)));
-    return acc;
-  }, {});
-
-const defaultErrorHandler = (err) => {
-  if (process.env.NODE_ENV !== 'test') {
-    console.error('GraphQLError', err.originalError || err);
-  }
-};
-
-const MAX_BATCH_SIZE = 40;
-const createHttpHandler = ({ resolver, onError = defaultErrorHandler, graphiql = true }) =>
-  graphqlHTTP({
-    schema: buildSchema(schemaSource),
-    rootValue: createResolvers(resolver),
-    graphiql,
-    // NOTE: following is required because of following gql query validation issue
-    // https://stackoverflow.com/questions/56695262/graphql-error-fieldsconflict-fields-have-different-list-shapes
-    customValidateFn: (_schema, query) => {
-      const operations = query.definitions
-        .map((x) => {
-          const selections = get(x, 'selectionSet.selections') || [];
-          const names = selections.map((y) => get(y, 'name.value'));
-          return names;
-        })
-        .reduce((arr, names) => {
-          arr.push(...names);
-          return arr;
-        }, []);
-
-      if (operations.length > MAX_BATCH_SIZE) {
-        throw new Error(`Batch query size exceeded allowed maximum batch size of ${MAX_BATCH_SIZE}`);
-      }
-
-      return true;
-    },
-
-    // format custom error code
-    customFormatErrorFn: (err) => {
-      onError(err);
-
-      const isProd = process.env.NODE_ENV === 'production';
-      return {
-        code: get(err, 'originalError.code', 'INTERNAL'),
-        message: err.message,
-        locations: err.locations || [],
-        stack: isProd ? [] : get(err, 'originalError.stack', '').split('\n'),
-        path: err.path,
-      };
-    },
-  });
-
-const createSocketHandler = ({ app, indexdb }) => {
-  const httpServer = createServer(app);
-  const wsServer = createWebSocketServer({ indexdb });
-  wsServer.attach(httpServer);
-
-  return httpServer;
-};
-
-module.exports = {
-  createHttpHandler,
-  createSocketHandler,
-  wrapResolver,
-  createResolvers,
-  formatContext,
-};

package/lib/ws.js

@@ -1,31 +0,0 @@
-const { WsServer } = require('@arcblock/ws');
-
-module.exports = function createWebsocketServer({ indexdb }) {
-  const wsServer = new WsServer({});
-
-  const mutableTables = ['account', 'asset', 'delegation', 'rollup', 'stake'];
-  const appendOnlyTables = ['tx', 'token', 'rollupBlock', 'factory'];
-  const map = { insert: 'create', update: 'update' };
-
-  // For entities that support updating
-  mutableTables.forEach((table) => {
-    ['insert', 'update'].forEach((action) => {
-      indexdb[table].on(action, (data) => wsServer.broadcast([table, map[action]].join('.'), data));
-    });
-  });
-
-  // For entities that are immutable after creation
-  appendOnlyTables.forEach((table) => {
-    ['insert'].forEach((action) => {
-      indexdb[table].on(action, (data) => wsServer.broadcast([table, map[action]].join('.'), data));
-    });
-  });
-
-  // For tx sub topic
-  indexdb.tx.on('insert', (tx) => {
-    const typeUrl = tx.tx.itxJson.type_url.split(':').pop();
-    wsServer.broadcast(`tx.${typeUrl}`, tx);
-  });
-
-  return wsServer;
-};