@paroicms/site-generator-plugin 0.27.8 → 0.28.0

package/backend/dist/generator/fake-content-generator/content-helpers.js

@@ -15,3 +15,16 @@ export function dedupMessages(messages) {
         return counter && counter > 1 ? `${m} (×${counter})` : m;
     });
 }
+export function getTaxonomyTypeNames(siteSchema) {
+    const taxonomyTypeNames = new Set();
+    for (const nodeType of Object.values(siteSchema.nodeTypes)) {
+        if (!nodeType.fields)
+            continue;
+        for (const field of nodeType.fields) {
+            if (field.dataType === "labeling") {
+                taxonomyTypeNames.add(field.taxonomy);
+            }
+        }
+    }
+    return taxonomyTypeNames;
+}

package/backend/dist/generator/fake-content-generator/create-database-with-fake-content.js

@@ -1,27 +1,16 @@
 import { getPartTypeByName, getRegularDocumentTypeByName, getRoutingDocumentTypeByName, } from "@paroicms/internal-anywhere-lib";
-import { createSimpleTranslator, } from "@paroicms/public-server-lib";
 import { updateGeneratedSiteStepSetAsCompleted, } from "../../db/db-write.queries.js";
 import { createTaskCollector } from "../lib/tasks.js";
 import { createGeneratedContentReport } from "./content-report.js";
 import { addParts, addRegularDocuments, updateRoutingDocument } from "./fill-lnodes.js";
 import { updateSiteFields } from "./fill-site-fields.js";
 import { updateLNodesWithTaxonomies } from "./fill-taxonomy-fields.js";
