@paroicms/server/dist/admin-backend/lnode/lnode-wrap.resolver.js

The ParoiCMS server

import { createNoTracker } from "@paroicms/internal-server-lib";
import { encodeLNodeId, parseLNodeId } from "@paroicms/public-anywhere-lib";
import { type } from "arktype";
import { siteReadyGuard } from "../../graphql/graphql.types.js";
import { authGuard } from "../auth/auth.helper.js";
import { formatGqlOrderBy } from "./lnode-wrap.formatters.js";
import { findOneLNode, getBreadcrumb, getLNodeWraps, getParentLanguages, searchDocuments, setLNodeReady, } from "./lnode.queries.js";
const LNodeLanguageRowAT = type({
    language: "string",
    "+": "reject",
});
export const lNodeWrapResolvers = {
    Query: {
        lNodeWrap: async (_parent, { lNodeId }, { siteContext, httpContext }) => {
            authGuard(httpContext);
            siteReadyGuard(siteContext);
            const parsedLNodeId = parseLNodeId(lNodeId);
            return await findOneLNode(siteContext, parsedLNodeId);
        },
        pagedLNodeWraps: async (_parent, { parentLNodeId, start, limit, orderBy }, { siteContext, httpContext }) => {
            authGuard(httpContext);
            siteReadyGuard(siteContext);
            const parentId = parseLNodeId(parentLNodeId);
            const result = await getLNodeWraps(siteContext, {
                parentId,
                pagination: {
                    limit,
                    start,
                },
                orderBy: orderBy ? formatGqlOrderBy(orderBy) : undefined,
            });
            if (result.total === undefined) {
                throw new Error("property total not found");
            }
            return {
                items: result.lNodeWraps,
                total: result.total,
                start,
            };
        },
        searchDocuments: async (_parent, { language, queryString, start, limit, orderBy }, { siteContext, httpContext }) => {
            authGuard(httpContext);
            siteReadyGuard(siteContext);
            return await searchDocuments(siteContext, {
                language,
                queryString,
                start,
                limit,
                orderBy: orderBy ? formatGqlOrderBy(orderBy) : undefined,
            });
        },
        lNodeWraps: async (_parent, { parentLNodeId }, { siteContext, httpContext }) => {
            authGuard(httpContext);
            siteReadyGuard(siteContext);
            const parentId = parseLNodeId(parentLNodeId);
            return (await getLNodeWraps(siteContext, {
                parentId,
            })).lNodeWraps;
        },
    },
    Mutation: {
        setLNodeReady: async (_parent, { lNodeId, ready }, { siteContext, httpContext }) => {
            authGuard(httpContext);
            siteReadyGuard(siteContext);
            const parsedId = parseLNodeId(lNodeId);
            await setLNodeReady(siteContext, {
                lNodeId: parsedId,
                ready,
            });
            return true;
        },
    },
    LNodeWrap: {
        translatedInto: async ({ nodeId }, _args, { siteContext }) => {
            siteReadyGuard(siteContext);
            const lNodes = await siteContext
                .cn("PaLNode as s")
                .select("s.language")
                .where("s.nodeId", nodeId);
            return lNodes.map((item) => LNodeLanguageRowAT.assert(item).language);
        },
        translations: async ({ nodeId }, _args, { siteContext }) => {
            siteReadyGuard(siteContext);
            const { cn } = siteContext;
            const rows = await cn("PaLNode as lNode")
                .select("lNode.language")
                .where("lNode.nodeId", nodeId);
            const translations = rows.map((row) => {
                const language = LNodeLanguageRowAT.assert(row).language;
                return {
                    language,
                    lNodeId: encodeLNodeId({
                        language,
                        nodeId,
                    }),
                };
            });
            return translations;
        },
        parentLanguages: async ({ nodeId }, _args, { siteContext }) => {
            siteReadyGuard(siteContext);
            return await getParentLanguages(siteContext, nodeId);
        },
        breadcrumb: async ({ nodeId, language }, _args, { siteContext }) => {
            siteReadyGuard(siteContext);
            const breadcrumb = await getBreadcrumb(siteContext, createNoTracker(), { nodeId, language });
            return breadcrumb.map((item) => ({
                language: item.documentId.language,
                nodeId: item.documentId.nodeId,
                typeName: item.typeName,
                lNodeId: encodeLNodeId(item.documentId),
                title: item.title,
            }));
        },
    },
};
//# sourceMappingURL=lnode-wrap.resolver.js.map