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

ParoiCMS Site Generator Plugin

import { dateVal, nbVal, strVal, strValOrUndef } from "@paroi/data-formatters-lib";
import { ensureType, formatActivityCode, formatStepKind, formatStepStatus } from "./formatters.js";
export async function getInvalidSessionError(ctx, sessionId) {
    const { cn } = ctx;
    const row = await cn("PgSession as s")
        .leftJoin("PgSchemaStep as u", "u.sessionId", "s.id")
        .select("s.id", "s.expireAt", cn.raw("count(u.sessionId) as successStepCount"))
        .where({ "s.id": sessionId })
        .groupBy("s.id")
        .first();
    if (!row)
        return "not found";
    const successStepCount = nbVal(row.successStepCount);
    if (successStepCount >= 20)
        return "too many steps";
    const expireAt = dateVal(row.expireAt).getTime();
    if (expireAt < Date.now())
        return "expired";
}
export async function readStepSchema(ctx, stepNumber) {
    const { cn, sessionId } = ctx;
    const row = await cn("PgSchemaStep")
        .select("siteSchema", "l10n", "localizedValues")
        .where({ sessionId, stepNumber })
        .first();
    if (!row)
        throw new Error(`[${sessionId}] Step "${stepNumber}" not found`);
    return {
        siteSchema: JSON.parse(strVal(row.siteSchema)),
        l10n: JSON.parse(strVal(row.l10n)),
        localizedValues: JSON.parse(strVal(row.localizedValues)),
    };
}
export async function fetchWorkSession(ctx) {
    const { cn, sessionId } = ctx;
    const row = await cn("PgSession")
        .select("id", "createdAt", "expireAt", "language")
        .where({ id: sessionId })
        .first();
    if (!row) {
        throw new Error(`Session not found: ${sessionId}`);
    }
    const steps = await loadSessionSteps(ctx);
    return {
        id: strVal(row.id),
        createdAt: dateVal(row.createdAt).toISOString(),
        expireAt: dateVal(row.expireAt).toISOString(),
        language: strVal(row.language),
        steps,
    };
}
async function loadSessionSteps(ctx) {
    const { cn, sessionId } = ctx;
    const rows = await buildStepsQuery(cn)
        .where({ "s.sessionId": sessionId })
        .orderBy("s.stepNumber");
    return rows.map((row) => mapRowToStep(row, sessionId));
}
export async function loadStep(ctx, stepNumber) {
    const { cn, sessionId } = ctx;
    const row = await buildStepsQuery(cn)
        .where({ "s.sessionId": sessionId, "s.stepNumber": stepNumber })
        .first();
    if (!row) {
        throw new Error(`[Session "${sessionId}"] Step "${stepNumber}" not found`);
    }
    return mapRowToStep(row, sessionId);
}
function buildStepsQuery(cn) {
    return cn("PgStep as s")
        .select("s.stepNumber", "s.kind", "s.status", "s.currentActivity", "s.explanation", "c.promptTitle", "c.siteSchema", "c.l10n", "c.localizedValues as schemaLocalizedValues", "i.siteId", "i.localizedValues as siteLocalizedValues", "i.siteUrl", "i.loginEmail", "i.loginPassword")
        .leftJoin("PgSchemaStep as c", {
        "c.stepNumber": "s.stepNumber",
        "c.sessionId": "s.sessionId",
    })
        .leftJoin("PgGeneratedSiteStep as i", {
        "i.stepNumber": "s.stepNumber",
        "i.sessionId": "s.sessionId",
    });
}
function mapRowToStep(row, sessionId) {
    const baseStep = {
        stepNumber: nbVal(row.stepNumber),
        explanation: strValOrUndef(row.explanation),
    };
    const status = formatStepStatus(row.status);
    const kind = formatStepKind(row.kind);
    if (status === "pending") {
        return ensureType({
            ...baseStep,
            status,
            kind,
            currentActivity: formatActivityCode(row.currentActivity),
        });
    }
    if (status === "completed") {
        if (kind === "initialSchema" || kind === "updateSchema") {
            if (!row.siteSchema) {
                throw new Error(`[Session "${sessionId}"] PgSchemaStep row is missing for completed step "${row.stepNumber}"`);
            }
            return ensureType({
                ...baseStep,
                status,
                kind,
                promptTitle: strValOrUndef(row.promptTitle),
                siteSchema: JSON.parse(strVal(row.siteSchema)),
                l10n: JSON.parse(strVal(row.l10n)),
                localizedValues: JSON.parse(strVal(row.schemaLocalizedValues)),
            });
        }
        if (kind === "generateSite") {
            if (!row.siteId) {
                throw new Error(`[Session "${sessionId}"] PgGeneratedSiteStep row is missing for completed step "${row.stepNumber}"`);
            }
            const siteUrl = strVal(row.siteUrl);
            return ensureType({
                ...baseStep,
                status,
                kind,
                siteId: strVal(row.siteId),
                siteUrl,
                adminUiUrl: `${siteUrl}/adm`,
                loginEmail: strVal(row.loginEmail),
                loginPassword: strVal(row.loginPassword),
                localizedValues: JSON.parse(strVal(row.siteLocalizedValues)),
            });
        }
        throw new Error(`[Session "${sessionId}"] invalid step kind "${kind}"`);
    }
    if (status === "failed") {
        return ensureType({
            ...baseStep,
            status,
            kind,
        });
    }
    return ensureType({
        ...baseStep,
        status,
        kind,
    });
}