@paroicms/site-generator-plugin/backend/dist/db/db-write.queries.js

ParoiCMS Site Generator Plugin

import { sqliteDateTime } from "@paroicms/internal-server-lib";
import { type } from "arktype";
export async function insertSession(ctx, values) {
    const { cn } = ctx;
    await cn("PgSession").insert({
        id: values.sessionId,
        language: values.language,
        expireAt: sqliteDateTime(values.expireAt),
    });
}
export async function updateSession(ctx, values) {
    const { cn, sessionId } = ctx;
    if (Object.keys(values).length === 0)
        return;
    await cn("PgSession")
        .where({ id: sessionId })
        .update({
        language: values.language,
        expireAt: values.expireAt ? sqliteDateTime(values.expireAt) : undefined,
    });
}
export async function insertStep(ctx, values) {
    const { cn, sessionId } = ctx;
    // Find the highest step number for this session
    const result = await cn("PgStep").where({ sessionId }).max("stepNumber as maxStep").first();
    const stepNumber = (result?.maxStep || 0) + 1;
    const startedAt = new Date();
    await cn("PgStep").insert({
        stepNumber,
        sessionId,
        startedAt: sqliteDateTime(startedAt),
        kind: values.kind,
        status: values.status,
        currentActivity: values.currentActivity,
        explanation: values.explanation,
    });
    return { stepNumber, startedAt };
}
export async function updateStep(ctx, stepHandle, values) {
    const { cn, sessionId } = ctx;
    const { stepNumber, startedAt } = stepHandle;
    const updateValues = {};
    if (values.status) {
        updateValues.status = values.status;
        if (values.status !== "pending") {
            updateValues.durationMs = Date.now() - startedAt.getTime();
        }
    }
    if (values.currentActivity !== undefined) {
        updateValues.currentActivity = values.currentActivity;
    }
    if (values.explanation !== undefined)
        updateValues.explanation = values.explanation;
    if (Object.keys(updateValues).length === 0)
        return;
    await cn("PgStep").where({ sessionId, stepNumber }).update(updateValues);
}
export async function saveCompletedSchemaStep(ctx, stepHandle, values) {
    const { cn, sessionId } = ctx;
    const { stepNumber, startedAt } = stepHandle;
    // Transaction to ensure both operations succeed or fail together
    await cn.transaction(async (tx) => {
        // Update the step status
        await tx("PgStep")
            .where({ sessionId, stepNumber })
            .update({
            status: "completed",
            durationMs: Date.now() - startedAt.getTime(),
            currentActivity: null,
            explanation: values.explanation,
        });
        // Insert the completed step details
        await tx("PgSchemaStep").insert({
            stepNumber,
            sessionId,
            promptTitle: values.promptTitle,
            siteSchema: JSON.stringify(values.siteSchema),
            l10n: JSON.stringify(values.l10n),
            localizedValues: JSON.stringify(values.localizedValues),
            nodeTypeCount: values.siteSchema.nodeTypes?.length ?? 0,
            inputTokenCount: values.inputTokenCount,
            outputTokenCount: values.outputTokenCount,
        });
    });
}
export async function saveGeneratedSiteStep(ctx, stepHandle, values) {
    const { cn, sessionId } = ctx;
    const { stepNumber, startedAt } = stepHandle;
    const completed = values.status === "completed";
    await cn.transaction(async (tx) => {
        await tx("PgStep")
            .where({ sessionId, stepNumber })
            .update({
            status: values.status,
            durationMs: completed ? Date.now() - startedAt.getTime() : null,
            currentActivity: completed ? null : undefined,
        });
        await tx("PgGeneratedSiteStep").insert({
            siteId: values.siteId,
            stepNumber,
            sessionId,
            siteUrl: values.siteUrl,
            loginEmail: values.loginEmail,
            loginPassword: values.loginPassword,
            localizedValues: JSON.stringify(values.localizedValues),
            contentEntryCount: completed ? 0 : undefined,
            contentInputTokenCount: completed ? 0 : undefined,
            contentOutputTokenCount: completed ? 0 : undefined,
        });
    });
}
export async function updateGeneratedSiteStepSetAsCompleted(ctx, stepHandle, values) {
    const { cn, sessionId } = ctx;
    const { stepNumber, startedAt } = stepHandle;
    await cn.transaction(async (tx) => {
        await tx("PgStep")
            .where({ sessionId, stepNumber })
            .update({
            status: values.status,
            durationMs: Date.now() - startedAt.getTime(),
            currentActivity: null,
        });
        await tx("PgGeneratedSiteStep").where({ sessionId, stepNumber }).update({
            contentEntryCount: values.contentEntryCount,
            contentInputTokenCount: values.contentInputTokenCount,
            contentOutputTokenCount: values.contentOutputTokenCount,
            contentErrors: values.contentErrors,
        });
    });
}
const InsertedIdAT = type({ id: "number", "+": "reject" });
export async function insertIssueEvent(ctx, values) {
    const { cn, sessionId } = ctx;
    const [inserted] = await cn("PgIssueEvent")
        .insert({
        sessionId,
        eventType: values.eventType,
        issueMessage: values.issueMessage,
        llmTaskName: values.llmTaskName,
        stepNumber: values.stepNumber,
        siteId: values.siteId,
    })
        .returning("id");
    const insertedId = String(InsertedIdAT.assert(inserted).id);
    return { id: insertedId };
}