Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

refactor: build the Loom import restart route with HttpApi

Richie McIlroy213bee841568
diff --git a/apps/web/__tests__/unit/loom-importer-redrive.test.ts b/apps/web/__tests__/unit/loom-importer-redrive.test.ts
index c7748480b..ba6bb8143 100644
--- a/apps/web/__tests__/unit/loom-importer-redrive.test.ts
+++ b/apps/web/__tests__/unit/loom-importer-redrive.test.ts
@@ -6,6 +6,7 @@ const mocks = vi.hoisted(() => ({
affectedRows: 1,
updates: [] as Array<Record<string, unknown>>,
inserts: [] as Array<Record<string, unknown>>,
+ deletes: 0,
runState: vi.fn(),
start: vi.fn(),
restore: vi.fn(),
@@ -30,6 +31,11 @@ vi.mock("@cap/database", () => {
},
}),
}),
+ delete: () => ({
+ where: async () => {
+ mocks.deletes++;
+ },
+ }),
insert: () => ({
values: (values: Record<string, unknown>) => ({
onDuplicateKeyUpdate: async () => {
@@ -56,11 +62,26 @@ vi.mock("@/lib/loom-import-start", () => ({
startLoomImportWorkflow: mocks.start,
restoreLoomImportStartError: mocks.restore,
LoomImportStartError: class LoomImportStartError extends Error {
- constructor(readonly canRetry: boolean) {
- super("Loom import could not start. Please try again.");
+ constructor(
+ readonly canRetry: boolean,
+ cause: unknown,
+ ) {
+ super("Loom import could not start. Please try again.", { cause });
}
},
}));
+vi.mock("@/lib/server", async () => {
+ const { HttpApiBuilder, HttpServer } = await import("@effect/platform");
+ const { Layer } = await import("effect");
+ return {
+ apiToHandler: (api: Layer.Layer<never>) => {
+ const { handler } = HttpApiBuilder.toWebHandler(
+ Layer.mergeAll(api, HttpServer.layerContext),
+ );
+ return (request: Request) => handler(request);
+ },
+ };
+});
vi.mock("@/lib/video-processing", () => ({
startVideoProcessingWorkflow: mocks.startProcessing,
}));
@@ -92,6 +113,7 @@ beforeEach(() => {
mocks.affectedRows = 1;
mocks.updates = [];
mocks.inserts = [];
+ mocks.deletes = 0;
mocks.runState.mockReset().mockResolvedValue("inactive");
mocks.start.mockReset().mockResolvedValue(undefined);
mocks.restore.mockReset().mockResolvedValue(undefined);
@@ -180,7 +202,9 @@ describe("redriveLoomImport", () => {
});
it("puts the import back into its error state when the start is rejected", async () => {
- mocks.start.mockRejectedValue(new LoomImportStartError(true));
+ mocks.start.mockRejectedValue(
+ new LoomImportStartError(true, new Error("queue rejected")),
+ );
await expect(redriveLoomImport("video", now)).resolves.toMatchObject({
status: "failed",
});
@@ -212,6 +236,55 @@ describe("deferred Loom processing", () => {
).toBe(expected);
});
+ it("retries a start that never finished after half an hour", () => {
+ const deferred = {
+ rawFileKey: "owner/video/raw-upload.webm",
+ status: "started" as const,
+ startedAt: now.toISOString(),
+ };
+ expect(
+ getPendingLoomProcessing(
+ { loomDeferredProcessing: deferred },
+ "owner",
+ "video",
+ now.getTime() + 29 * 60 * 1000,
+ ),
+ ).toBeNull();
+ expect(
+ getPendingLoomProcessing(
+ { loomDeferredProcessing: deferred },
+ "owner",
+ "video",
+ now.getTime() + 31 * 60 * 1000,
+ ),
+ ).toBe("owner/video/raw-upload.webm");
+ expect(
+ getPendingLoomProcessing(
+ { loomDeferredProcessing: { ...deferred, status: "complete" } },
+ "owner",
+ "video",
+ now.getTime() + 31 * 60 * 1000,
+ ),
+ ).toBeNull();
+ });
+
+ it("releases its claim when the conversion cannot start", async () => {
+ mocks.startProcessing.mockRejectedValue(new Error("queue down"));
+ await expect(
+ startDeferredLoomProcessing(
+ {
+ videoId: "video" as never,
+ ownerId: "owner",
+ bucketId: null,
+ rawFileKey: "owner/video/raw-upload.webm",
+ },
+ now,
+ ),
+ ).rejects.toThrow("queue down");
+ expect(mocks.deletes).toBe(1);
+ expect(mocks.updates).toHaveLength(2);
+ });
+
it("starts processing the original once", async () => {
const input = {
videoId: "video" as never,
@@ -246,7 +319,10 @@ describe("POST /api/internal/loom-imports/redrive", () => {
POST(
new NextRequest("https://cap.so/api/internal/loom-imports/redrive", {
method: "POST",
- headers: secret ? { "x-media-server-secret": secret } : {},
+ headers: {
+ "Content-Type": "application/json",
+ ...(secret ? { "x-media-server-secret": secret } : {}),
+ },
body: JSON.stringify(body),
}),
);
diff --git a/apps/web/app/api/internal/loom-imports/redrive/route.ts b/apps/web/app/api/internal/loom-imports/redrive/route.ts
index f38f0422b..cd422c5dc 100644
--- a/apps/web/app/api/internal/loom-imports/redrive/route.ts
+++ b/apps/web/app/api/internal/loom-imports/redrive/route.ts
@@ -1,57 +1,87 @@
import { createHash, timingSafeEqual } from "node:crypto";
import { serverEnv } from "@cap/env";
-import { type NextRequest, NextResponse } from "next/server";
-import { z } from "zod";
+import {
+ HttpApi,
+ HttpApiBuilder,
+ HttpApiEndpoint,
+ HttpApiError,
+ HttpApiGroup,
+ HttpServerRequest,
+} from "@effect/platform";
+import { Effect, Layer, Schema } from "effect";
import {
type LoomRedriveOutcome,
redriveLoomImport,
} from "@/lib/loom-import-redrive";
+import { apiToHandler } from "@/lib/server";
const MAX_VIDEOS_PER_REQUEST = 25;
const CONCURRENCY = 5;
-const bodySchema = z.object({
- videoIds: z
- .array(z.string().regex(/^[a-z0-9]{15}$/))
- .min(1)
- .max(MAX_VIDEOS_PER_REQUEST),
-});
+class Api extends HttpApi.make("LoomImportRedriveApi").add(
+ HttpApiGroup.make("root").add(
+ HttpApiEndpoint.post("redrive")`/api/internal/loom-imports/redrive`
+ .setPayload(
+ Schema.Struct({
+ videoIds: Schema.Array(
+ Schema.String.pipe(Schema.pattern(/^[a-z0-9]{15}$/)),
+ ).pipe(Schema.minItems(1), Schema.maxItems(MAX_VIDEOS_PER_REQUEST)),
+ }),
+ )
+ .addSuccess(
+ Schema.Struct({
+ results: Schema.Array(
+ Schema.Struct({
+ videoId: Schema.String,
+ status: Schema.Literal("restarted", "skipped", "failed"),
+ reason: Schema.optional(Schema.String),
+ }),
+ ),
+ }),
+ )
+ .addError(HttpApiError.Unauthorized),
+ ),
+) {}
-function isAuthorized(request: NextRequest) {
- const secret = serverEnv().MEDIA_SERVER_WEBHOOK_SECRET;
- const header = request.headers.get("x-media-server-secret");
- if (!secret || !header) return false;
- const digest = (value: string) =>
- createHash("sha256").update(value, "utf8").digest();
- return timingSafeEqual(digest(header), digest(secret));
+function digest(value: string) {
+ return createHash("sha256").update(value, "utf8").digest();
}
-export async function POST(request: NextRequest) {
- if (!isAuthorized(request))
- return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
- const parsed = bodySchema.safeParse(await request.json().catch(() => null));
- if (!parsed.success)
- return NextResponse.json(
- { error: "Invalid request", details: parsed.error.issues },
- { status: 400 },
- );
- const videoIds = [...new Set(parsed.data.videoIds)];
- const results: LoomRedriveOutcome[] = [];
- let next = 0;
- await Promise.all(
- Array.from({ length: Math.min(CONCURRENCY, videoIds.length) }, async () => {
- while (next < videoIds.length) {
- const videoId = videoIds[next++];
- if (!videoId) continue;
- results.push(
- await redriveLoomImport(videoId).catch((error) => ({
- videoId,
- status: "failed" as const,
- reason: error instanceof Error ? error.message : String(error),
- })),
- );
- }
- }),
- );
- return NextResponse.json({ results });
-}
+const ApiLive = HttpApiBuilder.api(Api).pipe(
+ Layer.provide(
+ HttpApiBuilder.group(Api, "root", (handlers) =>
+ handlers.handle("redrive", ({ payload }) =>
+ Effect.gen(function* () {
+ const request = yield* HttpServerRequest.HttpServerRequest;
+ const secret = serverEnv().MEDIA_SERVER_WEBHOOK_SECRET;
+ const header = request.headers["x-media-server-secret"];
+ if (
+ !secret ||
+ !header ||
+ !timingSafeEqual(digest(header), digest(secret))
+ )
+ return yield* new HttpApiError.Unauthorized();
+ const results = yield* Effect.forEach(
+ [...new Set(payload.videoIds)],
+ (videoId) =>
+ Effect.promise(
+ (): Promise<LoomRedriveOutcome> =>
+ redriveLoomImport(videoId).catch((error) => ({
+ videoId,
+ status: "failed",
+ reason:
+ error instanceof Error ? error.message : String(error),
+ })),
+ ),
+ { concurrency: CONCURRENCY },
+ );
+ return { results };
+ }),
+ ),
+ ),
+ ),
+);
+
+export const POST = apiToHandler(ApiLive);
+export const maxDuration = 300;
+export const dynamic = "force-dynamic";