@paroicms/connector/dist/db-init/load-routing-documents.js

An API to help build management tools for ParoiCMS instances

import { getRoutingDocumentTypeByName } from "@paroicms/internal-anywhere-lib";
import { encodeLNodeId } from "@paroicms/public-anywhere-lib";
import { type } from "arktype";
export async function loadRoutingDocuments(cn, siteSchema) {
    const siteNodeId = await loadSiteNodeId(cn);
    if (siteNodeId === undefined)
        throw new Error("Missing siteNodeId");
    const { home: routingIds } = await loadChildRoutingIds(cn, siteSchema, siteNodeId, [
        siteSchema.nodeTypes.home,
    ]);
    return {
        siteNodeId,
        homeIds: routingIds,
    };
}
const LoadSiteNodeIdAT = type({
    id: "number",
    "+": "reject",
}).pipe((r) => ({
    id: String(r.id),
}));
async function loadSiteNodeId(cn) {
    const rows = await cn("PaNode")
        .select("id")
        .where("depth", -1)
        .andWhere("typeName", "_site");
    if (rows.length === 0)
        return;
    if (rows.length !== 1)
        throw new Error(`it should not exist '${rows.length}' site nodes`);
    const [row] = rows;
    return LoadSiteNodeIdAT.assert(row).id;
}
const LoadChildRoutingIdsAT = type({
    nodeId: "number",
    language: "string",
    typeName: "string",
    "+": "reject",
}).pipe((r) => ({
    nodeId: String(r.nodeId),
    language: r.language,
    typeName: r.typeName,
}));
async function loadChildRoutingIds(cn, siteSchema, parentNodeId, childTypes) {
    const rows = await cn("PaLNode as s")
        .select("s.nodeId", "s.language", "l.typeName")
        .innerJoin("PaNode as l", "l.id", "s.nodeId")
        .where("l.parentId", parentNodeId)
        .whereIn("l.typeName", childTypes.map((t) => t.typeName))
        .whereIn("s.language", siteSchema.languages);
    const formattedRows = rows.map((row) => LoadChildRoutingIdsAT.assert(row));
    const map = new Map();
    for (const row of formattedRows) {
        let ids = map.get(row.typeName);
        if (!ids) {
            ids = {
                nodeId: row.nodeId,
                typeName: row.typeName,
                lNodeIds: {},
            };
            map.set(row.typeName, ids);
        }
        ids.lNodeIds[row.language] = encodeLNodeId(row);
    }
    for (const childType of childTypes) {
        const ids = map.get(childType.typeName);
        if (!ids) {
            throw new Error(`missing document-type '${childType.typeName}' in the database, for parent '${parentNodeId}'`);
        }
        const languages = Object.keys(ids.lNodeIds);
        if (languages.length !== siteSchema.languages.length) {
            throw new Error(`missing lNode(s) for '${childType.typeName}' in the database, found languages '${languages.join(",")}'`);
        }
        const subTypes = routingChildrenOf(siteSchema, childType);
        if (subTypes.length > 0) {
            ids.children = await loadChildRoutingIds(cn, siteSchema, ids.nodeId, subTypes);
        }
    }
    return Object.fromEntries(map);
}
function routingChildrenOf(siteSchema, documentType) {
    const typeNames = documentType.routingChildren ?? [];
    return typeNames.map((typeName) => getRoutingDocumentTypeByName(siteSchema, typeName));
}
//# sourceMappingURL=load-routing-documents.js.map