@paroicms/server
Version:
The ParoiCMS server
198 lines • 8.77 kB
JavaScript
import { getNodeTypeByName, getPartTypeByName } from "@paroicms/internal-anywhere-lib";
import { encodeLNodeId, isJsonFieldValue, isMediaHandleValue, isPartFieldValue, isReadLabelingValue, pickATermTitle, } from "@paroicms/public-anywhere-lib";
import { getHandleOfFieldOnNode, } from "@paroicms/public-server-lib";
import { loadFieldValues } from "../admin-backend/fields/load-fields.queries.js";
import { toTpSourceMedia } from "../common/medias/to-media-values.js";
import { makeCacheDependencyKey } from "../common/text-cache.js";
import { getNodeTypeLabel } from "../helpers/label-translator.helper.js";
import { createLiquidDrop } from "../liquidjs-tools/liquidjs-drop.js";
import { executeRenderingHook } from "../plugin-services/rendering-hook.js";
import { getUrlOfDocument } from "../rendered-site/page-route/make-url.js";
import { loadDefaultImage } from "./load-default-image.js";
export async function loadPublicFieldValues(renderingContext, options) {
const { siteContext } = renderingContext;
let fieldTypes = getNodeTypeByName(siteContext.siteSchema, options.typeName).fields ?? [];
const { fieldNames } = options;
if (fieldNames) {
fieldTypes = fieldTypes.filter((f) => fieldNames.includes(f.name));
}
const rawValues = await loadFieldValues(siteContext, {
fieldTypes,
nodeId: options.lNodeId.nodeId,
language: options.lNodeId.language,
publishedOnly: true,
});
const values = await executeRenderingHook(renderingContext, "fieldPreprocessor", {
fieldTypes,
values: rawValues,
options: {
absoluteUrls: false,
},
});
const map = new Map(fieldTypes.map((f) => [f.name, f]));
const result = {};
for (const [fieldName, value] of Object.entries(values)) {
const fType = map.get(fieldName);
if (!fType || !(fType.name in values))
throw new Error(`missing field type for '${fieldName}'`);
result[fieldName] = makeFieldValueOrLoader(renderingContext, fType, value, options.lNodeId.language);
if (fType.withGallery) {
result[`${fieldName}_gallery`] = createWithGalleryFieldLoader(renderingContext, fType, options.lNodeId.nodeId);
}
}
return createLiquidDrop(renderingContext, {
renderingCacheKey: `fields:${encodeLNodeId(options.lNodeId)}:${options.fieldNames?.join(",") ?? "full"}`,
values: result,
});
}
function createWithGalleryFieldLoader(renderingContext, fieldType, nodeId) {
const { siteContext } = renderingContext;
const handle = getHandleOfFieldOnNode({
siteNodeId: siteContext.siteNodeId,
nodeId,
fieldName: fieldType.name,
});
return makeMediaFieldLoader(renderingContext, {
dataType: "gallery",
}, handle);
}
function makeFieldValueOrLoader(renderingContext, fType, val, language) {
if (fType.storedAs === "mediaHandle") {
if (!isMediaHandleValue(val))
throw new Error(`invalid media handle value for "${fType.name}"`);
return makeMediaFieldLoader(renderingContext, fType, val.h);
}
if (fType.storedAs === "partField") {
if (!isPartFieldValue(val))
return;
return createPartFieldLiquidLoader(renderingContext, fType, val.p.nodeId, language);
}
if (val === undefined)
return;
if (fType.storedAs === "labeling") {
if (!isReadLabelingValue(val)) {
throw new Error(`invalid labeling field value for "${fType.name}"`);
}
return val.t.map((t) => createTpTerm(renderingContext, t, language));
}
if (isJsonFieldValue(val))
return val.j;
return val;
}
function createTpTerm(renderingContext, term, rightLanguage) {
const { siteContext } = renderingContext;
const { language, title } = pickATermTitle(term, rightLanguage);
const termId = { language, nodeId: term.nodeId };
const inRightLanguage = rightLanguage === language;
renderingContext.addDependencyKey(makeCacheDependencyKey({ documentId: termId }));
return createLiquidDrop(renderingContext, {
renderingCacheKey: `term:${encodeLNodeId(termId)}`,
values: {
nodeId: term.nodeId,
title,
inRightLanguage,
language,
languageLabel: siteContext.siteSchema.languageLabels[language],
url: inRightLanguage
? async () => await getUrlOfDocument(siteContext, renderingContext.tracker, {
nodeId: term.nodeId,
language,
}, { forPreview: renderingContext.isPreview })
: undefined,
},
}, {
loadDescriptor: {
load: "one",
nodeKind: "document",
descriptorName: "id",
documentId: termId,
},
});
}
function makeMediaFieldLoader(renderingContext, fType, handle) {
const { siteContext, withAttachedData } = renderingContext;
return async () => {
if (fType.dataType === "media") {
const media = await siteContext.mediaStorage.getMedia({ handle, withAttachedData });
return media ? toTpSourceMedia(renderingContext, media) : undefined;
}
const medias = await siteContext.mediaStorage.getMedias({ handle, withAttachedData });
const renderedMedias = medias.map((m) => toTpSourceMedia(renderingContext, m, { galleryHandle: handle }));
renderingContext.sourceImagesByGalleryHandles.set(handle, renderedMedias.filter((m) => m.kind === "image"));
return medias.length === 0 ? undefined : renderedMedias;
};
}
function createPartFieldLiquidLoader(renderingContext, fType, partNodeId, language) {
return async () => {
const { siteContext } = renderingContext;
const partType = getPartTypeByName(siteContext.siteSchema, fType.partType);
const lNodeId = { nodeId: partNodeId, language };
const typeLabel = getNodeTypeLabel(siteContext.siteSchema, {
language,
typeName: fType.partType,
});
return createLiquidDrop(renderingContext, {
renderingCacheKey: `partField:${encodeLNodeId(lNodeId)}`,
values: {
kind: "part",
leafType: async () => {
siteContext.logger.warn("'leafType' is deprecated, use 'type' instead");
return fType.partType;
},
get leafId() {
siteContext.logger.warn("'leafId' is deprecated, use 'nodeId' instead");
return partNodeId;
},
id: encodeLNodeId(lNodeId),
type: fType.partType,
nodeId: partNodeId,
language,
relativeId: "",
number: 1,
numberOfType: 1,
inRightLanguage: true,
publishDate: "",
languageLabel: siteContext.siteSchema.languageLabels[language] ?? "",
typeLabel,
num: () => {
siteContext.logger.warn("'num' is deprecated, use 'number' instead");
return 1;
},
defaultImage: async () => {
const image = await loadDefaultImage(renderingContext, {
fieldTypes: partType.fields,
nodeId: partNodeId,
language,
});
return image ? toTpSourceMedia(renderingContext, image) : undefined;
},
defaultImageId: async () => {
siteContext.logger.warn("'defaultImageId' is deprecated, use 'defaultImage' instead");
const image = await loadDefaultImage(renderingContext, {
fieldTypes: partType.fields,
nodeId: partNodeId,
language,
});
return image?.id;
},
field: () => loadPublicFieldValues(renderingContext, {
typeName: fType.partType,
lNodeId,
}),
fields: () => {
siteContext.logger.warn("'part.fields' is deprecated, use 'part.field' instead");
return loadPublicFieldValues(renderingContext, {
typeName: fType.partType,
lNodeId,
});
},
parts: () => {
if (!partType.list)
return;
return undefined;
},
},
});
};
}
//# sourceMappingURL=field-values.js.map