@paroicms/server/dist/admin-backend/part/part.resolver.js

The ParoiCMS server

import { getDocumentTypeByName } from "@paroicms/internal-anywhere-lib";
import { encodeLNodeId, parseLNodeId } from "@paroicms/public-anywhere-lib";
import { siteReadyGuard } from "../../graphql/graphql.types.js";
import { permissionGuard } from "../auth/authorization.helper.js";
import { getOneDocument } from "../document/load-documents.queries.js";
import { recordEvent } from "../event-log/event-log.service.js";
import { getTypeNameOf } from "../node/node.queries.js";
import { movePart } from "./part-moving.queries.js";
import { createNodeWithPart, createPartOnNode, deletePart, getDocumentNodeIdOfPart, loadPartSeed, readPartSeedsOf, } from "./part.queries.js";
export const partResolvers = {
    Query: {
        part: async (_parent, { partId }, { siteContext, httpContext }) => {
            siteReadyGuard(siteContext);
            await permissionGuard(siteContext, httpContext, "document.edit");
            return await loadPartSeed(siteContext, parseLNodeId(partId));
        },
        partsOf: async (_parent, { documentId }, { siteContext, httpContext }) => {
            siteReadyGuard(siteContext);
            await permissionGuard(siteContext, httpContext, "document.edit");
            const { nodeId, language } = parseLNodeId(documentId);
            const typeName = await getTypeNameOf(siteContext, nodeId);
            const documentType = getDocumentTypeByName(siteContext.siteSchema, typeName);
            const hasLists = documentType.lists && documentType.lists.length > 0;
            const hasPartFields = documentType.fields?.some((f) => f.storedAs === "partField");
            if (!hasLists && !hasPartFields)
                return null;
            return await readPartSeedsOf(siteContext, {
                documentNodeId: nodeId,
                language,
            });
        },
    },
    Mutation: {
        createPartOnNode: async (_parent, { language, nodeId }, { siteContext, httpContext }) => {
            siteReadyGuard(siteContext);
            const authorizedAccount = await permissionGuard(siteContext, httpContext, "document.edit");
            const newId = await createPartOnNode(siteContext, {
                language,
                nodeId,
            });
            const eventEntry = await createPartEventEntry(siteContext, newId.nodeId, language, authorizedAccount.accountId);
            recordEvent(siteContext, eventEntry);
            return await loadPartSeed(siteContext, newId);
        },
        createNodeWithPart: async (_parent, { parentLNodeId, listName, typeName }, { siteContext, httpContext }) => {
            siteReadyGuard(siteContext);
            const authorizedAccount = await permissionGuard(siteContext, httpContext, "document.edit");
            const newId = await createNodeWithPart(siteContext, {
                listName,
                parentLNodeId: parseLNodeId(parentLNodeId),
                typeName,
            });
            const eventEntry = await createPartEventEntry(siteContext, newId.nodeId, newId.language, authorizedAccount.accountId);
            recordEvent(siteContext, eventEntry);
            return await loadPartSeed(siteContext, newId);
        },
        deletePart: async (_parent, { partId }, { siteContext, httpContext }) => {
            siteReadyGuard(siteContext);
            const authorizedAccount = await permissionGuard(siteContext, httpContext, "document.edit");
            const parsedId = parseLNodeId(partId);
            const eventEntry = await createPartEventEntry(siteContext, parsedId.nodeId, parsedId.language, authorizedAccount.accountId);
            await deletePart(siteContext, parsedId);
            recordEvent(siteContext, eventEntry);
            return true;
        },
        movePart: async (_parent, { partNodeId, newParentNodeId, newListName }, { siteContext, httpContext }) => {
            siteReadyGuard(siteContext);
            const authorizedAccount = await permissionGuard(siteContext, httpContext, "document.edit");
            const eventEntry = await createPartMovedEventEntry(siteContext, partNodeId, newParentNodeId, newListName, authorizedAccount.accountId);
            await movePart(siteContext, {
                partNodeId,
                newParentNodeId,
                newListName,
            });
            recordEvent(siteContext, eventEntry);
            return true;
        },
    },
};
async function createPartEventEntry(siteContext, partNodeId, language, actorId) {
    const documentNodeId = await getDocumentNodeIdOfPart(siteContext, partNodeId);
    const doc = await getOneDocument(siteContext, { nodeId: documentNodeId, language });
    const typeName = await getTypeNameOf(siteContext, documentNodeId);
    return {
        eventType: "document.update",
        actorId,
        targetType: "document",
        targetId: encodeLNodeId({ nodeId: documentNodeId, language }),
        eventData: {
            nodeId: documentNodeId,
            typeName,
            title: doc.title,
            language,
            changedFields: ["parts"],
        },
    };
}
async function createPartMovedEventEntry(siteContext, partNodeId, newParentNodeId, newListName, actorId) {
    const documentNodeId = await getDocumentNodeIdOfPart(siteContext, partNodeId);
    const typeName = await getTypeNameOf(siteContext, documentNodeId);
    return {
        eventType: "part.move",
        actorId,
        targetType: "documentNode",
        targetId: documentNodeId,
        eventData: {
            partNodeId,
            documentNodeId,
            typeName,
            newParentNodeId,
            newListName,
        },
    };
}
//# sourceMappingURL=part.resolver.js.map