@paroicms/server/dist/running-server/write-document-api.js

The ParoiCMS server

import { getNodeTypeByName } from "@paroicms/internal-anywhere-lib";
import { generateSlug, parseLNodeId, } from "@paroicms/public-anywhere-lib";
import { ApiError, } from "@paroicms/public-server-lib";
import { createDocumentOnNode, createNodeWithDocument, } from "../admin-backend/document/save-documents.queries.js";
import { saveFieldValues } from "../admin-backend/fields/save-fields.queries.js";
import { getTypeNameOf } from "../admin-backend/node/node.queries.js";
import { createNodeWithPart, createPartOnNode } from "../admin-backend/part/part.queries.js";
import { loadMinimalDocumentInfo, loadMinimalPartInfo } from "./document-info.queries.js";
import { applyMarkdownToNativeForValues } from "./markdown-content.js";
export async function updateFieldsProgrammaticApi(siteContext, lNodeId, values) {
    const typeName = await getTypeNameOf(siteContext, lNodeId.nodeId);
    const processedValues = await applyMarkdownToNativeForValues(siteContext, values, typeName, lNodeId.language);
    await saveFieldValues(siteContext, {
        typeName,
        nodeId: lNodeId.nodeId,
        language: lNodeId.language,
        values: processedValues,
    });
}
export async function createDocumentProgrammaticApi(siteContext, createInput) {
    const parentId = parseLNodeId(createInput.parentLNodeId);
    const title = createInput.title;
    const slug = createInput.slug ?? (title ? generateSlug(title) : undefined);
    const documentId = await createNodeWithDocument(siteContext, {
        parentId,
        values: { typeName: createInput.typeName, title, slug },
        forceReady: true,
    });
    if (createInput.values && Object.keys(createInput.values).length > 0) {
        const processedValues = await applyMarkdownToNativeForValues(siteContext, createInput.values, createInput.typeName, documentId.language);
        await saveFieldValues(siteContext, {
            typeName: createInput.typeName,
            nodeId: documentId.nodeId,
            language: documentId.language,
            values: processedValues,
        });
    }
    return await loadMinimalDocumentInfo(siteContext, documentId);
}
export async function createDocumentTranslationProgrammaticApi(siteContext, createInput) {
    const { nodeId, language, title, slug, values } = createInput;
    const documentId = await createDocumentOnNode(siteContext, {
        nodeId,
        language,
        values: { title, slug },
        forceReady: true,
    });
    if (values && Object.keys(values).length > 0) {
        const typeName = await getTypeNameOf(siteContext, nodeId);
        const processedValues = await applyMarkdownToNativeForValues(siteContext, values, typeName, language);
        await saveFieldValues(siteContext, {
            typeName,
            nodeId,
            language,
            values: processedValues,
        });
    }
    return await loadMinimalDocumentInfo(siteContext, documentId);
}
export async function createPartProgrammaticApi(siteContext, createInput) {
    const parentId = parseLNodeId(createInput.parentLNodeId);
    const parentTypeName = await getTypeNameOf(siteContext, parentId.nodeId);
    const parentType = getNodeTypeByName(siteContext.siteSchema, parentTypeName);
    const listName = findListNameForPartType(parentType, createInput.typeName, parentTypeName);
    const partId = await createNodeWithPart(siteContext, {
        parentLNodeId: parentId,
        listName,
        typeName: createInput.typeName,
    });
    if (createInput.values && Object.keys(createInput.values).length > 0) {
        const processedValues = await applyMarkdownToNativeForValues(siteContext, createInput.values, createInput.typeName, partId.language);
        await saveFieldValues(siteContext, {
            typeName: createInput.typeName,
            nodeId: partId.nodeId,
            language: partId.language,
            values: processedValues,
        });
    }
    return await loadMinimalPartInfo(siteContext, partId);
}
export async function createPartTranslationProgrammaticApi(siteContext, createInput) {
    const { nodeId, language, values } = createInput;
    const partId = await createPartOnNode(siteContext, { nodeId, language });
    if (values && Object.keys(values).length > 0) {
        const typeName = await getTypeNameOf(siteContext, nodeId);
        const processedValues = await applyMarkdownToNativeForValues(siteContext, values, typeName, language);
        await saveFieldValues(siteContext, {
            typeName,
            nodeId,
            language,
            values: processedValues,
        });
    }
    return await loadMinimalPartInfo(siteContext, partId);
}
function findListNameForPartType(parentType, partTypeName, parentTypeName) {
    let listName;
    if (parentType.kind === "document" && parentType.lists) {
        listName = parentType.lists.find((l) => l.parts.includes(partTypeName))?.listName;
    }
    else if (parentType.kind === "part" && parentType.list?.parts.includes(partTypeName)) {
        listName = parentType.list.listName;
    }
    if (!listName) {
        throw new ApiError(`Type "${partTypeName}" is not a valid part type for "${parentTypeName}"`, 400);
    }
    return listName;
}
//# sourceMappingURL=write-document-api.js.map