@0xobelisk/graphql-client 1.2.0-pre.99 → 2.0.0

package/src/client.ts

@@ -11,12 +11,98 @@ import {
   FetchPolicy,
   OperationVariables
 } from '@apollo/client';
+import { BatchHttpLink } from '@apollo/client/link/batch-http';
 import { RetryLink } from '@apollo/client/link/retry';
 import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
 import { getMainDefinition } from '@apollo/client/utilities';
 import { createClient } from 'graphql-ws';
 import pluralize from 'pluralize';
 
+/**
+ * Static field registry for Dubhe system tables.
+ *
+ * These tables are exposed via `store_dubhe_*` views in the graphql-server.
+ * They are NOT in the DApp's dubhe.config schema, so `convertTableFields`
+ * cannot auto-discover their fields. Registering them here means callers
+ * can use `getAllTables('dubheDappMarketplaceFees', ...)` without passing
+ * `fields` explicitly.
+ *
+ * Key: the simplified GraphQL field name (after SimpleNamingPlugin strips
+ *      the `storeDubhe` prefix and removes the `all` prefix).
+ * Value: camelCase GraphQL field names matching the PostGraphile schema.
+ */
+const SYSTEM_TABLE_FIELDS: Record<string, string[]> = {
+  dubheDappMarketplaceFees: [
+    'dappKey',
+    'listingId',
+    'coinType',
+    'totalFee',
+    'treasuryAmount',
+    'dappAmount',
+    'updatedAtCheckpoint',
+    'lastUpdateDigest'
+  ],
+  dubheDappRuntimeState: [
+    'dappKey',
+    'admin',
+    'paused',
+    'settlementMode',
+    'creditPool',
+    'writeFeeShareBps',
+    'lastRuntimeEvent',
+    'lastRuntimeActor',
+    'lastRuntimeAmount',
+    'updatedAtCheckpoint',
+    'lastUpdateDigest'
+  ],
+  dubheDappFeeState: [
+    'entityId',
+    'baseFeePerWrite',
+    'bytesFeePerByte',
+    'freeCredit',
+    'creditPool',
+    'totalSettled',
+    'updatedAtTimestampMs',
+    'lastUpdateDigest'
+  ],
+  dubheDappRevenueState: [
+    'entityId',
+    'dappRevenue',
+    'coinType',
+    'updatedAtTimestampMs',
+    'lastUpdateDigest'
+  ],
+  dubheMarketplaceListings: [
+    'dappKey',
+    'listingId',
+    'seller',
+    'recordType',
+    'price',
+    'coinType',
+    'isFungible',
+    'listedUntil',
+    'status',
+    'updatedAtCheckpoint',
+    'lastUpdateDigest'
+  ],
+  dubheSessions: [
+    'dappKey',
+    'canonical',
+    'sessionWallet',
+    'expiresAt',
+    'active',
+    'updatedAtCheckpoint',
+    'lastUpdateDigest'
+  ],
+  dubheUserStorages: [
+    'dappKey',
+    'canonicalOwner',
+    'userStorageId',
+    'updatedAtCheckpoint',
+    'lastUpdateDigest'
+  ]
+};
+
 import {
   DubheClientConfig,
   Connection,
@@ -32,7 +118,14 @@ import {
   MultiTableSubscriptionConfig,
   MultiTableSubscriptionData,
   ParsedTableInfo,
-  DubheMetadata
+  DubheMetadata,
+  MarketplaceListingRow,
+  DubheSessionRow,
+  DubheUserStorageRow,
+  DubheDappRuntimeStateRow,
+  SceneStorageRow,
+  SceneStorageFieldRow,
+  ObjectStorageRow
 } from './types';
 
 // Convert cache policy type
@@ -53,6 +146,37 @@ function mapCachePolicyToFetchPolicy(cachePolicy: CachePolicy): FetchPolicy {
   }
 }
 