-export async function fillSiteWithFakeContent(ctx, stepHandle, { regSite, localizedValues }) {
-    const { service } = ctx;
-    const { fqdn } = regSite;
+export async function fillSiteWithFakeContent(ctx, stepHandle, { homeRoutingCluster, localizedValues, }) {
+    const { siteSchema } = ctx;
     const report = createGeneratedContentReport();
-    const { siteSchema, homeRoutingCluster } = await service.connector.loadSiteSchemaAndIds(fqdn);
-    const schemaI18n = createSimpleTranslator({
-        labels: siteSchema.l10n,
-        logger: ctx.logger,
-    });
-    await updateSiteFields(ctx, report, { fqdn, siteSchema, siteTitle: localizedValues.siteTitle });
+    await updateSiteFields(ctx, report, { siteTitle: localizedValues.siteTitle });
     const tasks = createTaskCollector(ctx);
     fillRoutingDocumentAndAddChildren(ctx, tasks, report, {
-        fqdn,
-        siteSchema,
-        schemaI18n,
-    }, {
         clusterNode: homeRoutingCluster,
         nodeType: siteSchema.nodeTypes.home,
     });
@@ -29,9 +18,7 @@ export async function fillSiteWithFakeContent(ctx, stepHandle, { regSite, locali
     const { doneCount, errorMessages } = await promise;
     const results = report.getResults();
     await updateLNodesWithTaxonomies(ctx, {
-        siteSchema,
         idPicker: results.idPicker,
-        fqdn,
     });
     if (errorMessages.length > 0) {
         ctx.logger.warn(`Failed to generate documents:\n  - ${errorMessages.join("\n  - ")}`);
@@ -45,14 +32,14 @@ export async function fillSiteWithFakeContent(ctx, stepHandle, { regSite, locali
         contentErrors: errorMessages.length > 0 ? errorMessages.join("\n  - ") : null,
     });
 }
-function fillRoutingDocumentAndAddChildren(ctx, tasks, report, siteOptions, nodeOptions) {
+function fillRoutingDocumentAndAddChildren(ctx, tasks, report, nodeOptions) {
     const { clusterNode, nodeType } = nodeOptions;
-    const { siteSchema } = siteOptions;
-    tasks.add(() => updateRoutingDocument(ctx, report, siteOptions, nodeOptions));
+    const { siteSchema } = ctx;
+    tasks.add(() => updateRoutingDocument(ctx, report, nodeOptions));
     for (const listType of nodeType.lists ?? []) {
         for (const typeName of listType.parts) {
             const partType = getPartTypeByName(siteSchema, typeName);
-            tasks.add(() => addParts(ctx, report, siteOptions, {
+            tasks.add(() => addParts(ctx, report, {
                 parentNodeId: clusterNode.nodeId,
                 nodeType: partType,
                 documentType: nodeType,
@@ -63,15 +50,15 @@ function fillRoutingDocumentAndAddChildren(ctx, tasks, report, siteOptions, node
         const childType = getRoutingDocumentTypeByName(siteSchema, typeName);
         const childIds = clusterNode.children?.[typeName];
         if (!childIds)
-            throw new Error(`Missing childIds for ${typeName}`);
-        fillRoutingDocumentAndAddChildren(ctx, tasks, report, siteOptions, {
+            continue;
+        fillRoutingDocumentAndAddChildren(ctx, tasks, report, {
             clusterNode: childIds,
             nodeType: childType,
         });
     }
     for (const typeName of nodeType.regularChildren ?? []) {
         const childType = getRegularDocumentTypeByName(siteSchema, typeName);
-        tasks.add(() => addRegularDocuments(ctx, report, siteOptions, {
+        tasks.add(() => addRegularDocuments(ctx, report, {
             parentNodeId: clusterNode.nodeId,
             nodeType: childType,
             documentType: childType,

package/backend/dist/generator/fake-content-generator/create-node-contents.js

@@ -1,4 +1,3 @@
-import { convertMarkdownToTiptap } from "@paroicms/markdown-to-tiptap-json";
 import { getRandomImagePath } from "../lib/images-lib.js";
 export function createNodeContents(options) {
     const { ctx, nodeType, count, generatedContents, outputTags, language } = options;
@@ -21,30 +20,57 @@ export function createNodeContents(options) {
 function createNodeContent(options) {
     const { ctx, nodeType, language, generatedContent, outputTags } = options;
     const fieldTypes = nodeType.fields ?? [];
+    const medias = [];
     if (nodeType.kind === "document") {
         const { title, ...generatedFields } = generatedContent;
-        const fields = toRiFieldSetContent(ctx, generatedFields, outputTags, fieldTypes, language);
-        const featuredImage = nodeType.withFeaturedImage
-            ? {
-                file: getRandomImagePath(),
+        const fields = toUpdateFieldValues(ctx, generatedFields, outputTags, fieldTypes, language);
+        if (nodeType.withFeaturedImage) {
+            medias.push({
+                kind: "featuredImage",
+                filePath: getRandomImagePath(),
+            });
+        }
+        collectMediaFieldEntries(fieldTypes, medias);
+        return { title, fields, medias: medias.length > 0 ? medias : undefined };
+    }
+    const fields = toUpdateFieldValues(ctx, generatedContent, outputTags, fieldTypes, language);
+    collectMediaFieldEntries(fieldTypes, medias);
+    return { fields, medias: medias.length > 0 ? medias : undefined };
+}
+function collectMediaFieldEntries(fieldTypes, medias) {
+    for (const fieldType of fieldTypes) {
+        if (fieldType.storedAs !== "mediaHandle")
+            continue;
+        if (fieldType.withGallery || fieldType.dataType === "gallery") {
+            // Gallery field: generate 3-5 random images
+            const count = 3 + Math.floor(Math.random() * 3);
+            const filePaths = [];
+            for (let i = 0; i < count; i++) {
+                filePaths.push(getRandomImagePath());
             }
-            : undefined;
-        return {
-            title,
-            featuredImage,
-            fields,
-        };
+            medias.push({
+                kind: "mediaGallery",
+                fieldName: fieldType.name,
+                filePaths,
+            });
+        }
+        else {
+            // Single media field
+            medias.push({
+                kind: "mediaField",
+                fieldName: fieldType.name,
+                filePath: getRandomImagePath(),
+            });
+        }
     }
-    const fields = toRiFieldSetContent(ctx, generatedContent, outputTags, fieldTypes, language);
-    return { fields };
 }
-function toRiFieldSetContent(ctx, content, outputTags, fieldTypes, language) {
+function toUpdateFieldValues(ctx, content, outputTags, fieldTypes, language) {
     const result = {};
     for (const fieldType of fieldTypes) {
         const isMarkdown = outputTags.find((tag) => tag.key === fieldType.name)?.format === "markdown";
         const localized = fieldType.localized;
         const value = content[fieldType.name];
-        const fieldContent = toRiFieldContent({
+        const fieldValue = toUpdateFieldValue({
             ctx,
             fieldType,
             generatedValue: value,
@@ -52,98 +78,37 @@ function toRiFieldSetContent(ctx, content, outputTags, fieldTypes, language) {
             language,
             isMarkdown,
         });
-        if (fieldContent !== undefined) {
-            result[fieldType.name] = fieldContent;
+        if (fieldValue !== undefined) {
+            result[fieldType.name] = fieldValue;
         }
     }
     return result;
 }
-function toRiFieldContent(options) {
-    const { ctx, fieldType, generatedValue, localized, language, isMarkdown } = options;
+function toUpdateFieldValue(options) {
+    const { fieldType, generatedValue, localized, language, isMarkdown } = options;
+    // Return the markdown string directly for markdown fields
     if (generatedValue !== undefined && localized) {
         if (fieldType.dataType === "string") {
-            return {
-                dataType: "string",
-                localized: true,
-                value: generatedValue,
-            };
+            // For localized strings, return the value for the language
+            return generatedValue[language];
         }
-        if (fieldType.dataType === "json" &&
-            fieldType.renderAs === "html" &&
-            fieldType.pluginName === "@paroicms/tiptap-editor-plugin" &&
-            isMarkdown) {
-            return toTiptapRiJsonContent(ctx, generatedValue);
-        }
-    }
-    if (fieldType.storedAs === "mediaHandle") {
-        if (fieldType.dataType === "media") {
-            const file = getRandomImagePath();
-            return localized
-                ? {
-                    dataType: "media",
-                    localized: true,
-                    value: { [language]: { file } },
-                }
-                : {
-                    dataType: "media",
-                    localized: false,
-                    value: { file },
-                };
-        }
-        if (fieldType.dataType === "gallery") {
-            const files = [
-                getRandomImagePath(),
-                getRandomImagePath(),
-                getRandomImagePath(),
-                getRandomImagePath(),
-                getRandomImagePath(),
-                getRandomImagePath(),
-            ];
-            return localized
-                ? {
-                    dataType: "gallery",
-                    localized: true,
-                    value: { [language]: { files } },
-                }
-                : {
-                    dataType: "gallery",
-                    localized: false,
-                    value: { files },
-                };
+        if (fieldType.dataType === "json" && fieldType.renderAs === "html" && isMarkdown) {
+            // Return the markdown string for the language
+            return generatedValue[language];
         }
     }
+    // Skip media fields - they are handled separately via setMedia
+    if (fieldType.storedAs === "mediaHandle")
+        return undefined;
     if (fieldType.dataType === "string") {
         const value = getDefaultStringValueForField(fieldType.name);
         if (value !== undefined) {
-            return localized
-                ? {
-                    dataType: "string",
-                    localized: true,
-                    value: { [language]: value },
-                }
-                : {
-                    dataType: "string",
-                    localized: false,
-                    value,
-                };
+            return value;
         }
     }
     if (fieldType.storedAs === "labeling")
         return; // TODO: Generate values for labeling fields
 }
-function toTiptapRiJsonContent(ctx, content) {
-    return {
-        dataType: "json",
-        localized: true,
-        value: Object.fromEntries(Object.entries(content).map(([language, text]) => {
-            const { result, issues } = convertMarkdownToTiptap(text);
-            if (issues && issues.length > 0) {
-                ctx.logger.warn(`Markdown conversion issues for language ${language}:`, issues);
-            }
-            return [language, { j: result }];
-        })),
-    };
-}
 function getDefaultStringValueForField(fieldName) {
     if (fieldName === "phone" || fieldName === "phone2")
         return "0123456789";
@@ -153,15 +118,9 @@ function getDefaultStringValueForField(fieldName) {
         return new Date().toISOString();
     return;
 }
-export function generateLocalizedFooterMention(ctx, siteSchema) {
+export function generateLocalizedFooterMention(siteSchema) {
     const { languages } = siteSchema;
-    return Object.fromEntries(languages.map((language) => {
-        const { result, issues } = convertMarkdownToTiptap(getPoweredByLabel(language));
-        if (issues && issues.length > 0) {
-            ctx.logger.warn(`Markdown conversion issues for footer mention (${language}):`, issues);
-        }
-        return [language, { j: result }];
-    }));
+    return Object.fromEntries(languages.map((language) => [language, getPoweredByLabel(language)]));
 }
 function getPoweredByLabel(language) {
     const translations = {

package/backend/dist/generator/fake-content-generator/fill-lnodes.js

@@ -1,9 +1,11 @@
-import { dedupMessages } from "./content-helpers.js";
+import { encodeLNodeId, } from "@paroicms/public-anywhere-lib";
+import { getHandleOfFeaturedImage, getHandleOfFieldOnNode } from "@paroicms/public-server-lib";
+import { dedupMessages, getTaxonomyTypeNames } from "./content-helpers.js";
 import { generateFieldSetContent, generateMultipleFieldSetContents, } from "./generate-fake-content.js";
-export async function updateRoutingDocument(ctx, report, siteOptions, nodeOptions) {
+export async function updateRoutingDocument(ctx, report, nodeOptions) {
     ctx.logger.debug(`[TASK] Updating routing document "${nodeOptions.nodeType.typeName}"…`);
     const { clusterNode, nodeType } = nodeOptions;
-    const { fqdn, siteSchema, schemaI18n } = siteOptions;
+    const { siteSchema, schemaI18n, siteConnector } = ctx;
     const content = await generateFieldSetContent(ctx, {
         nodeType,
         documentType: nodeType,
@@ -12,11 +14,10 @@ export async function updateRoutingDocument(ctx, report, siteOptions, nodeOption
         withTitle: false,
         llmTaskName: nodeType.kebabName,
     }, report);
-    await ctx.service.connector.updateNodeContent(fqdn, {
-        nodeId: clusterNode.nodeId,
-        content: toRiDocumentContent(content, nodeType),
-    });
+    // Use updateFields for each language
     for (const language of siteSchema.languages) {
+        const lNodeId = encodeLNodeId({ nodeId: clusterNode.nodeId, language });
+        await siteConnector.updateFields(lNodeId, content.fields);
         report.addId({
             typeName: nodeType.typeName,
             id: {
@@ -27,37 +28,127 @@ export async function updateRoutingDocument(ctx, report, siteOptions, nodeOption
         });
     }
 }
-export async function addRegularDocuments(ctx, report, siteOptions, nodeOptions) {
+export async function addRegularDocuments(ctx, report, nodeOptions) {
+    // Special case: author terms are created without LLM
+    if (nodeOptions.nodeType.typeName === "author") {
+        await addSingleAuthor(ctx, report, nodeOptions);
+        return;
+    }
     ctx.logger.debug(`[TASK] Adding regular documents "${nodeOptions.nodeType.typeName}"…`);
     const { parentNodeId, nodeType, documentType } = nodeOptions;
-    const { fqdn, siteSchema, schemaI18n } = siteOptions;
+    const { siteSchema, schemaI18n, siteConnector } = ctx;
+    const taxonomyTypeNames = getTaxonomyTypeNames(siteSchema);
+    const isTaxonomyTerm = taxonomyTypeNames.has(nodeType.typeName);
     const tolerateErrors = {
         errorMessages: [],
     };
-    const list = await generateMultipleFieldSetContents(ctx, {
-        siteSchema,
-        nodeType,
-        documentType,
-        schemaI18n,
-        count: getDefaultNodeContentCount(nodeType),
-        withTitle: true,
-        tolerateErrors,
-        llmTaskName: nodeType.kebabName,
-    }, report);
+    const maxAttempts = 3;
+    let list = [];
+    for (let attempt = 1; attempt <= maxAttempts; ++attempt) {
+        list = await generateMultipleFieldSetContents(ctx, {
+            siteSchema,
+            nodeType,
+            documentType,
+            schemaI18n,
+            count: getDefaultNodeContentCount(nodeType, siteSchema),
+            withTitle: true,
+            tolerateErrors,
+            llmTaskName: nodeType.kebabName,
+            isTaxonomyTerm,
+        }, report);
+        if (list.length > 0)
+            break;
+        if (attempt < maxAttempts) {
+            ctx.logger.debug(`[RETRY] Empty result for ${nodeType.typeName}, attempt ${attempt}/${maxAttempts}`);
+        }
+    }
     const errorMessages = dedupMessages(tolerateErrors.errorMessages);
     if (errorMessages.length > 0) {
         ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${errorMessages.join("\n  - ")}`);
     }
-    const insertedIds = await ctx.service.connector.addMultipleDocumentContents(fqdn, {
+    for (const content of list) {
+        const [firstLanguage, ...otherLanguages] = siteSchema.languages;
+        const parentLNodeId = encodeLNodeId({ nodeId: parentNodeId, language: firstLanguage });
+        const title = content.title?.[firstLanguage];
+        const info = await siteConnector.createDocument({
+            parentLNodeId,
+            typeName: nodeType.typeName,
+            title,
+            values: content.fields,
+        });
+        const nodeId = info.nodeId;
+        await uploadMediaEntries(ctx, nodeId, content.medias);
+        report.addId({
+            typeName: nodeType.typeName,
+            id: { nodeId, language: firstLanguage },
+            parentNodeId,
+        });
+        for (const language of otherLanguages) {
+            if (!content.title?.[language])
+                continue;
+            await siteConnector.createDocumentTranslation({
+                nodeId,
+                language,
+                title: content.title?.[language],
+                values: content.fields,
+            });
+            report.addId({
+                typeName: nodeType.typeName,
+                id: { nodeId, language },
+                parentNodeId,
+            });
+        }
+    }
+}
+const HERO_NAMES = [
+    "Mario",
+    "Luigi",
+    "Link",
+    "Zelda",
+    "Kirby",
+    "Pikachu",
+    "Yoshi",
+    "Sonic",
+    "Toad",
+    "Peach",
+];
+async function addSingleAuthor(ctx, report, nodeOptions) {
+    ctx.logger.debug("[TASK] Adding single author…");
+    const { parentNodeId, nodeType } = nodeOptions;
+    const { siteSchema, siteConnector } = ctx;
+    const title = HERO_NAMES[Math.floor(Math.random() * HERO_NAMES.length)];
+    const [firstLanguage, ...otherLanguages] = siteSchema.languages;
+    const parentLNodeId = encodeLNodeId({ nodeId: parentNodeId, language: firstLanguage });
+    const info = await siteConnector.createDocument({
+        parentLNodeId,
+        typeName: nodeType.typeName,
+        title,
+        values: {},
+    });
+    const nodeId = info.nodeId;
+    report.addId({
+        typeName: nodeType.typeName,
+        id: { nodeId, language: firstLanguage },
         parentNodeId,
-        contents: list.map((content) => toRiDocumentContent(content, nodeType)),
     });
-    report.addId({ typeName: nodeType.typeName, id: insertedIds, parentNodeId });
+    for (const language of otherLanguages) {
+        await siteConnector.createDocumentTranslation({
+            nodeId,
+            language,
+            title,
+            values: {},
+        });
+        report.addId({
+            typeName: nodeType.typeName,
+            id: { nodeId, language },
+            parentNodeId,
+        });
+    }
 }
-export async function addParts(ctx, report, siteOptions, nodeOptions) {
+export async function addParts(ctx, report, nodeOptions) {
     ctx.logger.debug(`[TASK] Adding parts "${nodeOptions.nodeType.typeName}"…`);
     const { parentNodeId, nodeType, documentType } = nodeOptions;
-    const { fqdn, siteSchema, schemaI18n } = siteOptions;
+    const { siteSchema, schemaI18n, siteConnector } = ctx;
     const tolerateErrors = {
         errorMessages: [],
     };
@@ -66,7 +157,7 @@ export async function addParts(ctx, report, siteOptions, nodeOptions) {
         nodeType,
         documentType,
         schemaI18n,
-        count: getDefaultNodeContentCount(nodeType),
+        count: getDefaultNodeContentCount(nodeType, siteSchema),
         withTitle: true,
         tolerateErrors,
         llmTaskName: nodeType.kebabName,
@@ -75,41 +166,75 @@ export async function addParts(ctx, report, siteOptions, nodeOptions) {
     if (errorMessages.length > 0) {
         ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${errorMessages.join("\n  - ")}`);
     }
-    const insertedIds = await ctx.service.connector.addMultiplePartContents(fqdn, {
-        parentNodeId,
-        contents: list.map((content) => toRiPartContent(content, nodeType)),
-    });
-    report.addId({ typeName: nodeType.typeName, id: insertedIds, parentNodeId });
-}
-function toRiDocumentContent(content, nodeType) {
-    const { title, fields, featuredImage } = content;
-    return {
-        kind: "document",
-        typeName: nodeType.typeName,
-        title,
-        featuredImage,
-        fields,
-    };
-}
-function toRiPartContent(content, nodeType) {
-    const { fields } = content;
-    return {
-        kind: "part",
-        typeName: nodeType.typeName,
-        fields,
-    };
+    for (const content of list) {
+        const [firstLanguage, ..._otherLanguages] = siteSchema.languages;
+        const parentLNodeId = encodeLNodeId({ nodeId: parentNodeId, language: firstLanguage });
+        const info = await siteConnector.createPart({
+            parentLNodeId,
+            typeName: nodeType.typeName,
+            values: content.fields,
+        });
+        const nodeId = info.nodeId;
+        await uploadMediaEntries(ctx, nodeId, content.medias);
+        report.addId({
+            typeName: nodeType.typeName,
+            id: { nodeId, language: firstLanguage },
+            parentNodeId,
+        });
+    }
 }
-function getDefaultNodeContentCount(nodeType) {
+function getDefaultNodeContentCount(nodeType, siteSchema) {
     if (nodeType.kind === "site")
         throw new Error("Cannot generate content for site node type");
     if (nodeType.kind === "document") {
         if (nodeType.documentKind === "routing")
             return 1;
+        const taxonomyTypeNames = getTaxonomyTypeNames(siteSchema);
+        if (taxonomyTypeNames.has(nodeType.typeName))
+            return 4;
         if (nodeType.route === ":yyyy/:mm/:dd/:relativeId-:slug")
-            return 14; // 4
-        return 8; // 2
+            return 14;
+        return 8;
     }
     if (nodeType.kind === "part")
-        return 8; // 2
+        return 8;
     throw new Error(`Unknown node type kind: ${nodeType.kind}`);
 }
+async function uploadMediaEntries(ctx, nodeId, medias) {
+    if (!medias || medias.length === 0)
+        return;
+    const { siteConnector, homeRoutingCluster } = ctx;
+    const siteNodeId = homeRoutingCluster.siteNodeId;
+    for (const entry of medias) {
+        switch (entry.kind) {
+            case "featuredImage": {
+                await siteConnector.setMedia({
+                    handle: getHandleOfFeaturedImage(nodeId),
+                    filePath: entry.filePath,
+                    replace: true,
+                });
+                break;
+            }
+            case "mediaField": {
+                await siteConnector.setMedia({
+                    handle: getHandleOfFieldOnNode({ siteNodeId, nodeId, fieldName: entry.fieldName }),
+                    filePath: entry.filePath,
+                    replace: true,
+                });
+                break;
+            }
+            case "mediaGallery": {
+                const handle = getHandleOfFieldOnNode({ siteNodeId, nodeId, fieldName: entry.fieldName });
+                // Gallery: first image replaces, subsequent ones add
+                for (let i = 0; i < entry.filePaths.length; i++) {
+                    await siteConnector.setMedia({
+                        handle,
+                        filePath: entry.filePaths[i],
+                        replace: i === 0,
+                    });
+                }
+                break;
+            }
+        }
+    }
+}

package/backend/dist/generator/fake-content-generator/fill-site-fields.js

@@ -1,63 +1,31 @@
+import { getHandleOfSiteField } from "@paroicms/public-server-lib";
 import { getRandomImagePath } from "../lib/images-lib.js";
 import { generateLocalizedFooterMention } from "./create-node-contents.js";
 export async function updateSiteFields(ctx, _report, options) {
-    const { service, logger } = ctx;
+    const { logger, siteSchema, siteConnector } = ctx;
     logger.debug("Updating site fields…");
-    const { fqdn, siteSchema, siteTitle } = options;
+    const { siteTitle } = options;
     const siteType = siteSchema.nodeTypes._site;
-    const logoImageFile = getRandomImagePath();
-    const fields = [
-        [
-            "title",
-            {
-                dataType: "string",
-                localized: true,
-                value: siteTitle,
-            },
-        ],
-        [
-            "favicon",
-            {
-                dataType: "media",
-                localized: false,
-                value: {
-                    file: logoImageFile,
-                },
-            },
-        ],
-        [
-            "ogImage",
-            {
-                dataType: "media",
-                localized: false,
-                value: {
-                    file: logoImageFile,
-                },
-            },
-        ],
-    ];
-    if (siteType.fields.some((f) => f.name === "logo")) {
-        fields.push([
-            "logo",
-            {
-                dataType: "media",
-                localized: false,
-                value: {
-                    file: logoImageFile,
-                },
-            },
-        ]);
+    const footerMention = generateLocalizedFooterMention(siteSchema);
+    // Update site fields for each language
+    for (const language of siteSchema.languages) {
+        const values = {
+            title: siteTitle[language],
+        };
+        if (siteType.fields.some((f) => f.name === "footerMention")) {
+            values.footerMention = footerMention[language];
+        }
+        await siteConnector.updateSiteFields(language, values);
     }
-    if (siteType.fields.some((f) => f.name === "footerMention")) {
-        fields.push([
-            "footerMention",
-            {
-                dataType: "json",
-                localized: true,
-                value: generateLocalizedFooterMention(ctx, siteSchema),
-            },
-        ]);
+    for (const fieldName of ["favicon", "ogImage", "logo"]) {
+        const fieldType = siteType.fields.find((f) => f.name === fieldName);
+        if (!fieldType || fieldType.storedAs !== "mediaHandle")
+            continue;
+        await siteConnector.setMedia({
+            handle: getHandleOfSiteField(fieldName),
+            filePath: getRandomImagePath(),
+            replace: true,
+        });
     }
-    await service.connector.updateSiteFields(fqdn, Object.fromEntries(fields));
     logger.debug("… Site fields updated");
 }