@paroicms/server/dist/public-api/public-api-rendering.js

The ParoiCMS server

import { type } from "arktype";
import { serveTextFromCacheOr } from "../common/serve-text-or.js";
import { makeCacheDependencyKey } from "../common/text-cache.js";
import { trackerReportToMessage } from "../common/tracker-report.js";
import { loadRoutingClusterFromNode } from "../connector/db-init/load-routing-cluster.queries.js";
import { renderLiquidTemplate } from "../liquidjs-tools/liquidjs-rendering/render-liquidjs.js";
import { toTpClusterPayload } from "../rendering-payload/cluster-payloads.js";
import { createDocPayloadDrop } from "../rendering-payload/create-doc-drop.js";
import { getListOfDocValues } from "../rendering-payload/doc-values.queries.js";
import { makeSitePayload } from "../rendering-payload/site-payload.js";
import { searchText } from "./search-text/search-text.queries.js";
const NumberAT = type("number");
export async function renderChildPartials(renderingContext, httpContext, options) {
    const { params, parentDocumentId, labeledBy } = options;
    const { siteContext, tracker, cacheKey } = renderingContext;
    const serveOr = serveTextFromCacheOr(siteContext, httpContext, tracker, {
        cacheKey,
        contentType: "text/plain; charset=utf-8",
    });
    if (!(await serveOr.serveFromCache())) {
        renderingContext.addDependencyKey(makeCacheDependencyKey({ documentId: parentDocumentId, relation: "children" }));
        const { html, dependencyKeys } = await renderChildDocuments(renderingContext, {
            parentId: parentDocumentId,
            limit: params.limit,
            offset: params.offset,
            templateName: params.templateName,
            labeledBy,
        });
        await serveOr.putInCacheAndServe(html, dependencyKeys);
    }
    siteContext.logger.stats(trackerReportToMessage(tracker.toReport(), `serve ${httpContext.req.relativeUrl}`));
}
export async function renderSearchPartials(renderingContext, httpContext, options) {
    const { language, words, limit, start, templateName } = options;
    const { siteContext, tracker, cacheKey } = renderingContext;
    const serveOr = serveTextFromCacheOr(siteContext, httpContext, tracker, {
        cacheKey,
        contentType: "application/json",
    });
    if (!(await serveOr.serveFromCache())) {
        renderingContext.addDependencyKey(makeCacheDependencyKey({ global: "all" }));
        const { result, dependencyKeys } = await searchAndRender(renderingContext, {
            language,
            words,
            limit: NumberAT.assert(limit),
            start: NumberAT.assert(start),
            templateName,
        });
        const content = JSON.stringify(result);
        await serveOr.putInCacheAndServe(content, dependencyKeys);
        await renderingContext.close();
    }
    siteContext.logger.stats(trackerReportToMessage(tracker.toReport(), `serve ${httpContext.req.relativeUrl}`));
}
async function renderChildDocuments(renderingContext, options) {
    const { parentId: parentDocumentId, templateName } = options;
    const docs = await getListOfDocValues(renderingContext, {
        ...options,
        documentKind: "regular",
    });
    const result = [];
    for (const row of docs) {
        const cluster = await getClusterForDocument(renderingContext, row, parentDocumentId.language);
        const payload = {
            site: makeSitePayload(renderingContext, parentDocumentId.language),
            cluster,
            doc: createDocPayloadDrop(renderingContext, row),
        };
        const html = await renderLiquidTemplate(renderingContext, {
            payload,
            templateNames: [`partials/${templateName}.public.liquid`],
        });
        result.push(html);
    }
    return {
        html: result.join(""),
        dependencyKeys: renderingContext.getDependencyKeys(),
    };
}
async function searchAndRender(renderingContext, options) {
    const { siteContext } = renderingContext;
    const { language, templateName } = options;
    const { rows, total } = await searchText(siteContext, { ...options, onlyPublished: true });
    const htmlList = [];
    for (const row of rows) {
        const cluster = await getClusterForDocument(renderingContext, row, language);
        const payload = {
            site: makeSitePayload(renderingContext, language),
            cluster,
            doc: createDocPayloadDrop(renderingContext, row),
        };
        const tName = templateName.endsWith(".public") ? templateName : `${templateName}.public`;
        const html = await renderLiquidTemplate(renderingContext, {
            payload,
            templateNames: [`partials/${tName}.liquid`],
        });
        htmlList.push(html);
    }
    return {
        result: {
            html: htmlList.join(""),
            total,
        },
        dependencyKeys: renderingContext.getDependencyKeys(),
    };
}
async function getClusterForDocument(renderingContext, document, language) {
    const cluster = await loadRoutingClusterFromNode(renderingContext.siteContext, {
        nodeId: document.nodeId,
        typeName: document.type,
    });
    return toTpClusterPayload(renderingContext, language, cluster);
}
//# sourceMappingURL=public-api-rendering.js.map