@secondlayer/sdk 10.6.0 → 12.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

@@ -234,8 +234,7 @@ declare function resolveBaseUrl(explicit?: string): string;
 *  env vars. Guarded for browsers and edge runtimes. */
 declare function resolveApiKey(apiKey?: string): string | undefined;
 /** Resolve the hosted account key for archive quote/fetch/credits.
-*  Precedence: explicit `accountKey` → `SECONDLAYER_API_KEY` → `SL_API_KEY` /
-*  `SL_ARCHIVE_API_KEY` (one-release warn-fallbacks). Does not read
+*  Precedence: explicit `accountKey` → `SECONDLAYER_API_KEY`. Does not read
 *  `INSTANCE_TOKEN`. */
 declare function resolveAccountKey(accountKey?: string): string | undefined;
 declare abstract class BaseClient {
@@ -2589,7 +2588,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 +2610,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 +2626,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 +2780,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

@@ -205,7 +205,6 @@ function raceAbort(promise, signal) {
 var LOCAL_API_URL = "http://127.0.0.1:3800";
 var INSTANCE_TOKEN_ENV = "INSTANCE_TOKEN";
 var ACCOUNT_KEY_ENV = "SECONDLAYER_API_KEY";
-var warnedUrlAlias = false;
 function resolveBaseUrl(explicit) {
   if (explicit && explicit.length > 0)
     return explicit.replace(/\/+$/, "");
@@ -213,14 +212,6 @@ function resolveBaseUrl(explicit) {
     const primary = process.env?.SECONDLAYER_API_URL || undefined;
     if (primary)
       return primary.replace(/\/+$/, "");
-    const legacy = process.env?.SL_API_URL || undefined;
-    if (legacy) {
-      if (!warnedUrlAlias) {
-        warnedUrlAlias = true;
-        console.warn("[secondlayer] SL_API_URL is a legacy alias of SECONDLAYER_API_URL; using the alias this once.");
-      }
-      return legacy.replace(/\/+$/, "");
-    }
   }
   return LOCAL_API_URL;
 }
@@ -232,26 +223,12 @@ function resolveApiKey(apiKey) {
   const token = process.env?.INSTANCE_TOKEN || undefined;
   return token;
 }
-var warnedArchiveAlias = false;
 function resolveAccountKey(accountKey) {
   if (accountKey !== undefined)
     return accountKey;
   if (typeof process === "undefined")
     return;
-  const primary = process.env?.SECONDLAYER_API_KEY || undefined;
-  const slAlias = process.env?.SL_API_KEY || undefined;
-  const archiveAlias = process.env?.SL_ARCHIVE_API_KEY || undefined;
-  if (primary)
-    return primary;
-  const legacy = slAlias ?? archiveAlias;
-  if (legacy) {
-    if (!warnedArchiveAlias) {
-      warnedArchiveAlias = true;
-      console.warn("[secondlayer] SL_API_KEY / SL_ARCHIVE_API_KEY are legacy aliases of SECONDLAYER_API_KEY; using the alias this once.");
-    }
-    return legacy;
-  }
-  return;
+  return process.env?.SECONDLAYER_API_KEY || undefined;
 }
 function seg(value) {
   return encodeURIComponent(String(value));
@@ -2317,7 +2294,6 @@ function buildSubgraphQueryString(params) {
     _sort: params.sort,
     _order: params.order,
     _limit: params.limit,
-    _offset: params.offset,
     _fields: params.fields,
     ...params.filters
   });
@@ -2395,15 +2371,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 queryTableCount(name, table, params = {}) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}/count${buildSubgraphQueryString(params)}`);
+  async count(name, table, params = {}) {
+    return this.request("GET", `/v1/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 +2392,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 +2963,5 @@ export {
   verifyWebhookSignature
 };
 
-//# debugId=92280D2ABC3CFA6364756E2164756E21
+//# debugId=758CC74B9A5D6A8064756E2164756E21
 //# sourceMappingURL=index.js.map