Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

perf(web): load mobile Caps lists in fewer round trips

Aditya Garud09fea65dee71
diff --git a/apps/web/__tests__/unit/mobile-caps-list.test.ts b/apps/web/__tests__/unit/mobile-caps-list.test.ts
new file mode 100644
index 000000000..55823a413
--- /dev/null
+++ b/apps/web/__tests__/unit/mobile-caps-list.test.ts
@@ -0,0 +1,379 @@
+import { setTimeout as delay } from "node:timers/promises";
+import {
+ CurrentUser,
+ DatabaseError,
+ HttpAuthMiddleware,
+ type Mobile,
+ Organisation,
+ User,
+ type Video,
+} from "@cap/web-domain";
+import { type HttpApi, HttpApiBuilder, HttpServer } from "@effect/platform";
+import { drizzle } from "drizzle-orm/mysql-proxy";
+import { Effect, Layer, Option } from "effect";
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+ Database,
+ type DbClient,
+} from "../../../../packages/web-backend/src/Database";
+
+vi.mock("server-only", () => ({}));
+vi.mock("@cap/env", () => ({
+ serverEnv: () => ({ WEB_URL: "http://localhost" }),
+}));
+vi.mock("@cap/database/auth/auth-options", () => ({ authOptions: () => ({}) }));
+vi.mock("@cap/database/emails/config", () => ({ sendEmail: vi.fn() }));
+vi.mock("@/actions/loom", () => ({}));
+vi.mock("@/app/(org)/dashboard/analytics/data", () => ({}));
+vi.mock("@/lib/account-deletion-request", () => ({}));
+vi.mock("@/lib/desktop-segments-finalization", () => ({}));
+vi.mock("@/lib/Notification", () => ({}));
+vi.mock("@/lib/sync-video-storage-names", () => ({}));
+vi.mock("@/lib/video-processing", () => ({}));
+vi.mock("@/workflows/import-loom-video", () => ({}));
+vi.mock("workflow/api", () => ({}));
+vi.mock("@cap/web-backend", async () => {
+ const { Context } = await import("effect");
+ const { Database } = await import(
+ "../../../../packages/web-backend/src/Database"
+ );
+ return {
+ Database,
+ Videos: Context.GenericTag("mobile-caps-test/Videos"),
+ ImageUploads: Context.GenericTag("mobile-caps-test/ImageUploads"),
+ };
+});
+
+const user = {
+ id: User.UserId.make("viewer"),
+ email: "[email protected]",
+ activeOrganizationId: Organisation.OrganisationId.make("org"),
+ iconUrlOrKey: Option.none(),
+};
+const date = "2026-10-24 12:00:00";
+let size = 30;
+let sharedList = false;
+let empty = false;
+let denied = false;
+let failDatabase = false;
+let failAnalytics = false;
+let latency = 0;
+let activeQueries = 0;
+let peakQueries = 0;
+let queries: string[] = [];
+let analyticsIds: readonly Video.VideoId[] = [];
+
+function owner(index: number) {
+ return !sharedList || index % 4 === 0 ? "viewer" : `owner-${index % 4}`;
+}
+
+function preferences(id: string) {
+ return {
+ blockedUserIds:
+ id === "viewer" ? ["owner-1"] : id === "owner-2" ? ["viewer"] : [],
+ };
+}
+
+const client = drizzle(async (sql, params) => {
+ queries.push(sql);
+ peakQueries = Math.max(peakQueries, ++activeQueries);
+ try {
+ if (latency) await delay(latency);
+ if (failDatabase) throw new Error("database unavailable");
+ if (sql.includes("from `organizations`")) {
+ return {
+ rows: denied ? [] : [["org", "Organization", "viewer", "owner"]],
+ };
+ }
+ if (sql.includes("from `spaces`")) {
+ return { rows: [["team", "Team", "Public", "viewer", "admin", false]] };
+ }
+ if (sql.includes(" group by ")) {
+ return {
+ rows: empty
+ ? []
+ : Array.from({ length: size }, (_, index) => {
+ const id = owner(index);
+ return [
+ `video-${index}`,
+ id,
+ `Cap ${index}`,
+ date,
+ date,
+ id === "owner-3" ? null : id,
+ ...(sql.includes("`users`.`preferences`")
+ ? [id === "owner-3" ? null : preferences(id)]
+ : []),
+ 60 + index,
+ null,
+ true,
+ index === 3,
+ index === 7,
+ 2,
+ 1,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ ];
+ }),
+ };
+ }
+ if (sql.startsWith("select `preferences`")) {
+ return { rows: [[preferences("viewer")]] };
+ }
+ if (sql.startsWith("select `id`, `preferences`")) {
+ return {
+ rows: ["viewer", "owner-1", "owner-2"].map((id) => [
+ id,
+ preferences(id),
+ ]),
+ };
+ }
+ if (sql.includes("from `folders`")) {
+ return { rows: [["folder", "Folder", "normal", null, 4]] };
+ }
+ if (sql.includes("COUNT(")) return { rows: [[61, 81]] };
+ if (sql.includes(" order by `videos`.`effectiveCreatedAt` desc limit ")) {
+ return {
+ rows: empty
+ ? []
+ : Array.from({ length: size }, (_, index) => [
+ `video-${index}`,
+ params.includes("folder") ? "folder" : null,
+ ]),
+ };
+ }
+ throw new Error(`Unexpected query: ${sql}`);
+ } finally {
+ activeQueries--;
+ }
+});
+
+let dispose: () => Promise<void>;
+vi.mock("@/lib/server", async () => {
+ const { Videos, ImageUploads } = await import("@cap/web-backend");
+ return {
+ apiToHandler: (
+ api: Layer.Layer<HttpApi.Api, never, Database | HttpAuthMiddleware>,
+ ) => {
+ const web = HttpApiBuilder.toWebHandler(
+ api.pipe(
+ Layer.provide(
+ Layer.succeed(
+ Database,
+ Database.make({
+ use: (callback) =>
+ Effect.tryPromise({
+ try: () => callback(client as unknown as DbClient),
+ catch: (cause) => new DatabaseError({ cause }),
+ }),
+ }),
+ ),
+ ),
+ Layer.provide(
+ Layer.mock(Videos, {
+ _tag: "Videos",
+ getAnalyticsBulkForOwner: (ids: readonly Video.VideoId[]) =>
+ Effect.gen(function* () {
+ analyticsIds = ids;
+ if (latency) yield* Effect.promise(() => delay(latency));
+ if (failAnalytics)
+ return yield* new DatabaseError({
+ cause: new Error("analytics unavailable"),
+ });
+ return ids.map((_, index) => ({ count: index + 10 }));
+ }),
+ }),
+ ),
+ Layer.provide(Layer.mock(ImageUploads, { _tag: "ImageUploads" })),
+ Layer.provide(
+ Layer.succeed(
+ HttpAuthMiddleware,
+ Effect.succeed(CurrentUser.of(user)),
+ ),
+ ),
+ Layer.merge(HttpServer.layerContext),
+ ),
+ );
+ dispose = web.dispose;
+ return web.handler;
+ },
+ };
+});
+
+const { GET } = await import("@/app/api/mobile/[...route]/route");
+
+async function list(params = "") {
+ sharedList = params.includes("spaceId=");
+ return GET(
+ new Request(`http://localhost/api/mobile/caps?limit=${size}${params}`),
+ );
+}
+
+function expectedCaps(folderId: string | null = null) {
+ return Array.from({ length: size }, (_, index) => index)
+ .filter((index) => !sharedList || index % 4 === 0 || index % 4 === 3)
+ .map((index) => {
+ const protectedCap = index === 3 || index === 7;
+ const owned = owner(index) === "viewer";
+ const hasThumbnail = owned || !protectedCap;
+ return {
+ id: `video-${index}`,
+ ownerId: owner(index),
+ shareUrl: `http://localhost/s/video-${index}`,
+ title: `Cap ${index}`,
+ createdAt: "2026-10-24T12:00:00.000Z",
+ updatedAt: "2026-10-24T12:00:00.000Z",
+ ownerName: owner(index) === "owner-3" ? "" : owner(index),
+ durationSeconds: 60 + index,
+ thumbnailUrl: hasThumbnail
+ ? `http://localhost/api/mobile/caps/video-${index}/thumbnail?v=1792843200000`
+ : null,
+ thumbnailCacheKey: hasThumbnail
+ ? `cap-thumbnail:video-${index}:1792843200000`
+ : null,
+ folderId,
+ public: true,
+ protected: protectedCap,
+ viewCount:
+ owned && !failAnalytics ? (sharedList ? index / 4 : index) + 10 : 0,
+ commentCount: 2,
+ reactionCount: 1,
+ upload: null,
+ ownedByCurrentUser: owned,
+ };
+ });
+}
+
+beforeEach(() => {
+ size = 30;
+ empty = false;
+ denied = false;
+ failDatabase = false;
+ failAnalytics = false;
+ latency = 0;
+ activeQueries = 0;
+ peakQueries = 0;
+ queries = [];
+ analyticsIds = [];
+});
+afterAll(() => dispose());
+
+describe("mobile Caps list", () => {
+ it.each(["", "&spaceId=org", "&spaceId=team", "&folderId=folder"])(
+ "preserves summaries, blocks, pagination and locations for %s",
+ async (params) => {
+ const response = await list(`${params}&page=2`);
+ expect(response.status).toBe(200);
+ const body: typeof Mobile.MobileCapsListResponse.Type =
+ await response.json();
+ expect(body).toEqual({
+ caps: expectedCaps(params.includes("folderId") ? "folder" : null),
+ folders: params.includes("folderId")
+ ? []
+ : [
+ {
+ id: "folder",
+ name: "Folder",
+ color: "normal",
+ parentId: null,
+ videoCount: 4,
+ },
+ ],
+ page: 2,
+ limit: 30,
+ total: 61,
+ collectionTotal: 81,
+ hasMore: true,
+ });
+ expect(analyticsIds).toEqual(
+ body.caps.filter((cap) => cap.ownedByCurrentUser).map((cap) => cap.id),
+ );
+ },
+ );
+
+ it.each([
+ ["", 6, 4],
+ ["&spaceId=org", 7, 4],
+ ["&spaceId=team", 8, 4],
+ ["&folderId=folder", 5, 3],
+ ] as const)(
+ "bounds SQL requests and overlaps independent reads for %s",
+ async (params, count, peak) => {
+ latency = 5;
+ expect((await list(params)).status).toBe(200);
+ expect(queries).toHaveLength(count);
+ expect(peakQueries).toBe(peak);
+ },
+ );
+
+ it("keeps collection totals on an empty page", async () => {
+ empty = true;
+ const response = await list("&page=4");
+ expect(response.status).toBe(200);
+ expect(await response.json()).toMatchObject({
+ caps: [],
+ total: 61,
+ collectionTotal: 81,
+ hasMore: false,
+ });
+ expect(queries).toHaveLength(4);
+ expect(analyticsIds).toEqual([]);
+ });
+
+ it("keeps zero views when analytics fails", async () => {
+ failAnalytics = true;
+ const response = await list();
+ expect(response.status).toBe(200);
+ expect((await response.json()).caps).toEqual(expectedCaps());
+ });
+
+ it("rejects inaccessible spaces before loading caps", async () => {
+ denied = true;
+ expect((await list("&spaceId=team")).status).toBe(403);
+ expect(queries).toHaveLength(1);
+ expect(analyticsIds).toEqual([]);
+ });
+
+ it("returns an error when a required database read fails", async () => {
+ failDatabase = true;
+ expect((await list()).status).toBe(500);
+ expect(analyticsIds).toEqual([]);
+ });
+
+ it.skipIf(!process.env.CAP_API_LIST_BENCH)(
+ "benchmarks the GET handler with 40 ms dependency latency",
+ async () => {
+ latency = 40;
+ for (const pageSize of [20, 30, 50]) {
+ size = pageSize;
+ await list();
+ const samples: number[] = [];
+ for (let sample = 0; sample < 7; sample++) {
+ queries = [];
+ peakQueries = 0;
+ const start = performance.now();
+ const response = await list();
+ expect(response.status).toBe(200);
+ expect((await response.json()).caps).toEqual(expectedCaps());
+ samples.push(performance.now() - start);
+ }
+ console.log(
+ JSON.stringify({
+ pageSize,
+ latency,
+ medianMs: samples.sort((a, b) => a - b)[3],
+ sqlRequests: queries.length,
+ peakQueries,
+ }),
+ );
+ }
+ },
+ );
+});
diff --git a/apps/web/app/api/mobile/[...route]/route.ts b/apps/web/app/api/mobile/[...route]/route.ts
index b1b3d2562..45df2ef4c 100644
--- a/apps/web/app/api/mobile/[...route]/route.ts
+++ b/apps/web/app/api/mobile/[...route]/route.ts
@@ -1403,31 +1403,40 @@ const getCapLocations = Effect.fn("Mobile.getCapLocations")(function* ({
isNull(Db.organizations.tombstoneAt),
);
const whereClause = and(collectionWhereClause, folderFilter);
- const [locations, [countRow]] = yield* Effect.all([
- database.use((db) =>
- db
- .select({ id: Db.videos.id, folderId: Db.videos.folderId })
- .from(Db.videos)
- .leftJoin(Db.organizations, eq(Db.videos.orgId, Db.organizations.id))
- .where(whereClause)
- .orderBy(desc(Db.videos.effectiveCreatedAt))
- .limit(limit)
- .offset(offset),
- ),
- database.use((db) =>
- db
- .select({
- total:
- sql<number>`COUNT(CASE WHEN ${folderFilter} THEN 1 END)`.mapWith(
- Number,
- ),
- collectionTotal: count(),
- })
- .from(Db.videos)
- .leftJoin(Db.organizations, eq(Db.videos.orgId, Db.organizations.id))
- .where(collectionWhereClause),
- ),
- ]);
+ const [locations, [countRow]] = yield* Effect.all(
+ [
+ database.use((db) =>
+ db
+ .select({ id: Db.videos.id, folderId: Db.videos.folderId })
+ .from(Db.videos)
+ .leftJoin(
+ Db.organizations,
+ eq(Db.videos.orgId, Db.organizations.id),
+ )
+ .where(whereClause)
+ .orderBy(desc(Db.videos.effectiveCreatedAt))
+ .limit(limit)
+ .offset(offset),
+ ),
+ database.use((db) =>
+ db
+ .select({
+ total:
+ sql<number>`COUNT(CASE WHEN ${folderFilter} THEN 1 END)`.mapWith(
+ Number,
+ ),
+ collectionTotal: count(),
+ })
+ .from(Db.videos)
+ .leftJoin(
+ Db.organizations,
+ eq(Db.videos.orgId, Db.organizations.id),
+ )
+ .where(collectionWhereClause),
+ ),
+ ],
+ { concurrency: 2 },
+ );
return {
locations,
total: countRow?.total ?? 0,
@@ -1444,15 +1453,73 @@ const getCapLocations = Effect.fn("Mobile.getCapLocations")(function* ({
isNull(Db.organizations.tombstoneAt),
);
const whereClause = and(collectionWhereClause, folderFilter);
- const [locations, [countRow]] = yield* Effect.all([
+ const [locations, [countRow]] = yield* Effect.all(
+ [
+ database.use((db) =>
+ db
+ .select({
+ id: Db.sharedVideos.videoId,
+ folderId: Db.sharedVideos.folderId,
+ })
+ .from(Db.sharedVideos)
+ .innerJoin(Db.videos, eq(Db.sharedVideos.videoId, Db.videos.id))
+ .leftJoin(
+ Db.organizations,
+ eq(Db.videos.orgId, Db.organizations.id),
+ )
+ .where(whereClause)
+ .orderBy(desc(Db.videos.effectiveCreatedAt))
+ .limit(limit)
+ .offset(offset),
+ ),
+ database.use((db) =>
+ db
+ .select({
+ total:
+ sql<number>`COUNT(DISTINCT CASE WHEN ${folderFilter} THEN ${Db.sharedVideos.videoId} END)`.mapWith(
+ Number,
+ ),
+ collectionTotal:
+ sql<number>`COUNT(DISTINCT ${Db.sharedVideos.videoId})`.mapWith(
+ Number,
+ ),
+ })
+ .from(Db.sharedVideos)
+ .innerJoin(Db.videos, eq(Db.sharedVideos.videoId, Db.videos.id))
+ .leftJoin(
+ Db.organizations,
+ eq(Db.videos.orgId, Db.organizations.id),
+ )
+ .where(collectionWhereClause),
+ ),
+ ],
+ { concurrency: 2 },
+ );
+ return {
+ locations,
+ total: countRow?.total ?? 0,
+ collectionTotal: countRow?.collectionTotal ?? 0,
+ };
+ }
+
+ const folderFilter = folderId
+ ? eq(Db.spaceVideos.folderId, folderId)
+ : isNull(Db.spaceVideos.folderId);
+ const collectionWhereClause = and(
+ eq(Db.spaceVideos.spaceId, space.id),
+ isNull(Db.organizations.tombstoneAt),
+ );
+ const whereClause = and(collectionWhereClause, folderFilter);
+ const [locations, [countRow]] = yield* Effect.all(
+ [
database.use((db) =>
db
.select({
- id: Db.sharedVideos.videoId,
- folderId: Db.sharedVideos.folderId,
+ id: Db.spaceVideos.videoId,
+ folderId: Db.spaceVideos.folderId,
})
- .from(Db.sharedVideos)
- .innerJoin(Db.videos, eq(Db.sharedVideos.videoId, Db.videos.id))
+ .from(Db.spaceVideos)
+ .innerJoin(Db.videos, eq(Db.spaceVideos.videoId, Db.videos.id))
.leftJoin(Db.organizations, eq(Db.videos.orgId, Db.organizations.id))
.where(whereClause)
.orderBy(desc(Db.videos.effectiveCreatedAt))
@@ -1463,68 +1530,22 @@ const getCapLocations = Effect.fn("Mobile.getCapLocations")(function* ({
db
.select({
total:
- sql<number>`COUNT(DISTINCT CASE WHEN ${folderFilter} THEN ${Db.sharedVideos.videoId} END)`.mapWith(
+ sql<number>`COUNT(DISTINCT CASE WHEN ${folderFilter} THEN ${Db.spaceVideos.videoId} END)`.mapWith(
Number,
),
collectionTotal:
- sql<number>`COUNT(DISTINCT ${Db.sharedVideos.videoId})`.mapWith(
+ sql<number>`COUNT(DISTINCT ${Db.spaceVideos.videoId})`.mapWith(
Number,
),
})
- .from(Db.sharedVideos)
- .innerJoin(Db.videos, eq(Db.sharedVideos.videoId, Db.videos.id))
+ .from(Db.spaceVideos)
+ .innerJoin(Db.videos, eq(Db.spaceVideos.videoId, Db.videos.id))
.leftJoin(Db.organizations, eq(Db.videos.orgId, Db.organizations.id))
.where(collectionWhereClause),
),
- ]);
- return {
- locations,
- total: countRow?.total ?? 0,
- collectionTotal: countRow?.collectionTotal ?? 0,
- };
- }
-
- const folderFilter = folderId
- ? eq(Db.spaceVideos.folderId, folderId)
- : isNull(Db.spaceVideos.folderId);
- const collectionWhereClause = and(
- eq(Db.spaceVideos.spaceId, space.id),
- isNull(Db.organizations.tombstoneAt),
+ ],
+ { concurrency: 2 },
);
- const whereClause = and(collectionWhereClause, folderFilter);
- const [locations, [countRow]] = yield* Effect.all([
- database.use((db) =>
- db
- .select({
- id: Db.spaceVideos.videoId,
- folderId: Db.spaceVideos.folderId,
- })
- .from(Db.spaceVideos)
- .innerJoin(Db.videos, eq(Db.spaceVideos.videoId, Db.videos.id))
- .leftJoin(Db.organizations, eq(Db.videos.orgId, Db.organizations.id))
- .where(whereClause)
- .orderBy(desc(Db.videos.effectiveCreatedAt))
- .limit(limit)
- .offset(offset),
- ),
- database.use((db) =>
- db
- .select({
- total:
- sql<number>`COUNT(DISTINCT CASE WHEN ${folderFilter} THEN ${Db.spaceVideos.videoId} END)`.mapWith(
- Number,
- ),
- collectionTotal:
- sql<number>`COUNT(DISTINCT ${Db.spaceVideos.videoId})`.mapWith(
- Number,
- ),
- })
- .from(Db.spaceVideos)
- .innerJoin(Db.videos, eq(Db.spaceVideos.videoId, Db.videos.id))
- .leftJoin(Db.organizations, eq(Db.videos.orgId, Db.organizations.id))
- .where(collectionWhereClause),
- ),
- ]);
return {
locations,
total: countRow?.total ?? 0,
@@ -1648,16 +1669,20 @@ const getCapsList = Effect.fn("Mobile.getCapsList")(function* (
const user = yield* CurrentUser;
const space = yield* getSelectedSpace(params.spaceId);
- const [{ locations, total, collectionTotal }, folders] = yield* Effect.all([
- getCapLocations({ folderId, page, limit, space }),
- folderId
- ? Effect.succeed([])
- : space
- ? getSpaceRootFolders(space)
- : getRootFolders(user.activeOrganizationId),
- ]);
+ const [{ locations, total, collectionTotal }, folders, blockedUserIds] =
+ yield* Effect.all(
+ [
+ getCapLocations({ folderId, page, limit, space }),
+ folderId
+ ? Effect.succeed([])
+ : space
+ ? getSpaceRootFolders(space)
+ : getRootFolders(user.activeOrganizationId),
+ getCurrentBlockedUserIds(),
+ ],
+ { concurrency: 3 },
+ );
const rows = yield* getCapRows(locations);
- const blockedUserIds = yield* getCurrentBlockedUserIds();
const visibleRows = rows.filter(
(row) =>
!blockedUserIds.includes(row.ownerId) &&