@paroicms/site-generator-plugin 0.15.1 → 0.16.0

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

@@ -1,4 +1,4 @@
-import { messageOf } from "@paroi/data-formatters-lib";
+import { messageOf } from "@paroicms/public-anywhere-lib";
 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";

package/gen-backend/dist/context.js

@@ -1,8 +1,8 @@
-import { strVal } from "@paroi/data-formatters-lib";
-import { resolveModuleDirectory } from "@paroicms/public-server-lib";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { resolveModuleDirectory } from "@paroicms/public-server-lib";
+import { type } from "arktype";
 export const projectDir = resolveModuleDirectory(import.meta.url, { parent: true });
 export const packageDir = dirname(projectDir);
-export const pluginVersion = strVal(JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8")).version);
+export const pluginVersion = type({ version: "string", "+": "ignore" }).assert(JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8"))).version;
 export const SLUG = "site-generator";

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

@@ -1,82 +1,144 @@
-import { boolVal, isObj, nbVal, strVal, strValOrUndef } from "@paroi/data-formatters-lib";
+import { isObj } from "@paroicms/public-anywhere-lib";
 import { ApiError } from "@paroicms/public-server-lib";
-export function formatGeneratorPluginConfiguration(pluginConf) {
-    const anthropicApiKey = strValOrUndef(pluginConf.anthropicApiKey, { varName: "anthropicApiKey" });
-    const mistralApiKey = strValOrUndef(pluginConf.mistralApiKey, { varName: "mistralApiKey" });
-    const packName = strValOrUndef(pluginConf.packName, { varName: "packName" });
-    const debugDir = strValOrUndef(pluginConf.debugDir, { varName: "debugDir" });
-    if (!anthropicApiKey || !mistralApiKey || !packName) {
-        throw new Error(`Invalid configuration for plugin "@paroicms/site-generator-plugin"`);
+import { type } from "arktype";
+export const GeneratorPluginConfigurationAT = type({
+    anthropicApiKey: "string",
+    mistralApiKey: "string",
+    packName: "string",
+    "googleRecaptchaSiteKey?": "string|undefined",
+    "debugDir?": "string|undefined",
+    "+": "reject",
+}).pipe((data) => data);
+const BaseCommandAT = type({
+    command: "string",
+    "+": "ignore",
+});
+const NewSessionCommandAT = type({
+    command: '"newSession"',
+    language: "string",
+    recaptchaToken: "string",
+    "+": "reject",
+});
+const RenewSessionCommandAT = type({
+    command: '"renewSession"',
+    sessionToken: "string",
+    recaptchaToken: "string",
+    "+": "reject",
+});
+const SetLanguageCommandAT = type({
+    command: '"setLanguage"',
+    sessionToken: "string",
+    language: "string",
+    "+": "reject",
+});
+const LoadWorkSessionCommandAT = type({
+    command: '"loadWorkSession"',
+    sessionToken: "string",
+    "+": "reject",
+});
+const LoadStepCommandAT = type({
+    command: '"loadStep"',
+    sessionToken: "string",
+    stepNumber: "number",
+    "+": "reject",
+});
+const CreateSiteSchemaCommandAT = type({
+    command: '"createSiteSchema"',
+    sessionToken: "string",
+    prompt: "string",
+    "+": "reject",
+});
+const UpdateSiteSchemaCommandAT = type({
+    command: '"updateSiteSchema"',
+    sessionToken: "string",
+    prompt: "string",
+    fromStepNumber: "number",
+    "+": "reject",
+});
+const GenerateSiteCommandAT = type({
+    command: '"generateSite"',
+    sessionToken: "string",
+    fromStepNumber: "number",
+    withSampleData: "boolean",
+    "+": "reject",
+});
+const PromptAT = type("string").narrow((prompt) => {
+    if (prompt.length > 5000) {
+        throw new ApiError("Prompt is too long", 400);
     }
-    return { anthropicApiKey, mistralApiKey, packName, debugDir };
-}
+    return true;
+});
 export function formatGeneratorCommand(data) {
     if (!isObj(data))
         throw new ApiError("Invalid input", 400);
-    const command = strVal(data.command, { varName: "command" });
+    const baseCommand = BaseCommandAT.assert(data);
+    const command = baseCommand.command;
     if (command === "newSession") {
+        const validated = NewSessionCommandAT.assert(data);
         return {
             command: "newSession",
-            language: strVal(data.language, { varName: "language" }),
-            recaptchaToken: strVal(data.recaptchaToken, { varName: "recaptchaToken" }),
+            language: validated.language,
+            recaptchaToken: validated.recaptchaToken,
         };
     }
     if (command === "renewSession") {
+        const validated = RenewSessionCommandAT.assert(data);
         return {
             command: "renewSession",
-            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
-            recaptchaToken: strVal(data.recaptchaToken, { varName: "recaptchaToken" }),
+            sessionToken: validated.sessionToken,
+            recaptchaToken: validated.recaptchaToken,
         };
     }
     if (command === "setLanguage") {
+        const validated = SetLanguageCommandAT.assert(data);
         return {
             command: "setLanguage",
-            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
-            language: strVal(data.language, { varName: "language" }),
+            sessionToken: validated.sessionToken,
+            language: validated.language,
         };
     }
     if (command === "loadWorkSession") {
+        const validated = LoadWorkSessionCommandAT.assert(data);
         return {
             command: "loadWorkSession",
-            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
+            sessionToken: validated.sessionToken,
         };
     }
     if (command === "loadStep") {
+        const validated = LoadStepCommandAT.assert(data);
         return {
             command: "loadStep",
-            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
-            stepNumber: nbVal(data.stepNumber, { varName: "stepNumber" }),
+            sessionToken: validated.sessionToken,
+            stepNumber: validated.stepNumber,
         };
     }
     if (command === "createSiteSchema") {
+        const validated = CreateSiteSchemaCommandAT.assert(data);
+        const prompt = PromptAT.assert(validated.prompt);
         return {
             command: "createSiteSchema",
-            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
-            prompt: formatPrompt(data.prompt),
+            sessionToken: validated.sessionToken,
+            prompt,
         };
     }
     if (command === "updateSiteSchema") {
+        const validated = UpdateSiteSchemaCommandAT.assert(data);
+        const prompt = PromptAT.assert(validated.prompt);
         return {
             command: "updateSiteSchema",
-            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
-            prompt: formatPrompt(data.prompt),
-            fromStepNumber: nbVal(data.fromStepNumber),
+            sessionToken: validated.sessionToken,
+            prompt,
+            fromStepNumber: validated.fromStepNumber,
         };
     }
     if (command === "generateSite") {
+        const validated = GenerateSiteCommandAT.assert(data);
         return {
             command: "generateSite",
-            sessionToken: strVal(data.sessionToken, { varName: "sessionToken" }),
-            fromStepNumber: nbVal(data.fromStepNumber),
-            withSampleData: boolVal(data.withSampleData, { varName: "withSampleData" }),
+            sessionToken: validated.sessionToken,
+            fromStepNumber: validated.fromStepNumber,
+            withSampleData: validated.withSampleData,
         };
     }
     throw new ApiError(`Invalid command: ${command}`, 400);
 }
-function formatPrompt(val) {
-    const prompt = strVal(val, { varName: "prompt" });
-    if (prompt.length > 5000) {
-        throw new ApiError("Prompt is too long", 400);
-    }
-    return prompt;
-}

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

@@ -1,5 +1,5 @@
-import { createOrOpenSqliteConnection, createSqlLogger, getMetadataDbSchemaVersion, } from "@paroicms/internal-server-lib";
 import { join } from "node:path";
+import { createOrOpenSqliteConnection, createSqlLogger, getMetadataDbSchemaVersion, } from "@paroicms/internal-server-lib";
 import { projectDir } from "../context.js";
 import { currentDbSchemaVersion, dbSchemaName, migrateSiteGeneratorDb } from "./ddl-migration.js";
 export async function createOrOpenSiteGeneratorConnection({ sqliteFile, canCreate, logger, }) {

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

@@ -1,5 +1,12 @@
-import { dateVal, nbVal, strVal, strValOrUndef } from "@paroi/data-formatters-lib";
+import { parseSqliteDateTime } from "@paroicms/internal-server-lib";
+import { type } from "arktype";
 import { ensureType, formatActivityCode, formatStepKind, formatStepStatus } from "./formatters.js";
+const SessionRowAT = type({
+    id: "string",
+    expireAt: "string|number|Date",
+    successStepCount: "number",
+    "+": "reject",
+});
 export async function getInvalidSessionError(ctx, sessionId) {
     const { cn } = ctx;
     const row = await cn("PgSession as s")
@@ -10,13 +17,19 @@ export async function getInvalidSessionError(ctx, sessionId) {
         .first();
     if (!row)
         return "not found";
-    const successStepCount = nbVal(row.successStepCount);
-    if (successStepCount >= 20)
+    const validated = SessionRowAT.assert(row);
+    if (validated.successStepCount >= 20)
         return "too many steps";
-    const expireAt = dateVal(row.expireAt).getTime();
+    const expireAt = parseSqliteDateTime(validated.expireAt).getTime();
     if (expireAt < Date.now())
         return "expired";
 }
+const StepSchemaRowAT = type({
+    siteSchema: "string",
+    l10n: "string",
+    localizedValues: "string",
+    "+": "reject",
+});
 export async function readStepSchema(ctx, stepNumber) {
     const { cn, sessionId } = ctx;
     const row = await cn("PgSchemaStep")
@@ -25,12 +38,20 @@ export async function readStepSchema(ctx, stepNumber) {
         .first();
     if (!row)
         throw new Error(`[${sessionId}] Step "${stepNumber}" not found`);
+    const validated = StepSchemaRowAT.assert(row);
     return {
-        siteSchema: JSON.parse(strVal(row.siteSchema)),
-        l10n: JSON.parse(strVal(row.l10n)),
-        localizedValues: JSON.parse(strVal(row.localizedValues)),
+        siteSchema: JSON.parse(validated.siteSchema),
+        l10n: JSON.parse(validated.l10n),
+        localizedValues: JSON.parse(validated.localizedValues),
     };
 }
+const WorkSessionRowAT = type({
+    id: "string",
+    createdAt: "string|number|Date",
+    expireAt: "string|number|Date",
+    language: "string",
+    "+": "reject",
+});
 export async function fetchWorkSession(ctx) {
     const { cn, sessionId } = ctx;
     const row = await cn("PgSession")
@@ -40,12 +61,13 @@ export async function fetchWorkSession(ctx) {
     if (!row) {
         throw new Error(`Session not found: ${sessionId}`);
     }
+    const validated = WorkSessionRowAT.assert(row);
     const steps = await loadSessionSteps(ctx);
     return {
-        id: strVal(row.id),
-        createdAt: dateVal(row.createdAt).toISOString(),
-        expireAt: dateVal(row.expireAt).toISOString(),
-        language: strVal(row.language),
+        id: validated.id,
+        createdAt: parseSqliteDateTime(validated.createdAt).toISOString(),
+        expireAt: parseSqliteDateTime(validated.expireAt).toISOString(),
+        language: validated.language,
         steps,
     };
 }
@@ -78,51 +100,90 @@ function buildStepsQuery(cn) {
         "i.sessionId": "s.sessionId",
     });
 }
+const StepRowAT = type({
+    stepNumber: "number",
+    explanation: "string|null",
+    status: "string",
+    kind: "string",
+    currentActivity: "string|null",
+    promptTitle: "string|null",
+    siteSchema: "string|null",
+    l10n: "string|null",
+    schemaLocalizedValues: "string|null",
+    siteId: "string|null",
+    siteLocalizedValues: "string|null",
+    siteUrl: "string|null",
+    loginEmail: "string|null",
+    loginPassword: "string|null",
+    "+": "reject",
+}).pipe((r) => ({
+    ...r,
+    explanation: r.explanation ?? undefined,
+    currentActivity: r.currentActivity ?? undefined,
+    promptTitle: r.promptTitle ?? undefined,
+    siteSchema: r.siteSchema ?? undefined,
+    l10n: r.l10n ?? undefined,
+    schemaLocalizedValues: r.schemaLocalizedValues ?? undefined,
+    siteId: r.siteId ?? undefined,
+    siteLocalizedValues: r.siteLocalizedValues ?? undefined,
+    siteUrl: r.siteUrl ?? undefined,
+    loginEmail: r.loginEmail ?? undefined,
+    loginPassword: r.loginPassword ?? undefined,
+}));
 function mapRowToStep(row, sessionId) {
+    const validated = StepRowAT.assert(row);
     const baseStep = {
-        stepNumber: nbVal(row.stepNumber),
-        explanation: strValOrUndef(row.explanation),
+        stepNumber: validated.stepNumber,
+        explanation: validated.explanation,
     };
-    const status = formatStepStatus(row.status);
-    const kind = formatStepKind(row.kind);
+    const status = formatStepStatus(validated.status);
+    const kind = formatStepKind(validated.kind);
     if (status === "pending") {
         return ensureType({
             ...baseStep,
             status,
             kind,
-            currentActivity: formatActivityCode(row.currentActivity),
+            currentActivity: formatActivityCode(validated.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}"`);
+            if (!validated.siteSchema) {
+                throw new Error(`[Session "${sessionId}"] PgSchemaStep row is missing for completed step "${validated.stepNumber}"`);
+            }
+            if (!validated.l10n || !validated.schemaLocalizedValues) {
+                throw new Error(`[Session "${sessionId}"] Missing schema data for completed step "${validated.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)),
+                promptTitle: validated.promptTitle,
+                siteSchema: JSON.parse(validated.siteSchema),
+                l10n: JSON.parse(validated.l10n),
+                localizedValues: JSON.parse(validated.schemaLocalizedValues),
             });
         }
         if (kind === "generateSite") {
-            if (!row.siteId) {
-                throw new Error(`[Session "${sessionId}"] PgGeneratedSiteStep row is missing for completed step "${row.stepNumber}"`);
+            if (!validated.siteId) {
+                throw new Error(`[Session "${sessionId}"] PgGeneratedSiteStep row is missing for completed step "${validated.stepNumber}"`);
+            }
+            if (!validated.siteUrl ||
+                !validated.loginEmail ||
+                !validated.loginPassword ||
+                !validated.siteLocalizedValues) {
+                throw new Error(`[Session "${sessionId}"] Missing generated site data for completed step "${validated.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)),
+                siteId: validated.siteId,
+                siteUrl: validated.siteUrl,
+                adminUiUrl: `${validated.siteUrl}/adm`,
+                loginEmail: validated.loginEmail,
+                loginPassword: validated.loginPassword,
+                localizedValues: JSON.parse(validated.siteLocalizedValues),
             });
         }
         throw new Error(`[Session "${sessionId}"] invalid step kind "${kind}"`);

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

@@ -1,5 +1,5 @@
-import { strVal } from "@paroi/data-formatters-lib";
 import { sqliteDateTime } from "@paroicms/internal-server-lib";
+import { type } from "arktype";
 export async function insertSession(ctx, values) {
     const { cn } = ctx;
     await cn("PgSession").insert({
@@ -128,6 +128,7 @@ export async function updateGeneratedSiteStepSetAsCompleted(ctx, stepHandle, val
         });
     });
 }
+const InsertedAT = type({ id: "string", "+": "reject" });
 export async function insertIssueEvent(ctx, values) {
     const { cn, sessionId } = ctx;
     const [inserted] = await cn("PgIssueEvent")
@@ -140,5 +141,5 @@ export async function insertIssueEvent(ctx, values) {
         siteId: values.siteId,
     })
         .returning("id");
-    return { id: strVal(inserted.id) };
+    return InsertedAT.assert(inserted);
 }

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

@@ -1,46 +1,24 @@
-import { strVal, strValOrUndef } from "@paroi/data-formatters-lib";
+import { type } from "arktype";
 export function ensureType(value) {
     return value;
 }
+const StepKindAT = type('"initialSchema"|"updateSchema"|"generateSite"');
 export function formatStepKind(value) {
-    const v = strVal(value);
-    if (v === "initialSchema" || v === "updateSchema" || v === "generateSite") {
-        return v;
-    }
-    throw new Error(`Invalid step kind "${v}"`);
+    return StepKindAT.assert(value);
 }
+const SchemaStepKindAT = type('"initialSchema"|"updateSchema"');
 export function formatSchemaStepKind(value) {
-    const v = strVal(value);
-    if (v === "initialSchema" || v === "updateSchema") {
-        return v;
-    }
-    throw new Error(`Invalid schema step kind "${v}"`);
+    return SchemaStepKindAT.assert(value);
 }
+const GeneratedSiteStepKindAT = type('"generateSite"');
 export function formatGeneratedSiteStepKind(value) {
-    const v = strVal(value);
-    if (v === "generateSite") {
-        return v;
-    }
-    throw new Error(`Invalid generated site step kind "${v}"`);
+    return GeneratedSiteStepKindAT.assert(value);
 }
+const StepStatusAT = type('"completed"|"pending"|"failed"|"noEffect"');
 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}"`);
+    return StepStatusAT.assert(value);
 }
+const ActivityCodeAT = type('"initial1"|"initial2"|"updating1"|"updating2"|"generatingSite"|"generatingContent"|undefined');
 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}"`);
+    return ActivityCodeAT.assert(value);
 }

package/gen-backend/dist/generator/lib/calling-llm-mistral.js

@@ -1,4 +1,4 @@
-import { messageOf } from "@paroi/data-formatters-lib";
+import { messageOf } from "@paroicms/public-anywhere-lib";
 let seq = 0;
 export async function batchInvokeMinistral(ctx, prompts, options) {
     const startTime = Date.now();

package/gen-backend/dist/generator/lib/create-prompt.js

@@ -1,6 +1,6 @@
-import { connectorPackageDir } from "@paroicms/connector";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { connectorPackageDir } from "@paroicms/connector";
 import { projectDir } from "../../context.js";
 import { buildPromptTemplate } from "./prompt-template.js";
 const contextContent = await readPromptFile("0-context.md");

package/gen-backend/dist/generator/lib/debug-utils.js

@@ -1,5 +1,5 @@
-import { messageOf } from "@paroi/data-formatters-lib";
 import { ensureDirectory } from "@paroicms/internal-server-lib";
+import { messageOf } from "@paroicms/public-anywhere-lib";
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { estimateTokenCount } from "./llm-tokens.js";

package/gen-backend/dist/generator/lib/session-utils.js

@@ -1,4 +1,4 @@
-import { messageOf } from "@paroi/data-formatters-lib";
+import { messageOf } from "@paroicms/public-anywhere-lib";
 import { insertIssueEvent, updateStep } from "../../db/db-write.queries.js";
 export function safeCallStep(ctx, stepHandle, cb) {
     void safeCallStepExec(ctx, stepHandle, cb);

package/gen-backend/dist/generator/lib/tasks.js

@@ -1,4 +1,4 @@
-import { messageOf } from "@paroi/data-formatters-lib";
+import { messageOf } from "@paroicms/public-anywhere-lib";
 export function createTaskCollector(ctx) {
     const tasks = [];
     return {

package/gen-backend/dist/generator/llm-queries/invoke-message-guard.js

@@ -1,4 +1,4 @@
-import { boolVal, listValOrUndef, strVal, strValOrUndef, } from "@paroi/data-formatters-lib";
+import { type } from "arktype";
 import { insertIssueEvent } from "../../db/db-write.queries.js";
 import { invokeClaude } from "../lib/calling-llm-anthropic.js";
 import { createPromptTemplate } from "../lib/create-prompt.js";
@@ -7,7 +7,13 @@ import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
 const guardPrompt = await createPromptTemplate({
     filename: "message-guard.md",
 });
-const invalidCauses = new Set(["rude", "malicious", "outOfScope", "technicalLimits", "noSense"]);
+const MessageGuardReportAT = type({
+    "language?": "string|undefined",
+    valid: "boolean",
+    "causes?": '("rude"|"malicious"|"outOfScope"|"technicalLimits"|"noSense")[]|undefined',
+    "explanation?": "string|undefined",
+    "+": "reject",
+});
 export async function invokeMessageGuard(ctx, input, { skipOutOfScopeCheck = false } = {}) {
     const llmTaskName = "guard";
     const llmInput = {
@@ -34,7 +40,7 @@ export async function invokeMessageGuard(ctx, input, { skipOutOfScopeCheck = fal
             format: "yaml",
         },
     ]);
-    const report = formatMessageGuardReport(rawReport.guard);
+    const report = MessageGuardReportAT.assert(rawReport.guard);
     if (report.causes && skipOutOfScopeCheck) {
         report.causes = report.causes.filter((cause) => cause !== "outOfScope");
         if (report.causes.length === 0) {
@@ -89,17 +95,3 @@ function getCauseLabel(cause, language) {
             return cause;
     }
 }
-function formatMessageGuardReport(rawReport) {
-    return {
-        language: strValOrUndef(rawReport.language, { varName: "language" }),
-        valid: boolVal(rawReport.valid, { varName: "valid" }),
-        causes: listValOrUndef(rawReport.causes, formatGuardInvalidCause),
-        explanation: strValOrUndef(rawReport.explanation, { varName: "explanation" }),
-    };
-}
-function formatGuardInvalidCause(cause) {
-    const v = strVal(cause, { varName: "cause" });
-    if (!invalidCauses.has(v))
-        throw new Error(`Invalid cause: "${v}"`);
-    return v;
-}

package/gen-backend/dist/generator/site-generator/site-generator.js

@@ -1,7 +1,7 @@
-import { generateSlug } from "@paroicms/public-anywhere-lib";
 import { randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { generateSlug } from "@paroicms/public-anywhere-lib";
 import { loadStep, readStepSchema } from "../../db/db-read.queries.js";
 import { insertStep, saveGeneratedSiteStep, } from "../../db/db-write.queries.js";
 import { fillSiteWithFakeContent } from "../fake-content-generator/create-database-with-fake-content.js";

package/gen-backend/dist/lib/create-raw-context.js

@@ -1,7 +1,7 @@
+import { join } from "node:path";
 import Anthropic from "@anthropic-ai/sdk";
 import { Mistral } from "@mistralai/mistralai";
 import { readOrCreateJwtSecretSync } from "@paroicms/internal-server-lib";
-import { join } from "node:path";
 export function createRawContext(service, options) {
     const { cn, logNextQuery, pluginConf, debugDir } = options;
     const packConf = service.connector.getSitePackConf(pluginConf.packName);

package/gen-backend/dist/plugin.js

@@ -1,10 +1,10 @@
-import { messageOf } from "@paroi/data-formatters-lib";
 import { pathExists } from "@paroicms/internal-server-lib";
+import { messageOf } from "@paroicms/public-anywhere-lib";
 import { ApiError, escapeHtml, makeStylesheetLinkAsyncTag, } from "@paroicms/public-server-lib";
 import { join } from "node:path";
 import { executeCommand } from "./commands/execute-command.js";
 import { SLUG, packageDir, pluginVersion } from "./context.js";
-import { formatGeneratorCommand, formatGeneratorPluginConfiguration } from "./data-format.js";
+import { GeneratorPluginConfigurationAT, formatGeneratorCommand } from "./data-format.js";
 import { createOrOpenSiteGeneratorConnection } from "./db/db-init.js";
 import { initializeImageNames } from "./generator/lib/images-lib.js";
 import { createRawContext } from "./lib/create-raw-context.js";
@@ -19,7 +19,7 @@ const plugin = {
             canCreate: true,
             logger: service.logger,
         });
-        const pluginConf = formatGeneratorPluginConfiguration(service.configuration);
+        const pluginConf = GeneratorPluginConfigurationAT.assert(service.configuration);
         let debugDir = pluginConf.debugDir;
         if (debugDir) {
             if (!(await pathExists(debugDir))) {
@@ -47,7 +47,7 @@ const plugin = {
                 return;
             return [
                 makeStylesheetLinkAsyncTag(`${service.pluginAssetsUrl}/gen-front.css`),
-                `<script type="module" src="${escapeHtml(`${service.pluginAssetsUrl}/gen-front.mjs`)}" class="js-script-${SLUG}" data-google-recaptcha-site-key="${escapeHtml(service.configuration.googleRecaptchaSiteKey)}" async></script>`,
+                `<script type="module" src="${escapeHtml(`${service.pluginAssetsUrl}/gen-front.mjs`)}" class="js-script-${SLUG}" data-google-recaptcha-site-key="${escapeHtml(pluginConf.googleRecaptchaSiteKey)}" async></script>`,
             ];
         });
         service.setPublicApiHandler(async (service, httpContext, relativePath) => {
@@ -64,6 +64,7 @@ const plugin = {
                 command = formatGeneratorCommand(req.body);
             }
             catch (error) {
+                service.logger.error("Invalid command:", error);
                 res.status(400).send({ status: 400, message: messageOf(error) });
                 return;
             }