@paroicms/site-generator-plugin 0.1.0

package/README.md

@@ -0,0 +1,9 @@
+# @paroicms/site-generator-plugin
+
+ParoiCMS Site Generator Plugin.
+
+This package is part of [ParoiCMS](https://www.npmjs.com/package/@paroicms/server).
+
+## License
+
+Released under the [MIT license](https://gitlab.com/paroi/opensource/paroicms/-/blob/main/LICENSE.md).

package/gen-backend/dist/context.js

@@ -0,0 +1,2 @@
+import { resolveModuleDirectory } from "@paroicms/public-server-lib";
+export const projectDir = resolveModuleDirectory(import.meta.url, { parent: true });

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

@@ -0,0 +1,37 @@
+import { boolVal, isObj, strVal, strValOrUndef } from "@paroi/data-formatters-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"`);
+    }
+    return { anthropicApiKey, mistralApiKey, packName, debugDir };
+}
+export function formatGeneratorCommand(data) {
+    if (!isObj(data))
+        throw new Error("Invalid input");
+    const command = strVal(data.command, { varName: "command" });
+    if (command === "createSiteSchema") {
+        return {
+            command: "createSiteSchema",
+            prompt: strVal(data.prompt, { varName: "prompt" }),
+        };
+    }
+    if (command === "updateSiteSchema") {
+        return {
+            command: "updateSiteSchema",
+            prompt: strVal(data.prompt, { varName: "prompt" }),
+            generatedSchema: data.generatedSchema,
+        };
+    }
+    if (command === "generateSite") {
+        return {
+            command: "generateSite",
+            generatedSchema: data.generatedSchema,
+            withFakeContent: boolVal(data.withFakeContent, { varName: "withFakeContent" }),
+        };
+    }
+    throw new Error(`Invalid command: ${command}`);
+}

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

@@ -0,0 +1,35 @@
+import { invokeMessageGuard } from "./llm-queries/invoke-message-guard.js";
+import { invokeNewSiteAnalysis } from "./llm-queries/invoke-new-site-analysis.js";
+import { invokeUpdateSiteSchema } from "./llm-queries/invoke-update-site-schema.js";
+import { generateSite } from "./site-generator/site-generator.js";
+export async function executeCommand(ctx, input) {
+    if (input.command === "createSiteSchema") {
+        const errorResponse = await invokeMessageGuard(ctx, input);
+        if (errorResponse)
+            return errorResponse;
+        return {
+            success: true,
+            result: await invokeNewSiteAnalysis(ctx, input),
+        };
+    }
+    if (input.command === "updateSiteSchema") {
+        const errorResponse = await invokeMessageGuard(ctx, input);
+        if (errorResponse)
+            return errorResponse;
+        return {
+            success: true,
+            result: await invokeUpdateSiteSchema(ctx, input),
+        };
+    }
+    if (input.command === "generateSite") {
+        return {
+            success: true,
+            result: await generateSite(ctx, input),
+        };
+    }
+    ctx.logger.error(`Invalid command: ${input.command}`);
+    return {
+        success: false,
+        userMessage: "Invalid command",
+    };
+}

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

@@ -0,0 +1,227 @@
+import { getPartTypeByName, getRegularDocumentTypeByName, getRoutingDocumentTypeByName, } from "@paroicms/internal-anywhere-lib";
+import { createSimpleTranslator, } from "@paroicms/public-server-lib";
+import { getRandomImagePath } from "../lib/images-lib.js";
+import { createTaskCollector } from "../lib/tasks.js";
+import { generateLocalizedFooterMention } from "./create-node-contents.js";
+import { generateFieldSetContent, generateMultipleFieldSetContents, } from "./generate-fake-content.js";
+export async function fillSiteWithFakeContent(ctx, { siteConf, siteId, siteTitle, }) {
+    const { service } = ctx;
+    const { fqdn } = siteConf;
+    const { siteSchema, siteIds } = await service.connector.loadSiteSchemaAndIds(fqdn);
+    const schemaI18n = createSimpleTranslator({
+        labels: siteSchema.l10n,
+        logger: ctx.logger,
+    });
+    await updateSiteFields(ctx, { fqdn, siteSchema, siteId, siteTitle });
+    const tasks = createTaskCollector(ctx);
+    fillRoutingDocumentAndAddChildren(ctx, tasks, {
+        fqdn,
+        siteSchema,
+        schemaI18n,
+    }, {
+        routingIds: siteIds.homeIds,
+        nodeType: siteSchema.nodeTypes.home,
+    });
+    const { promise } = tasks.runAll({ maxParallel: 10, rateLimitPerSecond: 3 });
+    const { doneCount, errorMessages } = await promise;
+    if (errorMessages.length > 0) {
+        ctx.logger.warn(`Failed to generate ${errorMessages.length} documents:\n  - ${errorMessages.join("\n  - ")}`);
+    }
+    ctx.logger.debug(`… Executed ${doneCount} generating tasks`);
+}
+function fillRoutingDocumentAndAddChildren(ctx, tasks, siteOptions, nodeOptions) {
+    const { routingIds, nodeType } = nodeOptions;
+    const { siteSchema } = siteOptions;
+    tasks.add(() => updateRoutingDocument(ctx, siteOptions, nodeOptions));
+    for (const typeName of nodeType.routingChildren ?? []) {
+        const childType = getRoutingDocumentTypeByName(siteSchema, typeName);
+        const childIds = routingIds.children?.[typeName];
+        if (!childIds)
+            throw new Error(`Missing childIds for ${typeName}`);
+        fillRoutingDocumentAndAddChildren(ctx, tasks, siteOptions, {
+            routingIds: childIds,
+            nodeType: childType,
+        });
+    }
+    for (const typeName of nodeType.regularChildren ?? []) {
+        const childType = getRegularDocumentTypeByName(siteSchema, typeName);
+        tasks.add(() => addRegularDocuments(ctx, siteOptions, {
+            parentNodeId: routingIds.nodeId,
+            nodeType: childType,
+        }));
+    }
+    for (const listType of nodeType.lists ?? []) {
+        for (const typeName of listType.parts) {
+            const childType = getPartTypeByName(siteSchema, typeName);
+            tasks.add(() => addParts(ctx, siteOptions, {
+                parentNodeId: routingIds.nodeId,
+                nodeType: childType,
+            }));
+        }
+    }
+}
+async function updateSiteFields(ctx, options) {
+    const { service, logger } = ctx;
+    logger.debug("Updating site fields…");
+    const { fqdn, siteSchema, siteId, siteTitle } = options;
+    const siteType = siteSchema.nodeTypes._site;
+    const logoImageFile = getRandomImagePath();
+    const fields = [
+        [
+            "title",
+            {
+                dataType: "string",
+                localized: true,
+                value: siteTitle,
+            },
+        ],
+        [
+            "contactEmail",
+            {
+                dataType: "string",
+                localized: false,
+                value: `${siteId}@yopmail.com`,
+            },
+        ],
+        [
+            "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,
+                },
+            },
+        ]);
+    }
+    if (siteType.fields.some((f) => f.name === "footerMention")) {
+        fields.push([
+            "footerMention",
+            {
+                dataType: "quillDelta",
+                localized: true,
+                value: generateLocalizedFooterMention(siteSchema),
+            },
+        ]);
+    }
+    await service.connector.updateSiteFields(fqdn, Object.fromEntries(fields));
+    logger.debug("… Site fields updated");
+}
+async function updateRoutingDocument(ctx, siteOptions, nodeOptions) {
+    ctx.logger.debug(`[TASK] Updating routing document "${nodeOptions.nodeType.typeName}"…`);
+    const { routingIds, nodeType } = nodeOptions;
+    const { fqdn, siteSchema, schemaI18n } = siteOptions;
+    const content = await generateFieldSetContent(ctx, {
+        nodeType,
+        siteSchema,
+        schemaI18n,
+        withTitle: false,
+        debugName: nodeType.kebabName,
+    });
+    await ctx.service.connector.updateDocumentContent(fqdn, {
+        nodeId: routingIds.nodeId,
+        content: toNcDocumentContent(content, nodeType),
+    });
+}
+async function addRegularDocuments(ctx, siteOptions, nodeOptions) {
+    ctx.logger.debug(`[TASK] Adding regular documents "${nodeOptions.nodeType.typeName}"…`);
+    const { parentNodeId, nodeType } = nodeOptions;
+    const { fqdn, siteSchema, schemaI18n } = siteOptions;
+    const tolerateErrors = {
+        errorMessages: [],
+    };
+    const list = await generateMultipleFieldSetContents(ctx, {
+        siteSchema,
+        nodeType,
+        schemaI18n,
+        count: getDefaultNodeContentCount(nodeType),
+        withTitle: true,
+        tolerateErrors,
+        debugName: nodeType.kebabName,
+    });
+    if (tolerateErrors.errorMessages.length > 0) {
+        ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${tolerateErrors.errorMessages.join("\n  - ")}`);
+    }
+    await ctx.service.connector.addMultipleDocumentContents(fqdn, {
+        parentNodeId,
+        contents: list.map((content) => toNcDocumentContent(content, nodeType)),
+    });
+}
+async function addParts(ctx, siteOptions, nodeOptions) {
+    ctx.logger.debug(`[TASK] Adding parts "${nodeOptions.nodeType.typeName}"…`);
+    const { parentNodeId, nodeType } = nodeOptions;
+    const { fqdn, siteSchema, schemaI18n } = siteOptions;
+    const tolerateErrors = {
+        errorMessages: [],
+    };
+    const list = await generateMultipleFieldSetContents(ctx, {
+        siteSchema,
+        nodeType,
+        schemaI18n,
+        count: getDefaultNodeContentCount(nodeType),
+        withTitle: true,
+        tolerateErrors,
+        debugName: nodeType.kebabName,
+    });
+    if (tolerateErrors.errorMessages.length > 0) {
+        ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${tolerateErrors.errorMessages.join("\n  - ")}`);
+    }
+    await ctx.service.connector.addMultiplePartContents(fqdn, {
+        parentNodeId,
+        contents: list.map((content) => toNcPartContent(content, nodeType)),
+    });
+}
+function toNcDocumentContent(content, nodeType) {
+    const { title, fields, featuredImage } = content;
+    return {
+        kind: "document",
+        typeName: nodeType.typeName,
+        title,
+        featuredImage,
+        fields,
+    };
+}
+function toNcPartContent(content, nodeType) {
+    const { fields } = content;
+    return {
+        kind: "part",
+        typeName: nodeType.typeName,
+        fields,
+    };
+}
+function getDefaultNodeContentCount(nodeType) {
+    if (nodeType.kind === "site")
+        throw new Error("Cannot generate content for site node type");
+    if (nodeType.kind === "document") {
+        if (nodeType.documentKind === "routing")
+            return 1;
+        if (nodeType.route === ":yyyy/:mm/:dd/:relativeId-:slug")
+            return 14; // 4
+        return 8; // 2
+    }
+    if (nodeType.kind === "part")
+        return 8; // 2
+    throw new Error(`Unknown node type kind: ${nodeType.kind}`);
+}

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

@@ -0,0 +1,156 @@
+import markdownToDelta from "markdown-to-quill-delta";
+import { getRandomImagePath } from "../lib/images-lib.js";
+export function createNodeContents(options) {
+    const { nodeType, count, generatedContents, outputTags, language } = options;
+    const result = [];
+    for (let i = 0; i < count; ++i) {
+        const generatedContent = generatedContents ? generatedContents[i] : {};
+        if (generatedContent === undefined)
+            break; // The LLM produced less than expected
+        const nodeContent = createNodeContent({
+            nodeType,
+            language,
+            generatedContent,
+            outputTags,
+        });
+        result.push(nodeContent);
+    }
+    return result;
+}
+function createNodeContent(options) {
+    const { nodeType, language, generatedContent, outputTags } = options;
+    const fieldTypes = nodeType.fields ?? [];
+    if (nodeType.kind === "document") {
+        const { title, ...generatedFields } = generatedContent;
+        const fields = toNcFieldSetContent(generatedFields, outputTags, fieldTypes, language);
+        const featuredImage = nodeType.withFeaturedImage
+            ? {
+                file: getRandomImagePath(),
+            }
+            : undefined;
+        return {
+            title,
+            featuredImage,
+            fields,
+        };
+    }
+    const fields = toNcFieldSetContent(generatedContent, outputTags, fieldTypes, language);
+    return { fields };
+}
+function toNcFieldSetContent(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 = toNcFieldContent({
+            fieldType,
+            generatedValue: value,
+            localized,
+            language,
+            isMarkdown,
+        });
+        if (fieldContent !== undefined) {
+            result[fieldType.name] = fieldContent;
+        }
+    }
+    return result;
+}
+function toNcFieldContent(options) {
+    const { fieldType, generatedValue, localized, language, isMarkdown } = options;
+    if (generatedValue !== undefined && localized) {
+        if (fieldType.dataType === "string") {
+            return {
+                dataType: "string",
+                localized: true,
+                value: generatedValue,
+            };
+        }
+        if (fieldType.dataType === "quillDelta" && isMarkdown) {
+            return toNcQuillDeltaContent(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 === "string") {
+        const value = getDefaultStringValueForField(fieldType.name);
+        if (value !== undefined) {
+            return localized
+                ? {
+                    dataType: "string",
+                    localized: true,
+                    value: { [language]: value },
+                }
+                : {
+                    dataType: "string",
+                    localized: false,
+                    value,
+                };
+        }
+    }
+}
+function toNcQuillDeltaContent(content) {
+    return {
+        dataType: "quillDelta",
+        localized: true,
+        value: Object.fromEntries(Object.entries(content).map(([language, text]) => [
+            language,
+            {
+                ops: markdownToDelta(text),
+            },
+        ])),
+    };
+}
+function getDefaultStringValueForField(fieldName) {
+    if (fieldName === "phone" || fieldName === "phone2")
+        return "0123456789";
+    if (fieldName === "phones")
+        return JSON.stringify(["0123456789", "9876543210"]);
+    if (fieldName === "updateDateTime")
+        return new Date().toISOString();
+    return undefined;
+}
+export function generateLocalizedFooterMention(siteSchema) {
+    const { languages, languageLabels } = siteSchema;
+    return Object.fromEntries(languages.map((language) => [
+        language,
+        {
+            ops: markdownToDelta(`Powered by ParoiCMS in ${languageLabels[language]}`),
+        },
+    ]));
+}

package/gen-backend/dist/generator/fake-content-generator.ts/fake-content-types.js

@@ -0,0 +1 @@
+export {};

package/gen-backend/dist/generator/fake-content-generator.ts/generate-fake-content.js

@@ -0,0 +1,127 @@
+import { camelToKebabCase, camelToTitleCase } from "../lib/utils.js";
+import { createNodeContents } from "./create-node-contents.js";
+import { invokeGenerateFakeContent, } from "./invoke-generate-fake-content.js";
+export async function generateFieldSetContent(ctx, options) {
+    const list = await generateMultipleFieldSetContents(ctx, {
+        ...options,
+        count: 1,
+    });
+    if (list.length !== 1)
+        throw new Error(`Expected one item, got ${list.length}`);
+    return list[0];
+}
+export async function generateMultipleFieldSetContents(ctx, options) {
+    const { siteSchema, nodeType, schemaI18n, count, withTitle, tolerateErrors, debugName } = options;
+    if (nodeType.kind === "site")
+        throw new Error("Cannot generate content for site node type");
+    const outputTags = withTitle
+        ? [{ tagName: "title", key: "title", format: "text", tagDescription: "Write the title here" }]
+        : [];
+    if (nodeType.fields) {
+        outputTags.push(...nodeType.fields.map(toFakeContentOutputTag).filter(Boolean));
+    }
+    const defaultLanguage = siteSchema.languages?.[0];
+    const typeLabel = translateText(schemaI18n, `nodeTypes.${nodeType.typeName}.label`, {
+        defaultValue: camelToTitleCase(nodeType.typeName),
+        defaultLanguage,
+    });
+    const typeDescription = translateText(schemaI18n, `nodeTypes.${nodeType.typeName}.description`, {
+        defaultValue: "",
+        defaultLanguage,
+    });
+    const siteTheme = translateText(schemaI18n, "siteTheme", {
+        defaultValue: "",
+        defaultLanguage,
+    });
+    const language = defaultLanguage ?? "en";
+    const generatedContents = outputTags.length > 0
+        ? await invokeGenerateFakeContent(ctx, {
+            count,
+            typeLabel,
+            typeDescription,
+            siteTheme,
+            language,
+        }, outputTags, { tolerateErrors, debugName })
+        : undefined;
+    return createNodeContents({
+        nodeType,
+        count,
+        generatedContents,
+        outputTags,
+        language,
+    });
+}
+function translateText(schemaI18n, key, options) {
+    const defaultValue = options.defaultValue ?? key;
+    const val = schemaI18n.translate({
+        key,
+        language: "en",
+        defaultValue,
+    });
+    if (val !== defaultValue || !options.defaultLanguage)
+        return val;
+    return schemaI18n.translate({
+        key,
+        language: options.defaultLanguage,
+        defaultValue,
+    });
+}
+function toFakeContentOutputTag(fieldNameOrType) {
+    const key = typeof fieldNameOrType === "string" ? fieldNameOrType : fieldNameOrType.name;
+    if (key === "leadParagraph") {
+        return {
+            tagName: `${camelToKebabCase(key)}-md`,
+            key,
+            format: "markdown",
+            tagDescription: "Write one lead paragraph here (15-30 words) in markdown format",
+        };
+    }
+    if (key === "htmlContent") {
+        return {
+            tagName: `${camelToKebabCase(key)}-md`,
+            key,
+            format: "markdown",
+            tagDescription: "Write document content here (150-200 words) in markdown format",
+        };
+    }
+    if (key === "introduction") {
+        return {
+            tagName: `${camelToKebabCase(key)}-md`,
+            key,
+            format: "markdown",
+            tagDescription: "Write a short introduction here (15-30 words) in markdown format",
+        };
+    }
+    if (key === "footerMention") {
+        return {
+            tagName: `${camelToKebabCase(key)}-md`,
+            key,
+            format: "markdown",
+            tagDescription: "Write a very short footer mention here in markdown format",
+        };
+    }
+    if (key === "slogan") {
+        return {
+            tagName: camelToKebabCase(key),
+            key,
+            format: "text",
+            tagDescription: "Write a slogan here in plain text",
+        };
+    }
+    if (key === "title") {
+        return {
+            tagName: camelToKebabCase(key),
+            key,
+            format: "text",
+            tagDescription: "Write a title here in plain text",
+        };
+    }
+    if (key === "shortTitle") {
+        return {
+            tagName: camelToKebabCase(key),
+            key,
+            format: "text",
+            tagDescription: "Rewrite the title as a short button label (1 or 2 words) here",
+        };
+    }
+}

package/gen-backend/dist/generator/fake-content-generator.ts/invoke-generate-fake-content.js

@@ -0,0 +1,49 @@
+import { PromptTemplate } from "@langchain/core/prompts";
+import { languageLabelIn } from "@paroicms/public-anywhere-lib";
+import { readPromptFile } from "../lib/create-prompt.js";
+import { debugBatchLlmOutputs } from "../lib/debug-utils.js";
+import { parseLlmResponseAsList } from "../lib/parse-llm-response.js";
+const singlePromptTpl = PromptTemplate.fromTemplate(await readPromptFile("generate-fake-content-single.md"));
+const multiplePromptTpl = PromptTemplate.fromTemplate(await readPromptFile("generate-fake-content-multiple.md"));
+export async function invokeGenerateFakeContent(ctx, input, outputTags, options) {
+    const { language } = input;
+    const single = input.count === 1;
+    const debugName = `fake-content-${options.debugName}${single ? "" : `-${input.count}`}`;
+    const tagAndDescriptions = outputTags
+        .map(({ tagName, tagDescription }) => `<${tagName}>${tagDescription}</${tagName}>`)
+        .join("\n\n");
+    // Call LLM in batch mode
+    const maxBatchSize = 15;
+    const batchInputs = [];
+    let startIndex = 0;
+    while (startIndex < input.count) {
+        const nextIndex = startIndex + maxBatchSize;
+        const end = Math.min(nextIndex, input.count);
+        const llmInput = {
+            tagAndDescriptions,
+            typeLabel: input.typeLabel,
+            typeDescription: input.typeDescription,
+            siteTheme: input.siteTheme,
+            language: languageLabelIn(language, "en"),
+        };
+        if (!single) {
+            llmInput.count = `${end - startIndex}`;
+        }
+        batchInputs.push(llmInput);
+        startIndex = nextIndex;
+    }
+    const debug = await debugBatchLlmOutputs(ctx, debugName, ctx.cheapModelName, batchInputs);
+    let contents = debug.storedContents;
+    if (!contents) {
+        const llmMessages = await (single ? singlePromptTpl : multiplePromptTpl)
+            .pipe(ctx.cheapModel)
+            .batch(batchInputs);
+        contents = await debug.getMessageContents(llmMessages);
+    }
+    const results = [];
+    for (const llmMessageContent of contents) {
+        const list = parseLlmResponseAsList(llmMessageContent, outputTags, options);
+        results.push(...list.map((fields) => Object.fromEntries(Object.entries(fields).map(([fieldName, value]) => [fieldName, { [language]: value }]))));
+    }
+    return results;
+}

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

@@ -0,0 +1 @@
+export {};

package/gen-backend/dist/generator/helpers/esm-module.helper.js

@@ -0,0 +1,6 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export function resolveModuleDirectory(moduleUrl, { parent = false } = {}) {
+    const dir = resolve(dirname(fileURLToPath(moduleUrl)));
+    return parent ? dirname(dir) : dir;
+}

package/gen-backend/dist/generator/helpers/js-utils.js

@@ -0,0 +1,14 @@
+export function reorderObjectKeys(obj, keys) {
+    const newObj = {};
+    for (const key of keys) {
+        if (!(key in obj))
+            continue;
+        newObj[key] = obj[key];
+    }
+    for (const key of Object.keys(obj)) {
+        if (keys.includes(key))
+            continue;
+        newObj[key] = obj[key];
+    }
+    return newObj;
+}

package/gen-backend/dist/generator/lib/common-types.js

@@ -0,0 +1 @@
+export {};