@paroicms/server/dist/common/text-cache.js

The ParoiCMS server

import { encodeLNodeId } from "@paroicms/public-anywhere-lib";
import { allDependencyKey } from "@paroicms/server-text-cache-system";
import { getParentDocumentIdsOf, getParentLNodeIdOf, getParentNodeIdOf, } from "../admin-backend/document/load-documents.queries.js";
import { normalizeUrlForCache } from "./url-helpers.js";
export function makeCacheDependencyKey(options) {
    if ("global" in options)
        return allDependencyKey;
    if ("relation" in options) {
        if (options.relation === "updated") {
            const { nodeId } = options;
            return `*:${nodeId}:updated`;
        }
        if (options.relation === "labeled") {
            const { termNodeId, fieldName } = options;
            return `*:${termNodeId}:labeled:${fieldName}`;
        }
    }
    if ("nodeId" in options) {
        return `*:${options.nodeId}`;
    }
    const encodedId = encodeLNodeId(options.documentId);
    if ("relation" in options)
        return `${encodedId}:${options.relation}`;
    if (options.perimeter)
        return `${encodedId}:${options.perimeter}`;
    return encodedId;
}
export function dependencyKeyOfMedia(mediaId) {
    return `media:${mediaId}`;
}
export function makeCacheKey(logger, options) {
    const { kind, url, urlKey, documentId } = options;
    if (kind === "html")
        return `${kind}:${normalizeUrlForCache(logger, url)}`;
    if (kind === "feed")
        return `${kind}:${normalizeUrlForCache(logger, url)}`;
    if (kind === "api")
        return `${kind}:${normalizeUrlForCache(logger, url)}`;
    if (kind === "redirect")
        return `${kind}:${urlKey}`;
    if (documentId)
        return `${kind}:${encodeLNodeId(documentId)}`;
    throw new Error("invalid parameter");
}
export function makePluginCacheKey(logger, options) {
    return `plugin:${options.pluginSlug}:${normalizeUrlForCache(logger, options.urlLike)}`;
}
export async function invalidateDocumentInCache(siteContext, options) {
    const documentId = "documentId" in options
        ? options.documentId
        : await getParentLNodeIdOf(siteContext, options.parentOf);
    if (!documentId)
        return;
    const fully = "fully" in options && options.fully;
    const withSlug = ("perimeter" in options && options.perimeter === "slug") || fully;
    const dependencyKeys = [
        makeCacheDependencyKey({ documentId }),
        makeCacheDependencyKey({ nodeId: documentId.nodeId }),
    ];
    if (withSlug) {
        dependencyKeys.push(makeCacheDependencyKey({ documentId, perimeter: "slug" }));
    }
    if (fully) {
        dependencyKeys.push(makeCacheDependencyKey({ documentId, relation: "children" }));
    }
    const parentId = "parentId" in options ? options.parentId : await getParentLNodeIdOf(siteContext, documentId);
    if (parentId) {
        dependencyKeys.push(makeCacheDependencyKey({ documentId: parentId, relation: "children" }));
    }
    await siteContext.textCache.invalidate(dependencyKeys);
}
export async function invalidateNodeInCache(siteContext, { nodeId }) {
    const languages = siteContext.siteSchema.languages;
    const documentIds = languages.map((language) => ({ language, nodeId }));
    const dependencyKeys = documentIds.map((documentId) => makeCacheDependencyKey({ documentId }));
    dependencyKeys.push(...documentIds.map((documentId) => makeCacheDependencyKey({ nodeId: documentId.nodeId })));
    const parentNodeId = await getParentNodeIdOf(siteContext, nodeId);
    if (parentNodeId) {
        const parentDocumentIds = siteContext.siteSchema.languages.map((language) => ({
            language,
            nodeId,
        }));
        dependencyKeys.push(...parentDocumentIds.map((documentId) => makeCacheDependencyKey({ documentId, relation: "children" })));
    }
    await siteContext.textCache.invalidate(dependencyKeys);
}
export async function invalidateDocumentRelationCache(siteContext, options) {
    await siteContext.textCache.invalidate([makeCacheDependencyKey(options)]);
}
export async function depKeysOfNodeRelationCache(siteContext, options) {
    const nodeId = await getParentNodeIdOf(siteContext, options.parentOfNodeId);
    if (nodeId === undefined)
        return [];
    const documentIds = siteContext.siteSchema.languages.map((language) => ({ language, nodeId }));
    return documentIds.map((documentId) => makeCacheDependencyKey({ documentId, relation: "children" }));
}
export async function invalidateMultipleDocumentsInCache(siteContext, options) {
    const languages = siteContext.siteSchema.languages;
    const nodeId = "nodeId" in options
        ? options.nodeId
        : await getParentNodeIdOf(siteContext, options.parentOfNodeId);
    if (nodeId === undefined)
        return;
    const dependencyKeys = makeDependencyKeysForDocuments(siteContext, nodeId, options);
    const parentIds = "parentIds" in options && options.parentIds !== undefined
        ? options.parentIds
        : await getParentDocumentIdsOf(siteContext, {
            languages,
            nodeId,
        });
    dependencyKeys.push(...parentIds.map((parentId) => makeCacheDependencyKey({ documentId: parentId, relation: "children" })));
    await siteContext.textCache.invalidate(dependencyKeys);
}
export function makeDependencyKeysForDocuments(siteContext, nodeId, options = {}) {
    const languages = siteContext.siteSchema.languages;
    const documentIds = languages.map((language) => ({ language, nodeId }));
    const dependencyKeys = [makeCacheDependencyKey({ nodeId })];
    for (const documentId of documentIds) {
        dependencyKeys.push(makeCacheDependencyKey({ documentId }));
        if (options.fully) {
            dependencyKeys.push(makeCacheDependencyKey({ documentId, perimeter: "slug" }), makeCacheDependencyKey({ documentId, relation: "children" }));
        }
    }
    return dependencyKeys;
}
//# sourceMappingURL=text-cache.js.map