@paroicms/site-generator-plugin 0.9.1 → 0.11.0

package/gen-backend/ddl/site-generator.ddl.sql

@@ -8,15 +8,63 @@ create table PaMetadata (
   primary key (dbSchema, k)
 );
 
-insert into PaMetadata (dbSchema, k, val) values ('site-generator', 'dbSchemaVersion', '1');
+insert into PaMetadata (dbSchema, k, val) values ('site-generator', 'dbSchemaVersion', '2');
 
-create table PaGenSession (
-  id char(36) not null primary key,
+create table PgSession (
+  id varchar(100) not null primary key,
   createdAt timestamp not null default current_timestamp,
+  expireAt timestamp not null,
+  language varchar(5) not null
+);
+
+create table PgStep (
+  stepNumber integer not null,
+  sessionId varchar(100) not null references PgSession(id),
+  startedAt timestamp not null default current_timestamp,
+  kind varchar(100) not null,
   status varchar(100) not null,
-  guardCount integer not null default 0,
-  promptCount integer not null default 0,
-  nodeTypeCount integer not null default 0,
-  contentCount integer not null default 0,
-  errorMessage varchar(500)
-);
+  durationMs integer,
+  currentActivity varchar(100),
+  explanation text,
+  primary key (stepNumber, sessionId)
+);
+
+create table PgSchemaStep (
+  stepNumber integer not null,
+  sessionId varchar(100) not null,
+  siteSchema text not null,
+  l10n text not null,
+  localizedValues text not null,
+  nodeTypeCount integer not null,
+  inputTokenCount integer not null,
+  outputTokenCount integer not null,
+  promptTitle varchar(200),
+  primary key (stepNumber, sessionId),
+  foreign key (stepNumber, sessionId) references PgStep(stepNumber, sessionId)
+);
+
+create table PgGeneratedSiteStep (
+  siteId varchar(100) not null primary key,
+  stepNumber integer not null,
+  sessionId varchar(100) not null,
+  siteUrl varchar(200) not null,
+  loginEmail varchar(100) not null,
+  loginPassword varchar(100) not null,
+  localizedValues text not null,
+  contentEntryCount integer,
+  contentInputTokenCount integer,
+  contentOutputTokenCount integer,
+  contentErrors text,
+  unique (stepNumber, sessionId),
+  foreign key (stepNumber, sessionId) references PgStep(stepNumber, sessionId)
+);
+
+create table PgIssueEvent(
+  id integer not null primary key autoincrement,
+  sessionId varchar(100) not null references PgSession(id),
+  createdAt timestamp not null default current_timestamp,
+  eventType varchar(100) not null,
+  issueMessage text,
+  llmTaskName varchar(100),
+  stepNumber integer
+);

package/gen-backend/dist/commands/execute-command.js

@@ -1,15 +1,22 @@
 import { messageOf } from "@paroi/data-formatters-lib";
-import { updateSession } from "../db/db.queries.js";
+import { fetchWorkSession, loadStep } from "../db/db-read.queries.js";
+import { insertIssueEvent, updateSession } from "../db/db-write.queries.js";
 import { invokeMessageGuard } from "../generator/llm-queries/invoke-message-guard.js";
-import { invokeNewSiteAnalysis } from "../generator/llm-queries/invoke-new-site-analysis.js";
-import { invokeUpdateSiteSchema } from "../generator/llm-queries/invoke-update-site-schema.js";
+import { startInitialAnalysis } from "../generator/llm-queries/invoke-new-site-analysis.js";
+import { startUpdateSiteSchema } from "../generator/llm-queries/invoke-update-site-schema.js";
 import { generateSite } from "../generator/site-generator/site-generator.js";
