Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { db } from "@cap/database";
import { videoUploads } from "@cap/database/schema";
import type { S3Bucket, Video } from "@cap/web-domain";
import { and, eq, ne } from "drizzle-orm";
import { start } from "workflow/api";
import { processVideoWorkflow } from "@/workflows/process-video";
export type VideoProcessingStartStatus =
| "started"
| "already-processing"
| "already-complete";
const getAffectedRows = (result: unknown) => {
if (Array.isArray(result)) {
return (
(result[0] as { affectedRows?: number } | undefined)?.affectedRows ?? 0
);
}
return (result as { affectedRows?: number } | undefined)?.affectedRows ?? 0;
};
export async function setVideoProcessingError(
videoId: Video.VideoId,
processingMessage: string,
error: unknown,
): Promise<void> {
await db()
.update(videoUploads)
.set({
phase: "error",
processingProgress: 0,
processingMessage,
processingError: error instanceof Error ? error.message : String(error),
updatedAt: new Date(),
})
.where(eq(videoUploads.videoId, videoId));
}
export async function transitionVideoToProcessing({
videoId,
rawFileKey,
processingMessage,
mode,
forceRestart,
}: {
videoId: Video.VideoId;
rawFileKey: string;
processingMessage: string;
mode?: "singlepart" | "multipart";
forceRestart?: boolean;
}): Promise<VideoProcessingStartStatus> {
const result = await db()
.update(videoUploads)
.set({
...(mode ? { mode } : {}),
phase: "processing",
processingProgress: 0,
processingMessage,
processingError: null,
rawFileKey,
updatedAt: new Date(),
})
.where(
forceRestart
? eq(videoUploads.videoId, videoId)
: and(
eq(videoUploads.videoId, videoId),
ne(videoUploads.phase, "processing"),
ne(videoUploads.phase, "generating_thumbnail"),
// "complete" is terminal for implicit starts: a multipart
// completion retried after an uncertain network outcome can
// land after the first processing run already finished, and
// must not kick off a duplicate full re-process. Explicit
// re-processing goes through forceRestart.
ne(videoUploads.phase, "complete"),
),
);
if (getAffectedRows(result) > 0) {
return "started";
}
const [upload] = await db()
.select()
.from(videoUploads)
.where(eq(videoUploads.videoId, videoId));
if (!upload) {
throw new Error("No upload record found");
}
if (
upload.phase === "processing" ||
upload.phase === "generating_thumbnail"
) {
return "already-processing";
}
if (upload.phase === "complete") {
return "already-complete";
}
throw new Error("Failed to transition upload to processing");
}
export async function startVideoProcessingWorkflow({
videoId,
userId,
rawFileKey,
bucketId,
processingMessage,
startFailureMessage,
mode,
forceRestart,
}: {
videoId: Video.VideoId;
userId: string;
rawFileKey: string;
bucketId: string | null;
processingMessage: string;
startFailureMessage: string;
mode?: "singlepart" | "multipart";
forceRestart?: boolean;
}): Promise<VideoProcessingStartStatus> {
const status = await transitionVideoToProcessing({
videoId,
rawFileKey,
processingMessage,
mode,
forceRestart,
});
if (status !== "started") {
return status;
}
try {
await start(processVideoWorkflow, [
{
videoId,
userId,
rawFileKey,
bucketId: bucketId as S3Bucket.S3BucketId | null,
},
]);
return "started";
} catch (error) {
const normalizedError =
error instanceof Error
? error
: new Error("Video processing could not start");
await setVideoProcessingError(
videoId,
startFailureMessage,
normalizedError,
);
throw normalizedError;
}
}