@cosmicdrift/kumiko-renderer-puppeteer-client 0.387.0 → 0.389.0

package/dist/document-pdf.js

@@ -10,6 +10,7 @@ import { collectRegionResourceKeys, compileDocumentSource, createDocumentHandleb
 const LINE_BREAKS = /[\r\n]+/g;
 const IMAGE_CONTENT_TYPE_PREFIX = "image/";
 const MAX_RECORD_IMAGES = 24;
+const MAX_RECORD_IMAGE_LOOKUPS = 100;
 const MAX_RECORD_IMAGES_TOTAL_BYTES = 20 * 1024 * 1024;
 const PREVIEW_PAGE_NUMBER = "1";
 const EMPTY_CHROMIUM_REGION = "<span></span>";
@@ -176,8 +177,10 @@ async function loadRecordImageDataUris(ctx, variables, imageVariableNames) {
         for (const fileRefId of fileRefIdsOf(variables[name])) {
             if (seenIds.has(fileRefId))
                 continue;
+            if (seenIds.size >= MAX_RECORD_IMAGE_LOOKUPS)
+                break;
             seenIds.add(fileRefId);
-            if (loadedCount >= MAX_RECORD_IMAGES)
+            if (loadedCount >= MAX_RECORD_IMAGES || loadedBytes >= MAX_RECORD_IMAGES_TOTAL_BYTES)
                 break;
             const image = await readRecordImage(ctx, filesForTenant, fileRefId, Math.min(maxBytes, MAX_RECORD_IMAGES_TOTAL_BYTES - loadedBytes));
             if (image === null)
@@ -190,10 +193,22 @@ async function loadRecordImageDataUris(ctx, variables, imageVariableNames) {
     }
     return dataUrisByVariable;
 }
-// Text context without images variables: their value is file ids, which no placeholder,
-// title or file name pattern may print.
-function withoutImageVariables(variables, definitions) {
-    return Object.fromEntries(Object.entries(variables).filter(([name]) => !(Object.hasOwn(definitions, name) && definitions[name]?.type === "images")));
+function isImagesVariable(definitions, name) {
+    return Object.hasOwn(definitions, name) && definitions[name]?.type === "images";
+}
+// An images variable's value is file ids, which no placeholder, title or file name pattern
+// may print; the text context carries only whether images exist, so a condition on it works.
+function imagesAsPresenceFlags(variables, definitions, recordImages, recordImageUris) {
+    const hasImages = (name) => {
+        if (recordImages === "placeholder")
+            return true;
+        const resolved = recordImageUris.get(name);
+        return resolved !== undefined ? resolved.length > 0 : fileRefIdsOf(variables[name]).length > 0;
+    };
+    return Object.fromEntries(Object.entries(variables).map(([name, value]) => [
+        name,
+        isImagesVariable(definitions, name) ? hasImages(name) : value,
+    ]));
 }
 function renderRegion(hbs, region, context, resourceSrc) {
     if (region.trim() === "")
@@ -304,17 +319,17 @@ async function assembleDocument(input, ctx, markers, recordImages = "placeholder
         ]);
         const hbs = createDocumentHandlebars(format);
         const variableDefinitions = resolveTemplateVariables(ctx.registry, slug, template.variableSchema);
+        const recordImageUris = recordImages === "resolve"
+            ? await loadRecordImageDataUris(ctx, variables, collectDocumentImageVariables(template.content).filter((name) => isImagesVariable(variableDefinitions, name)))
+            : new Map();
         const context = {
-            ...withoutImageVariables(variables, variableDefinitions),
+            ...imagesAsPresenceFlags(variables, variableDefinitions, recordImages, recordImageUris),
             tenantName,
             signature: "",
             imprint: "",
             page: "",
             pages: "",
         };
-        const recordImageUris = recordImages === "resolve"
-            ? await loadRecordImageDataUris(ctx, variables, collectDocumentImageVariables(template.content))
-            : new Map();
         const bodyKeys = collectDocumentResourceKeys(template.content);
         const layoutKeys = collectRegionResourceKeys(layout.regions);
         const bodyRefs = await resolveResourceFileRefs(tplApi, ctx, template, bodyKeys);

package/dist/index.d.ts

@@ -5,4 +5,4 @@ export { createRendererPuppeteerClientFeature } from "./feature.ts";
 export { countPdfPages } from "./pdf-page-count.ts";
 export { RendererPuppeteerClientQueries } from "./qualified-names.ts";
 export { puppeteerRender } from "./render.ts";
-export { type RenderedPdfUpload, type RenderPdfArgs, renderPdfBeforeTransaction, type StoredRenderedPdf, storeRenderedPdf, } from "./render-and-store.ts";
+export { type RenderedPdfBytes, type RenderedPdfUpload, type RenderPdfArgs, renderPdfBeforeTransaction, renderPdfBytes, type StoredRenderedPdf, storeRenderedPdf, } from "./render-and-store.ts";

package/dist/index.js

@@ -5,4 +5,4 @@ export { createRendererPuppeteerClientFeature } from "./feature.js";
 export { countPdfPages } from "./pdf-page-count.js";
 export { RendererPuppeteerClientQueries } from "./qualified-names.js";
 export { puppeteerRender } from "./render.js";
-export { renderPdfBeforeTransaction, storeRenderedPdf, } from "./render-and-store.js";
+export { renderPdfBeforeTransaction, renderPdfBytes, storeRenderedPdf, } from "./render-and-store.js";

package/dist/render-and-store.d.ts

@@ -31,5 +31,14 @@ export type StoredRenderedPdf = {
     readonly layout?: RenderedTemplateRef;
 };
 export declare function clientErrorForRenderFailure(e: unknown, ctx: HandlerContext, slug: string): KumikoError;
+export type RenderedPdfBytes = {
+    readonly fileName: string;
+    readonly pdfBytes: Uint8Array;
+    readonly pageCount: number;
+    readonly sizeBytes: number;
+    readonly template: RenderedTemplateRef;
+    readonly layout?: RenderedTemplateRef;
+};
+export declare function renderPdfBytes(ctx: HandlerContext, args: Pick<RenderPdfArgs, "slug" | "locale" | "variables">): Promise<WriteResult<RenderedPdfBytes>>;
 export declare function renderPdfBeforeTransaction(ctx: HandlerContext, args: RenderPdfArgs): Promise<BeforeTransactionResult<RenderedPdfUpload>>;
 export declare function storeRenderedPdf(ctx: HandlerContext, rendered: RenderedPdfUpload): Promise<WriteResult<StoredRenderedPdf>>;

package/dist/render-and-store.js

@@ -25,9 +25,9 @@ export function clientErrorForRenderFailure(e, ctx, slug) {
 function renderFailure(e, ctx, slug) {
     return writeFailure(clientErrorForRenderFailure(e, ctx, slug));
 }
-// Renders and uploads the PDF while no transaction is open: the print service call can take
-// seconds and must not hold a pool connection. Use as a handler's `beforeTransaction`.
-export async function renderPdfBeforeTransaction(ctx, args) {
+// Renders without storing: no file, no rendered-pdf row. For callers that keep the bytes
+// themselves (mail attachment, download); same no-transaction rule as renderPdfBeforeTransaction.
+export async function renderPdfBytes(ctx, args) {
     const tenantId = ctx.user.tenantId;
     const plugin = createRendererFoundationApi(collectRendererPlugins(ctx.registry)).createRendererForTenant({ tenantId, kind: "document-pdf" });
     let response;
@@ -53,15 +53,35 @@ export async function renderPdfBeforeTransaction(ctx, args) {
     if (template === undefined) {
         throw new RendererError(`renderer "${plugin.name}" did not report which template produced the PDF`, "other");
     }
+    return {
+        isSuccess: true,
+        data: {
+            fileName: response.fileName,
+            pdfBytes: response.pdfBytes,
+            pageCount: response.pageCount,
+            sizeBytes: response.sizeBytes,
+            template,
+            ...(layout !== undefined && { layout }),
+        },
+    };
+}
+// Renders and uploads the PDF while no transaction is open: the print service call can take
+// seconds and must not hold a pool connection. Use as a handler's `beforeTransaction`.
+export async function renderPdfBeforeTransaction(ctx, args) {
+    const rendered = await renderPdfBytes(ctx, args);
+    if (!rendered.isSuccess)
+        return rendered;
+    const { fileName, pdfBytes, pageCount, sizeBytes, template, layout } = rendered.data;
+    const tenantId = ctx.user.tenantId;
     const uploaded = await uploadFileBytesBeforeTransaction({
         db: ctx.db,
         files: fileContextForTenant(ctx, tenantId, tenantId),
         registry: ctx.registry,
         user: ctx.user,
     }, {
-        fileName: response.fileName,
+        fileName,
         mimeType: PDF_MIME_TYPE,
-        data: response.pdfBytes,
+        data: pdfBytes,
         ...(args.attachTo !== undefined && { attachTo: args.attachTo }),
     });
     if (!uploaded.isSuccess)
@@ -74,8 +94,8 @@ export async function renderPdfBeforeTransaction(ctx, args) {
             locale: args.locale,
             template,
             ...(layout !== undefined && { layout }),
-            pageCount: response.pageCount,
-            sizeBytes: response.sizeBytes,
+            pageCount,
+            sizeBytes,
         },
         ...(uploaded.release && { release: uploaded.release }),
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer-puppeteer-client",
-  "version": "0.387.0",
+  "version": "0.389.0",
   "description": "Renderer-Foundation plugin: HTTP client for puppeteer-service (PDF + image snapshot via remote browser).",
   "license": "MIT",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -19,13 +19,13 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.387.0",
-    "@cosmicdrift/kumiko-framework": "0.387.0",
-    "@cosmicdrift/kumiko-renderer-mail-html": "0.387.0",
-    "@cosmicdrift/kumiko-types": "0.387.0"
+    "@cosmicdrift/kumiko-bundled-features": "0.389.0",
+    "@cosmicdrift/kumiko-framework": "0.389.0",
+    "@cosmicdrift/kumiko-renderer-mail-html": "0.389.0",
+    "@cosmicdrift/kumiko-types": "0.389.0"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-testing": "0.387.0"
+    "@cosmicdrift/kumiko-testing": "0.389.0"
   },
   "repository": {
     "type": "git",

package/src/changes.json

@@ -1,4 +1,16 @@
 [
+  {
+    "version": "0.389.0",
+    "type": "improvement",
+    "title": "Render a PDF without storing it",
+    "detail": "renderPdfBytes is the render half of renderPdfBeforeTransaction. Use it when the bytes go straight into a mail or a download and no file or rendered-pdf row should exist."
+  },
+  {
+    "version": "0.388.0",
+    "type": "fix",
+    "title": "Conditions on images variables work in the PDF render",
+    "detail": "A data-condition on an images variable now shows its block when the record has resolvable images, instead of never. Record image loading stops once the byte budget is used up, caps the number of looked-up ids, and ignores image blocks whose variable is not declared as images."
+  },
   {
     "version": "0.379.0",
     "type": "improvement",