@secondlayer/sdk 10.6.0 → 11.0.0

package/README.md

@@ -412,7 +412,9 @@ Exported types: `TransactionProof`, `TransactionProofVerifyResult`, `RewardSet`.
 
 Deploy and query app-specific tables.
 
-Subgraphs and webhooks live on the instance API alongside Streams and Index. Everything here except `rows` and the typed `subscribe` calls `/api`, which needs `INSTANCE_TOKEN` once one is configured (init always configures one), loopback included.
+Subgraphs and webhooks live on the instance API alongside Streams and Index. Reads (`rows`, `count`, `aggregate`, typed `findMany`/`count`/`aggregate`, and `subscribe`) all hit the open `/v1` surface — keyless on loopback, `INSTANCE_TOKEN` once the API is bound beyond it. Everything else here (deploy, status, ops) calls `/api`, which needs `INSTANCE_TOKEN` once one is configured (init always configures one), loopback included.
+
+`/v1` paginates by cursor, not offset: `rows`/`count`/`aggregate` take no `offset` param — pass the previous page's `next_cursor` back as `cursor` to resume.
 
 ```typescript
 // List
@@ -421,25 +423,18 @@ const { data } = await sl.subgraphs.list();
 // Get
 const subgraph = await sl.subgraphs.status("my-subgraph");
 
-// Open read (/v1): keyless on loopback; needs the token once the API is bound beyond it
+// Untyped row read (/v1)
 const { rows, next_cursor, tip } = await sl.subgraphs.rows("my-subgraph", "transfers", {
+  sort: "block_height",
   order: "desc",
   limit: 50,
   // cursor: next_cursor — pass back to resume
 });
 
-// Authed control-plane query (/api)
-const page = await sl.subgraphs.queryTable("my-subgraph", "transfers", {
-  sort: "block_height",
-  order: "desc",
-  limit: 50,
+const { count } = await sl.subgraphs.count("my-subgraph", "transfers", {
+  filters: { status: "active" },
 });
 
-const { count } = await sl.subgraphs.queryTableCount(
-  "my-subgraph",
-  "transfers",
-);
-
 const spec = await sl.subgraphs.openapi("my-subgraph");
 const source = await sl.subgraphs.getSource("my-subgraph");
 const gaps = await sl.subgraphs.gaps("my-subgraph");
@@ -455,11 +450,22 @@ system column only when your table declares no column of that name; a declared
 `id` column is always your `id`.
 
 Stream rows live with the typed client — each table exposes `subscribe`
-alongside `findMany`/`count`:
+alongside `findMany`/`count`/`aggregate`:
 
 ```typescript
 const subgraph = sl.subgraphs.typed(myDefinition); // { transfers, ... }
 
