@vertesia/workflow 0.51.0 → 0.54.0

package/src/conversion/image.test.ts

@@ -1,26 +1,118 @@
-import fs from 'fs';
-import path from 'path';
-import sharp from 'sharp';
-import { expect, test } from 'vitest';
-import { imageResizer } from '../conversion/image';
+import fs from "fs";
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { expect, test, vi, describe } from "vitest";
 
+// Mock Temporal activity context
+vi.mock("@temporalio/activity", () => ({
+    log: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    },
+}));
 
-test('should resize an image to a maximum height or width', async () => {
-  const max_hw = 1024;
-  const format: keyof sharp.FormatEnum = 'jpeg';
-  const imageFile = fs.readFileSync(path.join(__dirname, '../../fixtures', 'cat-picture.jpg'));
+// Import after mocking
+import { imageResizer } from "../conversion/image";
 
-  const resizer = imageResizer(max_hw, format);
+const execAsync = promisify(exec);
 
-  const resized = sharp(imageFile).pipe(resizer);
-  const buffer = await resized.toBuffer();
-  const metadata = await sharp(buffer).metadata();
+describe("ImageMagick image resizing", () => {
+    test("should resize an image to a maximum height or width using ImageMagick", async () => {
+        const max_hw = 1024;
+        const format = "jpeg";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
 
-  console.log(metadata);
-  resized.toFile('/tmp/cat-picture.jpg');
+        // Make sure the input file exists
+        expect(fs.existsSync(inputImagePath)).toBe(true);
 
-  expect(metadata.width).to.be.lessThanOrEqual(max_hw);
-  expect(metadata.height).to.be.lessThanOrEqual(max_hw);
-  expect(metadata.format).to.equal(format);
+        // Call the imageResizer function with a file path
+        const resizedImagePath = await imageResizer(inputImagePath, max_hw, format);
 
+        // Make sure the output file exists
+        expect(fs.existsSync(resizedImagePath)).toBe(true);
+
+        // Use ImageMagick identify to get metadata about the resized image
+        const { stdout } = await execAsync(`identify -format "%w %h %m" "${resizedImagePath}"`);
+        const [width, height, imageFormat] = stdout.trim().split(" ");
+
+        console.log({ width, height, imageFormat });
+
+        // Check dimensions
+        expect(parseInt(width)).to.be.lessThanOrEqual(max_hw);
+        expect(parseInt(height)).to.be.lessThanOrEqual(max_hw);
+
+        // Check format (JPEG)
+        expect(imageFormat.toLowerCase()).to.equal("jpeg");
+    });
+
+    test("should throw an error for non-existent input file", async () => {
+        const max_hw = 1024;
+        const format = "jpeg";
+        const nonExistentPath = path.join(__dirname, "non-existent-image.jpg");
+
+        // Verify file doesn't exist
+        expect(fs.existsSync(nonExistentPath)).toBe(false);
+
+        // Expect the function to throw an error
+        await expect(imageResizer(nonExistentPath, max_hw, format)).rejects.toThrow("Input file does not exist");
+    });
+
+    test("should throw error with empty format", async () => {
+        const max_hw = 1024;
+        const format = "";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+
+        // Test for empty format validation
+        await expect(imageResizer(inputImagePath, max_hw, format)).rejects.toThrow("Invalid format");
+    });
+
+    test("should create progressive/interlaced image when enabled", async () => {
+        const max_hw = 800;
+        const format = "jpeg";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+
+        // Make sure the input file exists
+        expect(fs.existsSync(inputImagePath)).toBe(true);
+
+        // Call the imageResizer function with progressive=true
+        const resizedImagePath = await imageResizer(inputImagePath, max_hw, format, true);
+
+        // Make sure the output file exists
+        expect(fs.existsSync(resizedImagePath)).toBe(true);
+
+        // Use ImageMagick identify to check if the image is interlaced
+        const { stdout } = await execAsync(`identify -format "%[interlace]" "${resizedImagePath}"`);
+        const interlaceMode = stdout.trim();
+
+        console.log({ interlaceMode });
+
+        // Check that interlace is enabled (should be 'JPEG' or 'Line' for progressive JPEG)
+        expect(["JPEG", "Line", "Plane"]).to.include(interlaceMode);
+    });
+
+    test("should create non-interlaced image when progressive is disabled", async () => {
+        const max_hw = 800;
+        const format = "jpeg";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+
+        // Make sure the input file exists
+        expect(fs.existsSync(inputImagePath)).toBe(true);
+
+        // Call the imageResizer function with progressive=false
+        const resizedImagePath = await imageResizer(inputImagePath, max_hw, format, false);
+
+        // Make sure the output file exists
+        expect(fs.existsSync(resizedImagePath)).toBe(true);
+
+        // Use ImageMagick identify to check if the image is interlaced
+        const { stdout } = await execAsync(`identify -format "%[interlace]" "${resizedImagePath}"`);
+        const interlaceMode = stdout.trim().toLowerCase();
+
+        console.log({ interlaceMode });
+
+        // Check that interlace is disabled (should be 'none' or empty string)
+        expect(["none", ""]).to.include(interlaceMode);
+    });
 });

package/src/conversion/image.ts

@@ -1,22 +1,103 @@
-
-import sharp from "sharp";
-
+import { log } from "@temporalio/activity";
+import { execFile as execFileCallback } from "child_process";
+import fs from "fs";
+import { file } from "tmp-promise";
+import { promisify } from "util";
+const execFile = promisify(execFileCallback);
 
 /**
- * Resizes an image to a maximum height or width
- * @param max_hw 
- * @param format 
- * @returns 
+ * Resizes an image to a maximum height or width using ImageMagick
+ * with progressive loading when supported
+ * @param inputPath Input file path
+ * @param max_hw Maximum height or width
+ * @param format Output format
+ * @param progressive Enable progressive loading for supported formats (defaults to true)
+ * @returns Path to the resized image
  */
-export function imageResizer(max_hw: number, format: keyof sharp.FormatEnum) {
+export async function imageResizer(
+    inputPath: string,
+    max_hw: number,
+    format: string,
+    progressive: boolean = true,
+): Promise<string> {
+    log.info(`[image-resizer] Resizing image: ${inputPath} to max_hw: ${max_hw}, format: ${format}, progressive: ${progressive}`);
 
-    return sharp().resize({
-        width: max_hw,
-        height: max_hw,
-        fit: sharp.fit.inside,
-        withoutEnlargement: true,
+    const allowedFormats = ["jpg", "jpeg", "png", "webp"];
 
-    }).toFormat(format);
+    if (!format || format.trim() === "") {
+        throw new Error(`Invalid format: ${format}.Supported : ${allowedFormats.join(", ")}`);
+    }
 
-}
+    //check that max_hw is valid
+    if (!Number.isInteger(max_hw) || max_hw <= 0) {
+        throw new Error(`Invalid max_hw value: ${max_hw}`);
+    }
+
+    //check that inputPath exists
+    if (!fs.existsSync(inputPath)) {
+        throw new Error(`Input file does not exist: ${inputPath}`);
+    }
+
+    // Create a temporary file
+    const { path: outputPath, cleanup } = await file({ postfix: `.${format}` });
+    try {
+        // Check if input file exists
+        if (!fs.existsSync(inputPath)) {
+            throw new Error(`Input file does not exist: ${inputPath}`);
+        }
+        // Validate max_hw
+        if (!Number.isInteger(max_hw) || max_hw <= 0) {
+            throw new Error(`Invalid max_hw value: ${max_hw}`);
+        }
+
+        // Progressive loading options
+        let conversionOption = "";
+
+        // Only add progressive option for formats that support it
+        if (progressive) {
+            // JPEG and some other formats support progressive loading
+            const lowerFormat = format.toLowerCase();
+            if (lowerFormat === "jpg" || lowerFormat === "jpeg") {
+                conversionOption = "-interlace JPEG";
+                log.info(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
+            } else if (lowerFormat === "png") {
+                conversionOption = "-interlace PNG";
+                log.info(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
+            } else if (lowerFormat === "gif") {
+                conversionOption = "-interlace GIF";
+                log.info(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
+            }
+        }
 
+        log.info(`Resizing image using ImageMagick: ${inputPath} -> ${outputPath}`);
+
+        const command = `convert`
+        const args = [
+            inputPath,
+            "-resize",
+            `${max_hw}x${max_hw}>`,
+            ...(conversionOption ? conversionOption.split(" ") : []),
+            outputPath,
+        ];
+        log.info(`ImageMagick command: ${command} ${args.join(" ")}`);
+
+        const { stderr } = await execFile(command, args);
+
+        if (stderr) {
+            log.warn(`ImageMagick warning: ${stderr}`);
+        }
+
+        // Verify output exists and has content
+        if (!fs.existsSync(outputPath) || fs.statSync(outputPath).size === 0) {
+            throw new Error(`ImageMagick conversion failed: output file not created or empty`);
+        }
+
+        return outputPath;
+    } catch (error) {
+        // Clean up the temporary file
+        await cleanup();
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log.error(`Image conversion failed: ${errorMessage}`);
+        throw new Error(`Image conversion failed: ${errorMessage}`);
+    }
+}

package/src/conversion/markitdown.ts

@@ -0,0 +1,41 @@
+import { log } from "@temporalio/activity";
+import { spawn } from "child_process";
+import fs from "fs";
+import tmp from "tmp";
+
+export function markdownWithMarkitdown(buffer: Buffer, ext?: string): Promise<string> {
+    const inputFile = tmp.fileSync({ postfix: ext });
+    const targetFileName = tmp.tmpNameSync({ postfix: ".md" });
+
+    fs.writeSync(inputFile.fd, buffer);
+
+    return new Promise((resolve, reject) => {
+        const tool = "markitdown";
+        log.info(`Converting document to markdown with ${tool}`, { inputFile: inputFile.name, targetFileName });
+
+        const command = spawn(tool, [inputFile.name, "-o", targetFileName]);
+
+        command.on("exit", function (code) {
+            if (code) {
+                reject(new Error(`${tool} exited with code ${code}`));
+            }
+        });
+
+        command.on("close", function (code) {
+            if (code) {
+                reject(new Error(`${tool} exited with code ${code}`));
+            } else {
+                return fs.readFile(targetFileName, "utf8", (err, data) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    return resolve(data);
+                });
+            }
+        });
+
+        command.on("error", (err) => {
+            reject(err);
+        });
+    });
+}

package/src/conversion/mutool.ts

@@ -120,7 +120,7 @@ export async function pdfToImages(file: Buffer | string, pages?: number[]): Prom
 
 
 /**
- * Get somes pages from a PDF to create a new one
+ * Get some pages from a PDF to create a new one
  */
 
 export async function pdfExtractPages(file: Buffer | string, pages: number[]): Promise<string> {

package/src/conversion/pandoc.test.ts

@@ -2,21 +2,23 @@ import { MockActivityEnvironment, TestWorkflowEnvironment } from '@temporalio/te
 import fs from 'fs';
 import path from 'path';
 import { beforeAll, expect, test } from 'vitest';
-import { manyToMarkdown } from '../conversion/pandoc';
+import { markdownWithPandoc } from '../conversion/pandoc';
 
 
 let testEnv: TestWorkflowEnvironment;
 let activityContext: MockActivityEnvironment;
 
 beforeAll(async () => {
-  testEnv = await TestWorkflowEnvironment.createLocal();
-  activityContext = new MockActivityEnvironment();
+    testEnv = await TestWorkflowEnvironment.createLocal();
+    activityContext = new MockActivityEnvironment();
 });
 
 
 // Add more test cases for other file types (ODT, DOCX) if needed
 test('should convert docx to markdown', async () => {
-  const docx = fs.readFileSync(path.join(__dirname, '../../fixtures', 'us-ciia.docx'));
-  const result = await activityContext.run(manyToMarkdown, Buffer.from(docx), 'docx');
-  expect(result).to.include('confidential');
+    const filepath = path.join(__dirname, '../../fixtures', 'us-ciia.docx');
+    console.log("Converting file from", filepath);
+    const docx = fs.readFileSync(filepath);
+    const result = await activityContext.run(markdownWithPandoc, Buffer.from(docx), 'docx');
+    expect(result).to.include('confidential');
 });

package/src/conversion/pandoc.ts

@@ -1,44 +1,40 @@
-import { log } from '@temporalio/activity';
-import { spawn } from 'child_process';
-import { PassThrough } from 'stream';
-
-
-export function manyToMarkdown(buffer: Buffer, fromFormat: string): Promise<string> {
-
-  const fromType = undefined;
-
-  return new Promise((resolve, reject) => {
-    log.info(`Converting ${fromType} to markdown`);
-    const input = new PassThrough();
-    input.end(buffer);
-
-    let result: string[] = [];
-
-    const command = spawn("pandoc", ["-t", "markdown", '-f', fromFormat], {
-      stdio: 'pipe',
-    });
-    input.pipe(command.stdin);
-
-    command.stdout.on('data', function (data: string) {
-      result.push(data.toString());
-    });
-    command.on('exit', function (code) {
-      if (code) {
-        reject(new Error(`pandoc exited with code ${code}`));
-      }
+import { log } from "@temporalio/activity";
+import { spawn } from "child_process";
+import { PassThrough } from "stream";
+
+export function markdownWithPandoc(buffer: Buffer, fromFormat: string): Promise<string> {
+    const fromType = undefined;
+
+    return new Promise((resolve, reject) => {
+        log.info(`Converting ${fromType} to markdown`);
+        const input = new PassThrough();
+        input.end(buffer);
+
+        let result: string[] = [];
+
+        const command = spawn("pandoc", ["-t", "markdown", "-f", fromFormat], {
+            stdio: "pipe",
+        });
+        input.pipe(command.stdin);
+
+        command.stdout.on("data", function (data: string) {
+            result.push(data.toString());
+        });
+        command.on("exit", function (code) {
+            if (code) {
+                reject(new Error(`pandoc exited with code ${code}`));
+            }
+        });
+        command.on("close", function (code) {
+            if (code) {
+                reject(new Error(`pandoc exited with code ${code}`));
+            } else {
+                resolve(result.join(""));
+            }
+        });
+
+        command.on("error", (err) => {
+            reject(err);
+        });
     });
-    command.on('close', function (code) {
-      if (code) {
-        reject(new Error(`pandoc exited with code ${code}`));
-      } else {
-        resolve(result.join(''))
-      }
-    });
-
-    command.on('error', (err) => {
-      reject(err);
-    });
-
-  });
-
 }

package/src/dsl/dsl-workflow.ts

@@ -1,15 +1,30 @@
+import {
+    ActivityInterfaceFor,
+    ActivityOptions,
+    CancellationScope,
+    executeChild,
+    isCancellation,
+    log,
+    patched,
+    proxyActivities,
+    startChild,
+    UntypedActivities,
+} from "@temporalio/workflow";
 import {
     DSLActivityExecutionPayload,
     DSLActivityOptions,
     DSLActivitySpec,
     DSLChildWorkflowStep,
     DSLWorkflowExecutionPayload,
+    DSLWorkflowSpec,
+    getDocumentIds,
     WorkflowExecutionPayload
 } from "@vertesia/common";
-import { ActivityInterfaceFor, ActivityOptions, executeChild, log, proxyActivities, startChild, UntypedActivities } from "@temporalio/workflow";
 import ms, { StringValue } from 'ms';
 import { ActivityParamNotFound, NoDocumentFound, WorkflowParamNotFound } from "../errors.js";
 import { Vars } from "./vars.js";
+import { HandleDslErrorParams } from "../activities/handleError.js";
+import * as activities from "../activities/index.js";
 
 interface BaseActivityPayload extends WorkflowExecutionPayload {
     workflow_name: string;
@@ -30,7 +45,7 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
     if (!definition) {
         throw new WorkflowParamNotFound("workflow");
     }
-    // the base payload wiull be used to create the activities payload
+    // the base payload will be used to create the activities payload
     const basePayload: BaseActivityPayload = {
         ...payload,
         workflow_name: definition.name,
@@ -42,9 +57,9 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
         ...convertDSLActivityOptions(definition.options),
         startToCloseTimeout: "5 minute",
         retry: {
-            initialInterval: '30s',
+            initialInterval: '10s',
             backoffCoefficient: 2,
-            maximumAttempts: 20,
+            maximumAttempts: 10,
             maximumInterval: 100 * 30 * 1000, //ms
             nonRetryableErrorTypes: [
                 NoDocumentFound.name,
@@ -58,7 +73,7 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
     });
     const defaultProxy = proxyActivities(defaultOptions);
     log.debug("Default activity proxy is ready");
-    // merge default vars with the payload vars and add objectIds and obejctId
+    // merge default vars with the payload vars and add objectIds and objectId
     const vars = new Vars({
         ...definition.vars,
         ...payload.vars,
@@ -68,6 +83,26 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
 
     log.info("Executing workflow", { payload });
 
+    // TODO(mhuang): remove patch when all workflows are migrated to v2
+    //   It avoids breaking the ongoing workflow execution running in v1 and also allows us to
+    //   deploy the new error handler in production.
+    //   See https://docs.temporal.io/develop/typescript/versioning
+    if (patched('dsl-workflow-error-handling')) {
+        // v2: new version with error handler
+        try {
+            await executeSteps(definition, payload, basePayload, vars, defaultProxy, defaultOptions);
+        } catch (e) {
+            await handleError(e, basePayload, defaultOptions);
+        }
+    } else {
+        // v1: old version without error handler, deprecated since v0.52.0
+        await executeSteps(definition, payload, basePayload, vars, defaultProxy, defaultOptions);
+    }
+
+    return vars.getValue(definition.result || 'result');
+}
+
+async function executeSteps(definition: DSLWorkflowSpec, payload: DSLWorkflowExecutionPayload, basePayload: BaseActivityPayload, vars: Vars, defaultProxy: ActivityInterfaceFor<UntypedActivities>, defaultOptions: ActivityOptions) {
     if (definition.steps) {
         for (const step of definition.steps) {
             const stepType = step.type;
@@ -89,7 +124,32 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
     } else {
         throw new Error("No steps or activities found in the workflow definition");
     }
-    return vars.getValue(definition.result || 'result');
+}
+
+async function handleError(originalError: any, basePayload: BaseActivityPayload, defaultOptions: ActivityOptions) {
+    const { handleDslError } = proxyActivities<typeof activities>(defaultOptions);
+
+    const payload = dslActivityPayload(
+        basePayload,
+        {
+            name: "handleDslError",
+            params: { errorMessage: originalError.message },
+        } as DSLActivitySpec,
+        { errorMessage: originalError.message } satisfies HandleDslErrorParams,
+    )
+
+    if (isCancellation(originalError)) {
+        log.warn(`Workflow execution cancelled, executing error handler to update document status`, { error: originalError });
+        // Cleanup logic must be in a nonCancellable scope
+        // If we'd run cleanup outside of a nonCancellable scope it would've been cancelled
+        // before being started because the Workflow's root scope is cancelled.
+        // see https://docs.temporal.io/develop/typescript/cancellation
+        await CancellationScope.nonCancellable(() => handleDslError(payload));
+    } else {
+        log.warn(`Workflow execution failed, executing error handler to update document status`, { error: originalError });
+        handleDslError(payload);
+    }
+    throw originalError;
 }
 
 async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkflowExecutionPayload, vars: Vars, debug_mode?: boolean) {
@@ -101,14 +161,18 @@ async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkfl
     if (debug_mode) {
         log.debug(`Workflow vars before starting child workflow ${step.name}`, { vars: resolvedVars });
     }
-    //@ts-ignore
     const handle = await startChild(step.name, {
         ...step.options,
         args: [{
             ...payload,
             workflow: step.spec,
             vars: resolvedVars
-        }]
+        }],
+        searchAttributes: {
+            AccountId: [payload.account_id],
+            DocumentId: getDocumentIds(payload),
+            ProjectId: [payload.project_id],
+        },
     });
     if (step.output) {
         vars.setValue(step.output, handle.workflowId);
@@ -122,16 +186,20 @@ async function executeChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWork
         Object.assign(resolvedVars, step.vars);
     }
     if (debug_mode) {
-        log.debug(`Workflow vars before excuting child workflow ${step.name}`, { vars: resolvedVars });
+        log.debug(`Workflow vars before executing child workflow ${step.name}`, { vars: resolvedVars });
     }
-    //@ts-ignore
     const result = await executeChild(step.name, {
         ...step.options,
         args: [{
             ...payload,
             workflow: step.spec,
             vars: resolvedVars,
-        }]
+        }],
+        searchAttributes: {
+            AccountId: [payload.account_id],
+            DocumentId: getDocumentIds(payload),
+            ProjectId: [payload.project_id],
+        },
     });
 
     if (step.output) {
@@ -149,7 +217,7 @@ async function runActivity(activity: DSLActivitySpec, basePayload: BaseActivityP
         log.debug(`Workflow vars before executing activity ${activity.name}`, { vars: vars.resolve() });
     }
     if (activity.condition && !vars.match(activity.condition)) {
-        log.info("Activity skiped: condition not satisfied", activity.condition);
+        log.info("Activity skipped: condition not satisfied", activity.condition);
         return;
     }
     const importParams = vars.createImportVars(activity.import);