feat: Add pagination to /connected_accounts/list (#251)

* Add pagination to /connected_accounts/list

* Add test

* ci: Generate code

* ci: Format code

* Remove outdated test

---------

Co-authored-by: Seam Bot <seambot@getseam.com>

Author: andrii-balitskyi

src/lib/api/pagination.ts

@@ -0,0 +1,49 @@
+import { createHash } from "node:crypto"
+
+import { serializeUrlSearchParams } from "@seamapi/url-search-params-serializer"
+import { z } from "zod"
+
+export const getNextPageUrl = (
+  next_page_cursor: string | null,
+  {
+    req,
+  }: {
+    req: {
+      url?: string
+      commonParams: Record<string, unknown>
+      baseUrl: string | undefined
+    }
+  },
+): string | null => {
+  if (req.url == null || req.baseUrl == null) return null
+  if (next_page_cursor == null) return null
+  const { page_cursor, ...params } = req.commonParams
+  const query = serializeUrlSearchParams(params)
+  const url = new URL([req.baseUrl, req.url].join(""))
+  url.search = query
+  url.searchParams.set("next_page_cursor", next_page_cursor)
+  url.searchParams.sort()
+  return url.toString()
+}
+
+export const getPageCursorQueryHash = (
+  params: Record<string, unknown>,
+): string => {
+  const query = serializeUrlSearchParams(params)
+  return createHash("sha256").update(query).digest("hex")
+}
+
+export const createPageCursorSchema = <T extends z.ZodTypeAny>(
+  internal_page_cursor_schema: T,
+) =>
+  z
+    .string()
+    .base64()
+    .optional()
+    .nullable()
+    .transform((page_cursor) => {
+      if (page_cursor == null) return page_cursor
+      return internal_page_cursor_schema.parse(
+        JSON.parse(Buffer.from(page_cursor, "base64").toString("utf8")),
+      )
+    })

src/lib/zod/index.ts

@@ -15,6 +15,7 @@ export * from "./device.ts"
 export * from "./event.ts"
 export * from "./health.ts"
 export * from "./noise_threshold.ts"
+export * from "./pagination.ts"
 export * from "./phone.ts"
 export * from "./phone-number.ts"
 export * from "./schedule.ts"

src/lib/zod/pagination.ts

@@ -0,0 +1,33 @@
+import { z } from "zod"
+
+import { createPageCursorSchema } from "lib/api/pagination.ts"
+
+export const pagination = z.object({
+  has_next_page: z.boolean(),
+  next_page_cursor: z.string().base64().nullable(),
+  next_page_url: z.string().url().nullable(),
+})
+
+export const device_internal_page_cursor = z.tuple([
+  z.string(),
+  z.object({
+    created_at: z.coerce.date(),
+    device_id: z.string(),
+  }),
+])
+
+export const device_page_cursor = createPageCursorSchema(
+  device_internal_page_cursor,
+)
+
+export const connected_account_internal_page_cursor = z.tuple([
+  z.string(),
+  z.object({
+    created_at: z.coerce.date(),
+    connected_account_id: z.string(),
+  }),
+])
+
+export const connected_account_page_cursor = createPageCursorSchema(
+  connected_account_internal_page_cursor,
+)

src/pages/api/connected_accounts/list.ts

@@ -1,9 +1,22 @@
+import { sortBy } from "lodash"
+import { BadRequestException } from "nextlove"
 import { z } from "zod"
 
-import { connected_account } from "lib/zod/index.ts"
+import {
+  connected_account,
+  connected_account_internal_page_cursor,
+  connected_account_page_cursor,
+  pagination,
+} from "lib/zod/index.ts"
 
+import { getNextPageUrl, getPageCursorQueryHash } from "lib/api/pagination.ts"
 import { withRouteSpec } from "lib/middleware/with-route-spec.ts"
 
+export const common_params = z.object({
+  limit: z.coerce.number().int().positive().default(500),
+  page_cursor: connected_account_page_cursor,
+})
+
 export default withRouteSpec({
   auth: [
     "client_session",
@@ -12,17 +25,69 @@ export default withRouteSpec({
     "api_key",
   ],
   methods: ["GET", "POST"],
+  commonParams: common_params,
   jsonResponse: z.object({
     connected_accounts: z.array(connected_account),
+    pagination,
   }),
 } as const)(async (req, res) => {
+  const { page_cursor, ...params } = req.commonParams
+
+  const query_hash = getPageCursorQueryHash(params)
+  const page_cursor_query_hash = page_cursor?.[0]
+  const page_cursor_pointer = page_cursor?.[1]
+  if (page_cursor_query_hash != null && page_cursor_query_hash !== query_hash) {
+    throw new BadRequestException({
+      type: "mismatched_page_parameters",
+      message:
+        "When using next_page_cursor, the request must send parameters identical to the initial request.",
+    })
+  }
+
+  const { workspace_id } = req.auth
+
+  let accounts = req.db.connected_accounts
+    .filter((ca) => ca.workspace_id === workspace_id)
+    .filter((ca) =>
+      req.auth.type === "client_session"
+        ? req.auth.connected_account_ids.includes(ca.connected_account_id)
+        : true,
+    )
+
+  accounts = sortBy(accounts, ["created_at", "connected_account_id"])
+
+  const connected_account_id = page_cursor_pointer?.connected_account_id
+  const startIdx =
+    connected_account_id == null
+      ? 0
+      : accounts.findIndex(
+          (account) => account.connected_account_id === connected_account_id,
+        )
+
+  const endIdx = Math.min(startIdx + params.limit, accounts.length)
+  const page = accounts.slice(startIdx, endIdx)
+  const next_account = accounts[endIdx]
+  const has_next_page = next_account != null
+
+  let next_page_cursor = null
+  if (has_next_page) {
+    const next_page_cursor_data = connected_account_internal_page_cursor.parse([
+      query_hash,
+      {
+        connected_account_id: next_account.connected_account_id,
+        created_at: next_account.created_at,
+      },
+    ])
+    next_page_cursor = Buffer.from(
+      JSON.stringify(next_page_cursor_data),
+      "utf8",
+    ).toString("base64")
+  }
+
+  const next_page_url = getNextPageUrl(next_page_cursor, { req })
+
   res.status(200).json({
-    connected_accounts: req.db.connected_accounts
-      .filter((ca) =>
-        req.auth.type === "client_session"
-          ? req.auth.connected_account_ids.includes(ca.connected_account_id)
-          : true,
-      )
-      .filter((ca) => ca.workspace_id === req.auth.workspace_id),
+    connected_accounts: page,
+    pagination: { has_next_page, next_page_cursor, next_page_url },
   })
 })

src/pages/api/devices/list.ts

@@ -1,12 +1,16 @@
-import { createHash } from "node:crypto"
-
-import { serializeUrlSearchParams } from "@seamapi/url-search-params-serializer"
 import { sortBy } from "lodash"
 import { BadRequestException } from "nextlove"
 import { z } from "zod"
 
-import { device, device_type } from "lib/zod/index.ts"
+import {
+  device,
+  device_internal_page_cursor,
+  device_page_cursor,
+  device_type,
+  pagination,
+} from "lib/zod/index.ts"
 
+import { getNextPageUrl, getPageCursorQueryHash } from "lib/api/pagination.ts"
 import { withRouteSpec } from "lib/middleware/with-route-spec.ts"
 import { getManagedDevicesWithFilter } from "lib/util/devices.ts"
 
@@ -18,38 +22,16 @@ export const common_params = z.object({
   device_types: z.array(device_type).optional(),
   manufacturer: z.string().optional(),
   limit: z.coerce.number().int().positive().default(500),
-  page_cursor: z
-    .string()
-    .base64()
-    .optional()
-    .nullable()
-    .transform((page_cursor) => {
-      if (page_cursor == null) return page_cursor
-      return page_cursor_schema.parse(
-        JSON.parse(Buffer.from(page_cursor, "base64").toString("utf8")),
-      )
-    }),
+  page_cursor: device_page_cursor,
 })
 
-const page_cursor_schema = z.tuple([
-  z.string(),
-  z.object({
-    created_at: z.coerce.date(),
-    device_id: z.string(),
-  }),
-])
-
 export default withRouteSpec({
   auth: ["console_session_with_workspace", "client_session", "api_key"],
   methods: ["GET", "POST"],
   commonParams: common_params,
   jsonResponse: z.object({
     devices: z.array(device),
-    pagination: z.object({
-      has_next_page: z.boolean(),
-      next_page_cursor: z.string().base64().nullable(),
-      next_page_url: z.string().url().nullable(),
-    }),
+    pagination,
   }),
 } as const)(async (req, res) => {
   const { page_cursor, ...params } = req.commonParams
@@ -111,7 +93,7 @@ export default withRouteSpec({
 
   let next_page_cursor = null
   if (has_next_page) {
-    const next_page_cursor_data = page_cursor_schema.parse([
+    const next_page_cursor_data = device_internal_page_cursor.parse([
       query_hash,
       {
         device_id: next_device.device_id,
@@ -131,31 +113,3 @@ export default withRouteSpec({
     pagination: { has_next_page, next_page_cursor, next_page_url },
   })
 })
-
-const getNextPageUrl = (
-  next_page_cursor: string | null,
-  {
-    req,
-  }: {
-    req: {
-      url?: string
-      commonParams: Record<string, unknown>
-      baseUrl: string | undefined
-    }
-  },
-): string | null => {
-  if (req.url == null || req.baseUrl == null) return null
-  if (next_page_cursor == null) return null
-  const { page_cursor, ...params } = req.commonParams
-  const query = serializeUrlSearchParams(params)
-  const url = new URL([req.baseUrl, req.url].join(""))
-  url.search = query
-  url.searchParams.set("next_page_cursor", next_page_cursor)
-  url.searchParams.sort()
-  return url.toString()
-}
-
-const getPageCursorQueryHash = (params: Record<string, unknown>): string => {
-  const query = serializeUrlSearchParams(params)
-  return createHash("sha256").update(query).digest("hex")
-}

src/route-types.ts

@@ -1959,7 +1959,10 @@ export type Routes = {
     method: "GET" | "POST"
     queryParams: {}
     jsonBody: {}
-    commonParams: {}
+    commonParams: {
+      limit?: number
+      page_cursor?: (string | undefined) | null
+    }
     formData: {}
     jsonResponse: {
       connected_accounts: {
@@ -1982,6 +1985,11 @@ export type Routes = {
         assa_abloy_credential_service_id?: string | undefined
         bridge_id: string | null
       }[]
+      pagination: {
+        has_next_page: boolean
+        next_page_cursor: string | null
+        next_page_url: string | null
+      }
       ok: boolean
     }
   }