+// findMany returns a page, not a bare array — `nextCursor` resumes it.
+// `orderBy` sorts one column only (the /v1 keyset cursor pairs it with `_id`
+// as a tiebreaker); a second key throws.
+const page = await subgraph.transfers.findMany({
+  where: { amount: { gte: "1000000" } },
+  orderBy: { blockHeight: "desc" },
+  limit: 50,
+  // cursor: page.nextCursor — pass back to resume
+});
+// page.rows, page.nextCursor, page.tip
+
 const unsubscribe = subgraph.transfers.subscribe(
   (row) => console.log(row),
   {

package/dist/index.d.ts

@@ -2589,7 +2589,7 @@ declare class Subgraphs extends BaseClient {
 	* pass an apiKey on the client where reads are closed. Resume with the
 	* returned `next_cursor`.
 	*/
-	rows<T = unknown>(name: string, table: string, params?: Omit<SubgraphQueryParams, "offset" | "sort"> & {
+	rows<T = unknown>(name: string, table: string, params?: Omit<SubgraphQueryParams, "offset"> & {
 		cursor?: string;
 	}): Promise<SubgraphRowsEnvelope<T>>;
 	/** Recent reindex/backfill operations for a subgraph, newest first. */
@@ -2611,11 +2611,14 @@ declare class Subgraphs extends BaseClient {
 	bundle(data: {
 		code: string;
 	}): Promise<BundleSubgraphResponse>;
-	queryTable(name: string, table: string, params?: SubgraphQueryParams): Promise<unknown[]>;
-	queryTableCount(name: string, table: string, params?: SubgraphQueryParams): Promise<{
+	/** Open /v1 read: exact row count for a filtered set. Same auth posture as
+	*  {@link rows}. */
+	count(name: string, table: string, params?: Pick<SubgraphQueryParams, "filters">): Promise<{
 		count: number;
 	}>;
-	queryTableAggregate(name: string, table: string, params?: SubgraphAggregateParams): Promise<SubgraphAggregateResponse>;
+	/** Open /v1 read: scalar aggregates over a filtered set. Same auth posture
+	*  as {@link rows}. */
+	aggregate(name: string, table: string, params?: SubgraphAggregateParams): Promise<SubgraphAggregateResponse>;
 	/**
 	* Returns a typed client for a subgraph defined with `defineSubgraph()`.
 	* Row types are inferred from the subgraph's schema literal types.
@@ -2624,8 +2627,9 @@ declare class Subgraphs extends BaseClient {
 	* ```ts
 	* import mySubgraph from './subgraphs/my-token-subgraph'
 	* const client = sl.subgraphs.typed(mySubgraph)
-	* const rows = await client.transfers.findMany({ where: { sender: 'SP...' } })
-	* // rows: InferTableRow<typeof mySubgraph.schema.transfers>[]
+	* const page = await client.transfers.findMany({ where: { sender: 'SP...' } })
+	* // page.rows: InferTableRow<typeof mySubgraph.schema.transfers>[]
+	* // page.nextCursor: string | null — pass back as `cursor` to resume
 	* ```
 	*/
 	typed<T extends {
@@ -2777,7 +2781,7 @@ import { InferSubgraphClient as InferSubgraphClient2 } from "@secondlayer/subgra
 * import { getSubgraph } from '@secondlayer/sdk'
 *
 * const client = getSubgraph(mySubgraph, { apiKey: 'sl_...' })
-* const rows = await client.transfers.findMany({ where: { sender: 'SP...' } })
+* const page = await client.transfers.findMany({ where: { sender: 'SP...' } })
 * ```
 */
 declare function getSubgraph<T extends {

package/dist/index.js

@@ -2317,7 +2317,6 @@ function buildSubgraphQueryString(params) {
     _sort: params.sort,
     _order: params.order,
     _limit: params.limit,
-    _offset: params.offset,
     _fields: params.fields,
     ...params.filters
   });
@@ -2395,15 +2394,11 @@ class Subgraphs extends BaseClient {
   async bundle(data) {
     return this.request("POST", "/api/subgraphs/bundle", data);
   }
-  async queryTable(name, table, params = {}) {
-    const result = await this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}${buildSubgraphQueryString(params)}`);
-    return Array.isArray(result) ? result : result.data;
+  async count(name, table, params = {}) {
+    return this.request("GET", `/v1/subgraphs/${seg(name)}/${seg(table)}/count${buildSubgraphQueryString(params)}`);
   }
-  async queryTableCount(name, table, params = {}) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}/count${buildSubgraphQueryString(params)}`);
-  }
-  async queryTableAggregate(name, table, params = {}) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}/aggregate${buildAggregateQueryString(params)}`);
+  async aggregate(name, table, params = {}) {
+    return this.request("GET", `/v1/subgraphs/${seg(name)}/${seg(table)}/aggregate${buildAggregateQueryString(params)}`);
   }
   typed(def) {
     const result = {};
@@ -2420,32 +2415,41 @@ class Subgraphs extends BaseClient {
         let sort;
         let order;
         if (options.orderBy) {
-          const entries = Array.isArray(options.orderBy) ? options.orderBy : Object.entries(options.orderBy);
-          if (entries.length > 0) {
-            sort = entries.map(([col]) => resolveOrderByColumn(col, columns)).join(",");
-            order = entries.map(([, dir]) => dir ?? "asc").join(",");
+          const entries = Object.entries(options.orderBy);
+          if (entries.length > 1) {
+            throw new Error(`findMany orderBy accepts a single column; got ${entries.length}: ${entries.map(([col]) => col).join(", ")}. Sort one column — the cursor pairs it with _id as a tiebreaker.`);
+          }
+          const entry = entries[0];
+          if (entry) {
+            const [col, dir] = entry;
+            sort = resolveOrderByColumn(col, columns);
+            order = dir ?? "asc";
           }
         }
-        const params = {
+        const result = await self.rows(subgraphName, tableName, {
           sort,
           order,
           limit: options.limit,
-          offset: options.offset,
           fields: options.fields?.join(","),
-          filters
+          filters,
+          cursor: options.cursor
+        });
+        return {
+          rows: result.rows,
+          nextCursor: result.next_cursor,
+          tip: result.tip
         };
-        return self.queryTable(subgraphName, tableName, params);
       },
       async count(where) {
         const filters = where ? serializeWhere(where, columns) : undefined;
-        const result = await self.queryTableCount(subgraphName, tableName, {
+        const result = await self.count(subgraphName, tableName, {
           filters
         });
         return result.count;
       },
       async aggregate(spec) {
         const filters = spec.where ? serializeWhere(spec.where, columns) : undefined;
-        const result = await self.queryTableAggregate(subgraphName, tableName, {
+        const result = await self.aggregate(subgraphName, tableName, {
           filters,
           count: spec.count,
           countDistinct: spec.countDistinct,
@@ -2982,5 +2986,5 @@ export {
   verifyWebhookSignature
 };
 
-//# debugId=92280D2ABC3CFA6364756E2164756E21
+//# debugId=8B8A60AF0DDA966664756E2164756E21
 //# sourceMappingURL=index.js.map