Leon Serfaty
110 lines
4.1 KiB
TypeScript
110 lines
4.1 KiB
TypeScript
"use server";
|
|
|
|
import { revalidatePath } from "next/cache";
|
|
import { z } from "zod";
|
|
import type { Prisma } from "@prisma/client";
|
|
import { getServerSession } from "@/lib/auth/guards";
|
|
import { prisma } from "@/lib/db";
|
|
import { subjectHasFeature } from "@/lib/billing/subscription";
|
|
import { enforceLimit, LimitExceededError } from "@/lib/usage/limits";
|
|
import { enqueueEpisodeGeneration } from "@/lib/queue/pgboss";
|
|
import { FORMAT_SPEAKERS } from "@/lib/episodes/options";
|
|
import { DEFAULT_VOICE_IDS, VOICE_CATALOG } from "@/lib/ai/voices";
|
|
import { isFlagEnabled } from "@/lib/flags";
|
|
|
|
const createSchema = z.object({
|
|
theme: z.string().min(5).max(500),
|
|
count: z.number().int().min(2).max(12),
|
|
tone: z.string().min(1),
|
|
audience: z.string().max(200).optional(),
|
|
language: z.string().min(2).max(5),
|
|
});
|
|
|
|
export async function createSeriesAction(
|
|
input: z.infer<typeof createSchema>
|
|
): Promise<{ ok: boolean; error?: string; seriesId?: string }> {
|
|
const session = await getServerSession();
|
|
if (!session) return { ok: false, error: "You must be signed in." };
|
|
if (!(await subjectHasFeature(session.user.id, "series_generator", session.session.activeOrganizationId))) {
|
|
return { ok: false, error: "The series generator requires the Pro plan." };
|
|
}
|
|
if (!(await isFlagEnabled("episode_generation_enabled"))) {
|
|
return { ok: false, error: "Generation is temporarily paused. Please try again shortly." };
|
|
}
|
|
const parsed = createSchema.safeParse(input);
|
|
if (!parsed.success) return { ok: false, error: parsed.error.issues[0]?.message ?? "Invalid input." };
|
|
|
|
const { planSeason } = await import("@/lib/ai/series");
|
|
const { plan } = await planSeason(parsed.data);
|
|
|
|
const series = await prisma.series.create({
|
|
data: {
|
|
userId: session.user.id,
|
|
organizationId: session.session.activeOrganizationId ?? undefined,
|
|
title: plan.title,
|
|
description: plan.description,
|
|
plannedCount: plan.episodes.length,
|
|
plan: plan.episodes as unknown as Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
revalidatePath("/series");
|
|
return { ok: true, seriesId: series.id };
|
|
}
|
|
|
|
export async function generateFromSeriesAction(
|
|
seriesId: string,
|
|
index: number
|
|
): Promise<{ ok: boolean; error?: string; episodeId?: string }> {
|
|
const session = await getServerSession();
|
|
if (!session) return { ok: false, error: "You must be signed in." };
|
|
|
|
if (!(await isFlagEnabled("episode_generation_enabled"))) {
|
|
return { ok: false, error: "Episode generation is temporarily paused. Please try again shortly." };
|
|
}
|
|
|
|
const series = await prisma.series.findUnique({ where: { id: seriesId } });
|
|
if (!series || series.userId !== session.user.id) return { ok: false, error: "Not allowed." };
|
|
|
|
const episodes = (series.plan as unknown as { title: string; topic: string; summary: string }[]) ?? [];
|
|
const item = episodes[index];
|
|
if (!item) return { ok: false, error: "Episode not found in plan." };
|
|
|
|
try {
|
|
await enforceLimit(session.user.id, "script", session.session.activeOrganizationId);
|
|
await enforceLimit(session.user.id, "audio", session.session.activeOrganizationId);
|
|
} catch (err) {
|
|
if (err instanceof LimitExceededError) {
|
|
return { ok: false, error: `Monthly ${err.check.metric} limit reached.` };
|
|
}
|
|
throw err;
|
|
}
|
|
|
|
const speakers = FORMAT_SPEAKERS.SOLO.map((s, i) => ({
|
|
speakerKey: s.speakerKey,
|
|
displayName: s.defaultName,
|
|
elevenVoiceId: DEFAULT_VOICE_IDS[s.speakerKey] ?? VOICE_CATALOG[i % VOICE_CATALOG.length].id,
|
|
}));
|
|
|
|
const episode = await prisma.episode.create({
|
|
data: {
|
|
userId: session.user.id,
|
|
organizationId: series.organizationId ?? undefined,
|
|
seriesId: series.id,
|
|
title: item.title,
|
|
topic: item.topic,
|
|
tone: "Conversational",
|
|
format: "SOLO",
|
|
language: "en",
|
|
targetLengthMin: 10,
|
|
status: "QUEUED",
|
|
stage: "Queued for generation",
|
|
speakers: { create: speakers },
|
|
jobs: { create: { type: "full", status: "queued" } },
|
|
},
|
|
});
|
|
await enqueueEpisodeGeneration({ episodeId: episode.id, type: "full" });
|
|
|
|
revalidatePath(`/series/${seriesId}`);
|
|
return { ok: true, episodeId: episode.id };
|
|
}
|