@paroicms/server/dist/admin-backend/fields/labeling.queries.js

The ParoiCMS server

import { type } from "arktype";
const LabelingFieldRowAT = type({
    field: "string",
    termId: "number",
    typeName: "string",
    language: "string",
    title: "string|null",
    "+": "reject",
}).pipe((r) => ({
    fieldName: r.field,
    nodeId: String(r.termId),
    typeName: r.typeName,
    language: r.language,
    title: r.title ?? undefined,
}));
export async function loadFieldLabelingValues(siteContext, { nodeId, fieldTypes, publishedOnly, }) {
    if (fieldTypes.length === 0)
        return;
    const query = siteContext
        .cn("PaFieldLabeling as l")
        .join("PaNode as o", "o.id", "l.termId")
        .join("PaLNode as n", "n.nodeId", "o.id")
        .join("PaDocument as d", {
        "d.nodeId": "n.nodeId",
        "d.language": "n.language",
    })
        .select("l.field", "l.termId", "o.typeName", "d.language", "d.title")
        .where("l.nodeId", nodeId)
        .where("n.ready", true)
        .whereIn("l.field", fieldTypes.map((f) => f.name))
        .orderBy("l.field", "asc")
        .orderBy("l.orderNum", "asc");
    if (publishedOnly) {
        query.whereRaw("o.publishDate <= current_timestamp");
    }
    const rows = await query;
    const fetchedTerms = rows.map((row) => LabelingFieldRowAT.assert(row));
    const result = new Map();
    for (const fetchedTerm of fetchedTerms) {
        const { fieldName, nodeId, language, title, typeName } = fetchedTerm;
        let terms = result.get(fieldName);
        if (!terms) {
            terms = [];
            result.set(fieldName, terms);
        }
        const existingTerm = terms.find((term) => term.nodeId === nodeId);
        if (existingTerm) {
            existingTerm.title[language] = title;
        }
        else {
            terms.push({
                nodeId,
                typeName,
                title: { [language]: title },
            });
        }
    }
    return result;
}
const TaxonomyRowAT = type({
    id: "number",
    typeName: "string",
    "+": "reject",
}).pipe((r) => ({
    id: String(r.id),
    typeName: r.typeName,
}));
export async function saveFieldLabeling(tx, { fieldType, nodeId, termNodeIds, }) {
    await tx("PaFieldLabeling")
        .where({
        field: fieldType.name,
        nodeId,
    })
        .delete();
    if (!termNodeIds || termNodeIds.length === 0)
        return;
    const taxonomyRows = await tx("PaNode as n")
        .join("PaNode as p", "p.id", "n.parentId")
        .select("p.id", "p.typeName")
        .distinct()
        .whereIn("n.id", termNodeIds);
    if (taxonomyRows.length !== 1) {
        throw new Error(`Invalid terms for "${fieldType.name}" field: "${termNodeIds.join()}"`);
    }
    const taxonomyTypeName = TaxonomyRowAT.assert(taxonomyRows[0]).typeName;
    if (taxonomyTypeName !== fieldType.taxonomy) {
        throw new Error(`Terms don't belong to taxonomy "${fieldType.name}"`);
    }
    await tx("PaFieldLabeling").insert(termNodeIds.map((termId, index) => ({
        field: fieldType.name,
        nodeId,
        termId,
        orderNum: index,
        plugin: fieldType.pluginName ?? null,
    })));
}
//# sourceMappingURL=labeling.queries.js.map