-import { newSession, verifySessionToken } from "./generator-session.js";
+import { newSessionCommand, renewSessionCommand, verifySessionToken } from "./generator-session.js";
 export async function executeCommand(commandCtx, input) {
     if (input.command === "newSession") {
         return {
             success: true,
-            result: await newSession(commandCtx, input),
+            result: await newSessionCommand(commandCtx, input),
+        };
+    }
+    if (input.command === "renewSession") {
+        return {
+            success: true,
+            result: await renewSessionCommand(commandCtx, input),
         };
     }
     const { sessionId } = await verifySessionToken(commandCtx, input.sessionToken);
@@ -18,13 +25,32 @@ export async function executeCommand(commandCtx, input) {
         sessionId,
     };
     try {
+        if (input.command === "setLanguage") {
+            await updateSession(ctx, { language: input.language });
+            return {
+                success: true,
+                result: { updated: true },
+            };
+        }
+        if (input.command === "loadWorkSession") {
+            return {
+                success: true,
+                result: await fetchWorkSession(ctx),
+            };
+        }
+        if (input.command === "loadStep") {
+            return {
+                success: true,
+                result: await loadStep(ctx, input.stepNumber),
+            };
+        }
         if (input.command === "createSiteSchema") {
             const errorResponse = await invokeMessageGuard(ctx, input);
             if (errorResponse)
                 return errorResponse;
             return {
                 success: true,
-                result: await invokeNewSiteAnalysis(ctx, input),
+                result: await startInitialAnalysis(ctx, input),
             };
         }
         if (input.command === "updateSiteSchema") {
@@ -33,7 +59,7 @@ export async function executeCommand(commandCtx, input) {
                 return errorResponse;
             return {
                 success: true,
-                result: await invokeUpdateSiteSchema(ctx, input),
+                result: await startUpdateSiteSchema(ctx, input),
             };
         }
         if (input.command === "generateSite") {
@@ -50,10 +76,10 @@ export async function executeCommand(commandCtx, input) {
     }
     catch (error) {
         try {
-            await updateSession(ctx, { status: "error", errorMessage: messageOf(error) });
+            await insertIssueEvent(ctx, { eventType: "unexpectedError", issueMessage: messageOf(error) });
         }
         catch {
-            ctx.logger.error("Failed to update session error message", error);
+            ctx.logger.error("Failed to insert issue event", error);
         }
         throw error;
     }

package/gen-backend/dist/commands/generator-session.js

@@ -1,16 +1,56 @@
 import { ApiError } from "@paroicms/public-server-lib";
-import { randomUUID } from "node:crypto";
-import { insertSession, readSession } from "../db/db.queries.js";
+import { nanoid } from "nanoid";
+import { getInvalidSessionError } from "../db/db-read.queries.js";
+import { insertSession, updateSession } from "../db/db-write.queries.js";
 const { sign, verify } = (await import("jsonwebtoken")).default;
-export async function newSession(ctx, command) {
+export async function newSessionCommand(ctx, command) {
+    const { service } = ctx;
+    const { recaptchaToken, language } = command;
+    const isValid = await service.validateRecaptchaResponse(recaptchaToken);
+    if (!isValid)
+        throw new ApiError("Invalid reCAPTCHA token", 400);
+    const date = new Date();
+    const compressedTs = `${date.toISOString().replace(/[-:]/g, "").split(".")[0]}Z`;
+    const sessionId = `${compressedTs}-${nanoid()}`;
+    const token = sign({ sessionId }, ctx.jwtSecret, { expiresIn: "48h" });
+    const expireAt = new Date(date.getTime() + 48 * 60 * 60 * 1000);
+    await insertSession(ctx, { sessionId, language, expireAt });
+    return { token };
+}
+/**
+ * Renews a session token and extends its expiration time
+ */
+export async function renewSessionCommand(ctx, command) {
     const { service } = ctx;
     const { recaptchaToken } = command;
     const isValid = await service.validateRecaptchaResponse(recaptchaToken);
     if (!isValid)
         throw new ApiError("Invalid reCAPTCHA token", 400);
-    const sessionId = randomUUID();
+    let payload;
+    try {
+        // When renewing, we verify the token but allow expired tokens
+        payload = verify(command.sessionToken, ctx.jwtSecret, { ignoreExpiration: true });
+    }
+    catch (error) {
+        if (error.name === "JsonWebTokenError")
+            throw new ApiError("Invalid session token", 401);
+        throw error;
+    }
+    if (!payload || !("sessionId" in payload) || typeof payload.sessionId !== "string") {
+        throw new ApiError("Invalid session token", 401);
+    }
+    const sessionId = payload.sessionId;
+    // Check if the session is valid (not deleted, not too many steps)
+    const errorMessage = await getInvalidSessionError(ctx, sessionId);
+    if (errorMessage && errorMessage !== "expired") {
+        throw new ApiError(`Invalid session "${sessionId}": ${errorMessage}`, 401);
+    }
+    // Generate new expiration time - 48 hours from now
+    const expireAt = new Date(Date.now() + 48 * 60 * 60 * 1000);
+    // Update the session's expiration time
+    await updateSession({ ...ctx, sessionId }, { expireAt });
+    // Generate a new token
     const token = sign({ sessionId }, ctx.jwtSecret, { expiresIn: "48h" });
-    await insertSession(ctx, { sessionId });
     return { token };
 }
 /**
@@ -32,10 +72,9 @@ export async function verifySessionToken(ctx, token) {
         throw new ApiError("Invalid session token", 401);
     }
     const sessionId = payload.sessionId;
-    const session = await readSession(ctx, sessionId);
-    if (!session)
-        throw new ApiError(`Missing session "${sessionId}"`, 500);
-    if (session.promptCount >= 20)
-        throw new ApiError("Session consumed", 401);
+    const errorMessage = await getInvalidSessionError(ctx, sessionId);
+    if (errorMessage) {
+        throw new ApiError(`Invalid session "${sessionId}": ${errorMessage}`, 401);
+    }
     return { sessionId };
 }

package/gen-backend/dist/data-format.js

@@ -1,4 +1,4 @@
-import { boolVal, isObj, strVal, strValOrUndef } from "@paroi/data-formatters-lib";
+import { boolVal, isObj, nbVal, strVal, strValOrUndef } from "@paroi/data-formatters-lib";
 import { ApiError } from "@paroicms/public-server-lib";
 export function formatGeneratorPluginConfiguration(pluginConf) {
     const anthropicApiKey = strValOrUndef(pluginConf.anthropicApiKey, { varName: "anthropicApiKey" });
@@ -17,9 +17,37 @@ export function formatGeneratorCommand(data) {
     if (command === "newSession") {
         return {
             command: "newSession",
+            language: strVal(data.language, { varName: "language" }),
             recaptchaToken: strVal(data.recaptchaToken, { varName: "recaptchaToken" }),
         };
     }
+    if (command === "renewSession") {
+        return {
+            command: "renewSession",
+            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
+            recaptchaToken: strVal(data.recaptchaToken, { varName: "recaptchaToken" }),
+        };
+    }
+    if (command === "setLanguage") {
+        return {
+            command: "setLanguage",
+            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
+            language: strVal(data.language, { varName: "language" }),
+        };
+    }
+    if (command === "loadWorkSession") {
+        return {
+            command: "loadWorkSession",
+            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
+        };
+    }
+    if (command === "loadStep") {
+        return {
+            command: "loadStep",
+            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
+            stepNumber: nbVal(data.stepNumber, { varName: "stepNumber" }),
+        };
+    }
     if (command === "createSiteSchema") {
         return {
             command: "createSiteSchema",
@@ -32,15 +60,15 @@ export function formatGeneratorCommand(data) {
             command: "updateSiteSchema",
             sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
             prompt: formatPrompt(data.prompt),
-            generatedSchema: data.generatedSchema,
+            fromStepNumber: nbVal(data.fromStepNumber),
         };
     }
     if (command === "generateSite") {
         return {
             command: "generateSite",
             sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
-            generatedSchema: data.generatedSchema,
-            withFakeContent: boolVal(data.withFakeContent, { varName: "withFakeContent" }),
+            fromStepNumber: nbVal(data.fromStepNumber),
+            withSampleData: boolVal(data.withSampleData, { varName: "withSampleData" }),
         };
     }
     throw new ApiError(`Invalid command: ${command}`, 400);

package/gen-backend/dist/db/db-init.js

@@ -4,11 +4,12 @@ import { projectDir } from "../context.js";
 import { currentDbSchemaVersion, dbSchemaName, migrateSiteGeneratorDb } from "./ddl-migration.js";
 export async function createOrOpenSiteGeneratorConnection({ sqliteFile, canCreate, logger, }) {
     const { logNextQuery, knexLogger } = createSqlLogger({ logger, dbSchemaName });
+    const ddlFile = join(projectDir, "ddl", "site-generator.ddl.sql");
     const { cn } = await createOrOpenSqliteConnection({
         canCreate,
         dbSchemaName,
         sqliteFile,
-        ddlFile: join(projectDir, "ddl", "site-generator.ddl.sql"),
+        ddlFile,
         migrateDb,
         knexLogger,
         logger,
@@ -24,6 +25,7 @@ export async function createOrOpenSiteGeneratorConnection({ sqliteFile, canCreat
         await migrateSiteGeneratorDb(cn, {
             fromVersion: dbVersion,
             logger,
+            ddlFile,
         });
         return {
             migrated: true,

package/gen-backend/dist/db/db-read.queries.js

@@ -0,0 +1,142 @@
+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,
+                backOfficeUrl: `${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,
+    });
+}

package/gen-backend/dist/db/db-write.queries.js

@@ -0,0 +1,144 @@
+import { strVal } from "@paroi/data-formatters-lib";
+import { sqliteDateTime } from "@paroicms/internal-server-lib";
+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,
+        });
+    });
+}
+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");
+    return { id: strVal(inserted.id) };
+}

package/gen-backend/dist/db/ddl-migration.js

@@ -1,12 +1,14 @@
+import { executeDdl } from "@paroicms/internal-server-lib";
 export const dbSchemaName = "site-generator";
-export const currentDbSchemaVersion = 1;
-export async function migrateSiteGeneratorDb(_cn, { fromVersion, logger }) {
+export const currentDbSchemaVersion = 2;
+export async function migrateSiteGeneratorDb(cn, { fromVersion, logger, ddlFile }) {
     const toVersion = currentDbSchemaVersion;
-    const currentVersion = fromVersion;
+    let currentVersion = fromVersion;
     if (currentVersion === 1) {
-        // await cn.raw("...");
-        // await setMetadataDbSchemaVersion(cn, { dbSchemaName, value: 2 });
-        // currentVersion = 2;
+        await cn.raw("drop table PaGenSession");
+        await cn.raw("drop table PaMetadata");
+        await executeDdl(cn, ddlFile);
+        currentVersion = currentDbSchemaVersion;
     }
     if (currentVersion !== toVersion) {
         throw new Error(`version of ${dbSchemaName} database should be '${toVersion}', but is '${currentVersion}'`);

package/gen-backend/dist/db/formatters.js

@@ -0,0 +1,46 @@
+import { strVal, strValOrUndef } from "@paroi/data-formatters-lib";
+export function ensureType(value) {
+    return value;
+}
+export function formatStepKind(value) {
+    const v = strVal(value);
+    if (v === "initialSchema" || v === "updateSchema" || v === "generateSite") {
+        return v;
+    }
+    throw new Error(`Invalid step kind "${v}"`);
+}
+export function formatSchemaStepKind(value) {
+    const v = strVal(value);
+    if (v === "initialSchema" || v === "updateSchema") {
+        return v;
+    }
+    throw new Error(`Invalid schema step kind "${v}"`);
+}
+export function formatGeneratedSiteStepKind(value) {
+    const v = strVal(value);
+    if (v === "generateSite") {
+        return v;
+    }
+    throw new Error(`Invalid generated site step kind "${v}"`);
+}
+export function formatStepStatus(value) {
+    const v = strVal(value);
+    if (v === "completed" || v === "pending" || v === "failed" || v === "noEffect") {
+        return v;
+    }
+    throw new Error(`Invalid step status "${v}"`);
+}
+export function formatActivityCode(value) {
+    const v = strValOrUndef(value);
+    if (v === undefined)
+        return;
+    if (v === "initial1" ||
+        v === "initial2" ||
+        v === "updating1" ||
+        v === "updating2" ||
+        v === "generatingSite" ||
+        v === "generatingContent") {
+        return v;
+    }
+    throw new Error(`Invalid activity code "${v}"`);
+}