+/**
+ * Build the HTTP transport link.
+ *
+ * When `config.batchRequests` is true, returns a `BatchHttpLink` that collects
+ * queries fired within `batchInterval` ms (default 10 ms) and sends them as a
+ * single POST request. The PostGraphile server already has `enableQueryBatching`
+ * enabled, so no server-side changes are needed.
+ *
+ * Falls back to the standard `createHttpLink` when batching is disabled.
+ */
+function buildHttpLink(config: DubheClientConfig): ApolloLink {
+  const fetchFn = (input: RequestInfo | URL, init?: RequestInit) =>
+    fetch(input, { ...config.fetchOptions, ...(init ?? {}) });
+
+  if (config.batchRequests) {
+    return new BatchHttpLink({
+      uri: config.endpoint,
+      headers: config.headers,
+      fetch: fetchFn,
+      batchInterval: config.batchInterval ?? 10,
+      batchMax: config.batchMax ?? 20
+    });
+  }
+
+  return createHttpLink({
+    uri: config.endpoint,
+    headers: config.headers,
+    fetch: fetchFn
+  });
+}
+
 export class DubheGraphqlClient {
   private apolloClient: ApolloClient<NormalizedCacheObject>;
   private subscriptionClient?: any;
@@ -73,12 +197,8 @@ export class DubheGraphqlClient {
       this.parseTableInfoFromConfig();
     }
 
-    // Create HTTP Link
-    const httpLink = createHttpLink({
-      uri: config.endpoint,
-      headers: config.headers,
-      fetch: (input, init) => fetch(input, { ...config.fetchOptions, ...init })
-    });
+    // Create HTTP link (batched or standard depending on config.batchRequests)
+    const httpLink = buildHttpLink(config);
 
     // Create retry link
     const retryLink = new RetryLink({
@@ -244,12 +364,8 @@ export class DubheGraphqlClient {
         this.subscriptionClient = undefined;
       }
 
-      // Recreate HTTP Link
-      const httpLink = createHttpLink({
-        uri: this.currentConfig.endpoint,
-        headers: this.currentConfig.headers,
-        fetch: (input, init) => fetch(input, { ...this.currentConfig.fetchOptions, ...init })
-      });
+      // Recreate HTTP link (batched or standard depending on config)
+      const httpLink = buildHttpLink(this.currentConfig);
 
       // Recreate retry link with current config
       const retryLink = new RetryLink({
@@ -883,6 +999,480 @@ export class DubheGraphqlClient {
     });
   }
 
+  /**
+   * Query marketplace listings indexed by the Dubhe indexer.
+   * Uses the marketplace_listings PostgreSQL table (exposed as dubheMarketplaceListings in GraphQL).
+   * The record_type field is pre-decoded text ("wheat", "corn", …) and status tracks
+   * active/sold/cancelled directly — no extra RPC calls needed.
+   */
+  async getMarketplaceListings(options?: {
+    dappKey?: string;
+    status?: 'listed' | 'sold' | 'cancelled' | 'expired';
+    recordType?: string;
+    seller?: string;
+    first?: number;
+    after?: string;
+  }): Promise<Connection<MarketplaceListingRow>> {
+    const filter: Record<string, any> = {};
+    if (options?.dappKey) filter.dappKey = { equalTo: options.dappKey };
+    if (options?.status !== undefined) filter.status = { equalTo: options.status };
+    if (options?.recordType) filter.recordType = { equalTo: options.recordType };
+    if (options?.seller) filter.seller = { equalTo: options.seller };
+
+    const query = gql`
+      query GetMarketplaceListings(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheMarketplaceListingFilter
+        $orderBy: [StoreDubheMarketplaceListingsOrderBy!]
+      ) {
+        dubheMarketplaceListings(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              listingId
+              dappKey
+              seller
+              recordType
+              recordDataRaw
+              price
+              coinType
+              isFungible
+              status
+              buyer
+              listedUntil
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : undefined,
+        orderBy: ['CREATED_AT_CHECKPOINT_DESC']
+      },
+      fetchPolicy: 'network-only'
+    });
+
+    if (result.error) throw result.error;
+    return (
+      (result.data as any)?.dubheMarketplaceListings ?? {
+        edges: [],
+        pageInfo: { hasNextPage: false, hasPreviousPage: false },
+        totalCount: 0
+      }
+    );
+  }
+
+  /**
+   * Query session keys indexed by the Dubhe indexer (dubheSessions in GraphQL).
+   */
+  async getDubheSessions(options?: {
+    dappKey?: string;
+    canonical?: string;
+    active?: boolean;
+    first?: number;
+    after?: string;
+  }): Promise<Connection<DubheSessionRow>> {
+    const filter: Record<string, any> = {};
+    if (options?.dappKey) filter.dappKey = { equalTo: options.dappKey };
+    if (options?.canonical) filter.canonical = { equalTo: options.canonical };
+    if (options?.active !== undefined) filter.active = { equalTo: options.active };
+
+    const query = gql`
+      query GetDubheSessions(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheSessionFilter
+        $orderBy: [StoreDubheSessionsOrderBy!]
+      ) {
+        dubheSessions(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              dappKey
+              canonical
+              sessionWallet
+              expiresAt
+              active
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : undefined,
+        orderBy: ['UPDATED_AT_CHECKPOINT_DESC']
+      },
+      fetchPolicy: 'network-only'
+    });
+
+    if (result.error) throw result.error;
+    return (
+      (result.data as any)?.dubheSessions ?? {
+        edges: [],
+        pageInfo: { hasNextPage: false, hasPreviousPage: false },
+        totalCount: 0
+      }
+    );
+  }
+
+  /**
+   * Query user storage registrations indexed by the Dubhe indexer (dubheUserStorages in GraphQL).
+   */
+  async getDubheUserStorages(options?: {
+    dappKey?: string;
+    canonicalOwner?: string;
+    first?: number;
+    after?: string;
+  }): Promise<Connection<DubheUserStorageRow>> {
+    const filter: Record<string, any> = {};
+    if (options?.dappKey) filter.dappKey = { equalTo: options.dappKey };
+    if (options?.canonicalOwner) filter.canonicalOwner = { equalTo: options.canonicalOwner };
+
+    const query = gql`
+      query GetDubheUserStorages(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheUserStorageFilter
+        $orderBy: [StoreDubheUserStoragesOrderBy!]
+      ) {
+        dubheUserStorages(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              dappKey
+              canonicalOwner
+              userStorageId
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : undefined,
+        orderBy: ['CREATED_AT_CHECKPOINT_DESC']
+      },
+      fetchPolicy: 'network-only'
+    });
+
+    if (result.error) throw result.error;
+    return (
+      (result.data as any)?.dubheUserStorages ?? {
+        edges: [],
+        pageInfo: { hasNextPage: false, hasPreviousPage: false },
+        totalCount: 0
+      }
+    );
+  }
+
+  /**
+   * Query SceneStorage system rows indexed by the Dubhe indexer
+   * (scene_storages table, exposed as dubheSceneStorages in GraphQL).
+   * Field values live in the companion scene_storage_fields table —
+   * see getSceneStorageFields.
+   */
+  async getSceneStorages(options?: {
+    dappKey?: string;
+    sceneType?: string;
+    sceneId?: string;
+    isDestroyed?: boolean;
+    first?: number;
+    after?: string;
+  }): Promise<Connection<SceneStorageRow>> {
+    const filter: Record<string, any> = {};
+    if (options?.dappKey) filter.dappKey = { equalTo: options.dappKey };
+    if (options?.sceneType) filter.sceneType = { equalTo: options.sceneType };
+    if (options?.sceneId) filter.sceneId = { equalTo: options.sceneId };
+    if (options?.isDestroyed !== undefined) filter.isDestroyed = { equalTo: options.isDestroyed };
+
+    const query = gql`
+      query GetSceneStorages(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheSceneStorageFilter
+        $orderBy: [StoreDubheSceneStoragesOrderBy!]
+      ) {
+        dubheSceneStorages(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              sceneId
+              dappKey
+              sceneType
+              authorizationKind
+              authorizedPermitId
+              isDestroyed
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : undefined,
+        orderBy: ['UPDATED_AT_CHECKPOINT_DESC']
+      },
+      fetchPolicy: 'network-only'
+    });
+
+    if (result.error) throw result.error;
+    return (
+      (result.data as any)?.dubheSceneStorages ?? {
+        edges: [],
+        pageInfo: { hasNextPage: false, hasPreviousPage: false },
+        totalCount: 0
+      }
+    );
+  }
+
+  /**
+   * Query raw field rows of SceneStorages (scene_storage_fields table,
+   * exposed as dubheSceneStorageFields in GraphQL). Values are hex-encoded
+   * BCS — decode with the decoders exported from this package.
+   */
+  async getSceneStorageFields(options?: {
+    dappKey?: string;
+    sceneIds?: string[];
+    sceneId?: string;
+    fieldName?: string;
+    isDeleted?: boolean;
+    first?: number;
+    after?: string;
+  }): Promise<Connection<SceneStorageFieldRow>> {
+    const filter: Record<string, any> = {};
+    if (options?.dappKey) filter.dappKey = { equalTo: options.dappKey };
+    if (options?.sceneIds && options.sceneIds.length > 0) filter.sceneId = { in: options.sceneIds };
+    if (options?.sceneId) filter.sceneId = { equalTo: options.sceneId };
+    if (options?.fieldName) filter.fieldName = { equalTo: options.fieldName };
+    if (options?.isDeleted !== undefined) filter.isDeleted = { equalTo: options.isDeleted };
+
+    const query = gql`
+      query GetSceneStorageFields(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheSceneStorageFieldFilter
+        $orderBy: [StoreDubheSceneStorageFieldsOrderBy!]
+      ) {
+        dubheSceneStorageFields(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              sceneId
+              dappKey
+              sceneType
+              fieldName
+              fieldValueRaw
+              isDeleted
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 1000,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : undefined,
+        orderBy: ['UPDATED_AT_CHECKPOINT_DESC']
+      },
+      fetchPolicy: 'network-only'
+    });
+
+    if (result.error) throw result.error;
+    return (
+      (result.data as any)?.dubheSceneStorageFields ?? {
+        edges: [],
+        pageInfo: { hasNextPage: false, hasPreviousPage: false },
+        totalCount: 0
+      }
+    );
+  }
+
+  /**
+   * Query ObjectStorage system rows indexed by the Dubhe indexer
+   * (object_storages table, exposed as dubheObjectStorages in GraphQL).
+   */
+  async getObjectStorages(options?: {
+    dappKey?: string;
+    objectType?: string;
+    objectId?: string;
+    isDestroyed?: boolean;
+    first?: number;
+    after?: string;
+  }): Promise<Connection<ObjectStorageRow>> {
+    const filter: Record<string, any> = {};
+    if (options?.dappKey) filter.dappKey = { equalTo: options.dappKey };
+    if (options?.objectType) filter.objectType = { equalTo: options.objectType };
+    if (options?.objectId) filter.objectId = { equalTo: options.objectId };
+    if (options?.isDestroyed !== undefined) filter.isDestroyed = { equalTo: options.isDestroyed };
+
+    const query = gql`
+      query GetObjectStorages(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheObjectStorageFilter
+        $orderBy: [StoreDubheObjectStoragesOrderBy!]
+      ) {
+        dubheObjectStorages(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              objectId
+              dappKey
+              objectType
+              entityIdRaw
+              isDestroyed
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : undefined,
+        orderBy: ['UPDATED_AT_CHECKPOINT_DESC']
+      },
+      fetchPolicy: 'network-only'
+    });
+
+    if (result.error) throw result.error;
+    return (
+      (result.data as any)?.dubheObjectStorages ?? {
+        edges: [],
+        pageInfo: { hasNextPage: false, hasPreviousPage: false },
+        totalCount: 0
+      }
+    );
+  }
+
+  /**
+   * Query DApp runtime state (credit pool, admin, package version, etc.).
+   * Exposed as dubheDappRuntimeStates in GraphQL.
+   */
+  async getDubheDappRuntimeState(dappKey: string): Promise<DubheDappRuntimeStateRow | null> {
+    const query = gql`
+      query GetDubheDappRuntimeState($filter: StoreDubheDappRuntimeStateFilter) {
+        dubheDappRuntimeStates(first: 1, filter: $filter) {
+          edges {
+            node {
+              dappKey
+              admin
+              dappStorageId
+              packageId
+              version
+              creditPool
+              paused
+              settlementMode
+              createdAt
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+
+    const result = await this.apolloClient.query({
+      query,
+      variables: { filter: { dappKey: { equalTo: dappKey } } },
+      fetchPolicy: 'network-only'
+    });
+
+    if (result.error) throw result.error;
+    const edges = (result.data as any)?.dubheDappRuntimeStates?.edges ?? [];
+    return edges[0]?.node ?? null;
+  }
+
   // Improved table name handling methods
   private getFilterTypeName(tableName: string): string {
     // Convert to singular form and apply PascalCase conversion
@@ -1235,12 +1825,24 @@ export class DubheGraphqlClient {
     if (customFields && customFields.length > 0) {
       fields = customFields;
     } else {
-      // Try to get fields from dubhe configuration
-      const autoFields = this.getTableFields(tableName);
-      if (autoFields.length > 0) {
-        fields = autoFields;
+      // 1. Check system table registry first
+      const systemFields = SYSTEM_TABLE_FIELDS[tableName];
+      if (systemFields) {
+        fields = systemFields;
       } else {
-        fields = ['createdAtTimestampMs', 'updatedAtTimestampMs', 'isDeleted', 'lastUpdateDigest'];
+        // 2. Try to get fields from dubhe configuration (DApp store tables)
+        const autoFields = this.getTableFields(tableName);
+        if (autoFields.length > 0) {
+          fields = autoFields;
+        } else {
+          // 3. Generic fallback for store_* tables
+          fields = [
+            'createdAtTimestampMs',
+            'updatedAtTimestampMs',
+            'isDeleted',
+            'lastUpdateDigest'
+          ];
+        }
       }
     }
 
@@ -1248,6 +1850,74 @@ export class DubheGraphqlClient {
 
     return fields.join('\n      ');
   }
+
+  // ── Typed system-table query methods ─────────────────────────────────────
+
+  /** Latest DApp fee state snapshot (credit_pool, total_settled, fee rates). */
+  async getDappFeeState(): Promise<{
+    entityId: string;
+    baseFeePerWrite: string;
+    bytesFeePerByte: string;
+    freeCredit: string;
+    creditPool: string;
+    totalSettled: string;
+    updatedAtTimestampMs: string;
+  } | null> {
+    const result = await this.getAllTables<any>('dubheDappFeeState', { first: 1 }).catch(
+      () => null
+    );
+    return result?.edges?.[0]?.node ?? null;
+  }
+
+  /** Latest DApp revenue balance (USER_PAYS mode collected revenue). */
+  async getDappRevenueState(): Promise<{
+    entityId: string;
+    dappRevenue: string;
+    coinType: string;
+    updatedAtTimestampMs: string;
+  } | null> {
+    const result = await this.getAllTables<any>('dubheDappRevenueState', { first: 1 }).catch(
+      () => null
+    );
+    return result?.edges?.[0]?.node ?? null;
+  }
+
+  /** Latest DApp runtime state (admin, settlement mode, last event). */
+  async getDappRuntimeState(): Promise<{
+    dappKey: string;
+    admin: string;
+    paused: boolean;
+    settlementMode: number;
+    creditPool: string;
+    writeFeeShareBps: number;
+    lastRuntimeEvent: string;
+    lastRuntimeActor: string;
+    lastRuntimeAmount: string;
+  } | null> {
+    const result = await this.getAllTables<any>('dubheDappRuntimeState', { first: 1 }).catch(
+      () => null
+    );
+    return result?.edges?.[0]?.node ?? null;
+  }
+
+  /** Marketplace fee records (one row per listing sold). */
+  async getDappMarketplaceFees(options?: { first?: number; after?: string }): Promise<
+    Connection<{
+      dappKey: string;
+      listingId: string;
+      coinType: string;
+      totalFee: string;
+      treasuryAmount: string;
+      dappAmount: string;
+      updatedAtCheckpoint: string;
+    }>
+  > {
+    return this.getAllTables<any>('dubheDappMarketplaceFees', {
+      first: options?.first ?? 20,
+      after: options?.after,
+      orderBy: [{ field: 'updatedAtCheckpoint', direction: 'DESC' }]
+    });
+  }
 }
 
 // Export convenience function