@vertesia/workflow 1.2.0 → 1.3.0-dev.20260620.061059Z

package/src/conversion/image.test.ts

@@ -1,11 +1,11 @@
-import fs from "fs";
-import path from "path";
-import { exec } from "child_process";
-import { promisify } from "util";
-import { expect, test, vi, describe } from "vitest";
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { describe, expect, test, vi } from 'vitest';
 
 // Mock Temporal activity context
-vi.mock("@temporalio/activity", () => ({
+vi.mock('@temporalio/activity', () => ({
     log: {
         debug: vi.fn(),
         info: vi.fn(),
@@ -15,15 +15,15 @@ vi.mock("@temporalio/activity", () => ({
 }));
 
 // Import after mocking
-import { imageResizer } from "../conversion/image";
+import { imageResizer } from '../conversion/image.js';
 
 const execAsync = promisify(exec);
 
-describe("ImageMagick image resizing", () => {
-    test("should resize an image to a maximum height or width using ImageMagick", async () => {
+describe('ImageMagick image resizing', () => {
+    test('should resize an image to a maximum height or width using ImageMagick', async () => {
         const max_hw = 1596;
-        const format = "jpeg";
-        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+        const format = 'jpeg';
+        const inputImagePath = path.join(__dirname, '../../fixtures', 'cat-picture.jpg');
 
         // Make sure the input file exists
         expect(fs.existsSync(inputImagePath)).toBe(true);
@@ -36,43 +36,43 @@ describe("ImageMagick image resizing", () => {
 
         // 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(" ");
+        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);
+        expect(parseInt(width, 10)).to.be.lessThanOrEqual(max_hw);
+        expect(parseInt(height, 10)).to.be.lessThanOrEqual(max_hw);
 
         // Check format (JPEG)
-        expect(imageFormat.toLowerCase()).to.equal("jpeg");
+        expect(imageFormat.toLowerCase()).to.equal('jpeg');
     });
 
-    test("should throw an error for non-existent input file", async () => {
+    test('should throw an error for non-existent input file', async () => {
         const max_hw = 1596;
-        const format = "jpeg";
-        const nonExistentPath = path.join(__dirname, "non-existent-image.jpg");
+        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");
+        await expect(imageResizer(nonExistentPath, max_hw, format)).rejects.toThrow('Input file does not exist');
     });
 
-    test("should throw error with empty format", async () => {
+    test('should throw error with empty format', async () => {
         const max_hw = 1596;
-        const format = "";
-        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+        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");
+        await expect(imageResizer(inputImagePath, max_hw, format)).rejects.toThrow('Invalid format');
     });
 
-    test("should create progressive/interlaced image when enabled", async () => {
+    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");
+        const format = 'jpeg';
+        const inputImagePath = path.join(__dirname, '../../fixtures', 'cat-picture.jpg');
 
         // Make sure the input file exists
         expect(fs.existsSync(inputImagePath)).toBe(true);
@@ -90,13 +90,13 @@ describe("ImageMagick image resizing", () => {
         console.log({ interlaceMode });
 
         // Check that interlace is enabled (should be 'JPEG' or 'Line' for progressive JPEG)
-        expect(["JPEG", "Line", "Plane"]).to.include(interlaceMode);
+        expect(['JPEG', 'Line', 'Plane']).to.include(interlaceMode);
     });
 
-    test("should create non-interlaced image when progressive is disabled", async () => {
+    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");
+        const format = 'jpeg';
+        const inputImagePath = path.join(__dirname, '../../fixtures', 'cat-picture.jpg');
 
         // Make sure the input file exists
         expect(fs.existsSync(inputImagePath)).toBe(true);
@@ -114,6 +114,6 @@ describe("ImageMagick image resizing", () => {
         console.log({ interlaceMode });
 
         // Check that interlace is disabled (should be 'none' or empty string)
-        expect(["none", ""]).to.include(interlaceMode);
+        expect(['none', '']).to.include(interlaceMode);
     });
 });

package/src/conversion/image.ts

@@ -1,8 +1,9 @@
-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";
+import { execFile as execFileCallback } from 'node:child_process';
+import fs from 'node:fs';
+import { promisify } from 'node:util';
+import { log } from '@temporalio/activity';
+import { file } from 'tmp-promise';
+
 const execFile = promisify(execFileCallback);
 
 /**
@@ -22,14 +23,16 @@ export async function imageResizer(
     format: string,
     progressive: boolean = true,
     colorspaceCorrection: boolean = true,
-    colorspace: 'RGB' | 'LAB' | 'LUV' | 'sigmoidal' = 'RGB'
+    colorspace: 'RGB' | 'LAB' | 'LUV' | 'sigmoidal' = 'RGB',
 ): Promise<string> {
-    log.debug(`[image-resizer] Resizing image: ${inputPath} to max_hw: ${max_hw}, format: ${format}, progressive: ${progressive}, colorspaceCorrection: ${colorspaceCorrection ? colorspace : 'disabled'}`);
+    log.debug(
+        `[image-resizer] Resizing image: ${inputPath} to max_hw: ${max_hw}, format: ${format}, progressive: ${progressive}, colorspaceCorrection: ${colorspaceCorrection ? colorspace : 'disabled'}`,
+    );
 
-    const allowedFormats = ["jpg", "jpeg", "png", "webp"];
+    const allowedFormats = ['jpg', 'jpeg', 'png', 'webp'];
 
-    if (!format || format.trim() === "") {
-        throw new Error(`Invalid format: ${format}.Supported : ${allowedFormats.join(", ")}`);
+    if (!format || format.trim() === '') {
+        throw new Error(`Invalid format: ${format}.Supported : ${allowedFormats.join(', ')}`);
     }
 
     //check that max_hw is valid
@@ -55,34 +58,34 @@ export async function imageResizer(
         }
 
         // Progressive loading options
-        let conversionOption = "";
+        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";
+            if (lowerFormat === 'jpg' || lowerFormat === 'jpeg') {
+                conversionOption = '-interlace JPEG';
                 log.debug(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
-            } else if (lowerFormat === "png") {
-                conversionOption = "-interlace PNG";
+            } else if (lowerFormat === 'png') {
+                conversionOption = '-interlace PNG';
                 log.debug(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
-            } else if (lowerFormat === "gif") {
-                conversionOption = "-interlace GIF";
+            } else if (lowerFormat === 'gif') {
+                conversionOption = '-interlace GIF';
                 log.debug(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
             }
         }
 
         log.debug(`Resizing image using ImageMagick: ${inputPath} -> ${outputPath}`);
 
-        const command = `convert`
-        let args = [inputPath];
+        const command = 'convert';
+        const args = ['-define', `jpeg:size=${max_hw * 3}x${max_hw * 3}`];
 
-        // Add JPEG shrink-on-load optimization
-        args.push("-define", `jpeg:size=${max_hw * 3}x${max_hw * 3}`);
+        // Add input after JPEG shrink-on-load optimization so ImageMagick can apply it while decoding.
+        args.push(inputPath);
 
         // Remove metadata
-        args.push("-strip");
+        args.push('-strip');
 
         // https://usage.imagemagick.org/filter/nicolas/#downsample
         // Add colorspace correction if enabled
@@ -91,33 +94,33 @@ export async function imageResizer(
                 case 'RGB':
                     // Linear light, recommended default
                     // Convert from sRGB to linear RGB for processing
-                    args.push("-colorspace", "RGB");
-                    log.debug("Using linear RGB colorspace for resize processing");
+                    args.push('-colorspace', 'RGB');
+                    log.debug('Using linear RGB colorspace for resize processing');
                     break;
                 case 'LAB':
                     // Perceptual linear light
                     // Use LAB colorspace which separates intensity from color
                     // Better for avoiding color clipping and distortion
-                    args.push("-colorspace", "LAB");
-                    log.debug("Using LAB colorspace for resize processing");
+                    args.push('-colorspace', 'LAB');
+                    log.debug('Using LAB colorspace for resize processing');
                     break;
                 case 'LUV':
                     // Perceptual linear light
                     // Alternative to LAB with perceptually uniform color deltas
-                    args.push("-colorspace", "LUV");
-                    log.debug("Using LUV colorspace for resize processing");
+                    args.push('-colorspace', 'LUV');
+                    log.debug('Using LUV colorspace for resize processing');
                     break;
                 case 'sigmoidal':
                     // Sigmoidal colorspace modification to reduce ringing artifacts
-                    args.push("-colorspace", "RGB");
-                    args.push("+sigmoidal-contrast", "6.5,50%");
-                    log.debug("Using sigmoidal contrast modification for resize processing");
+                    args.push('-colorspace', 'RGB');
+                    args.push('+sigmoidal-contrast', '6.5,50%');
+                    log.debug('Using sigmoidal contrast modification for resize processing');
                     break;
             }
         }
 
         // Resize operation
-        args.push("-resize", `${max_hw}x${max_hw}>`);
+        args.push('-resize', `${max_hw}x${max_hw}>`);
 
         // Restore colorspace after processing
         if (colorspaceCorrection) {
@@ -126,25 +129,25 @@ export async function imageResizer(
                 case 'LAB':
                 case 'LUV':
                     // Convert back to sRGB for output
-                    args.push("-colorspace", "sRGB");
+                    args.push('-colorspace', 'sRGB');
                     break;
                 case 'sigmoidal':
                     // Restore from sigmoidal modification and convert to sRGB
-                    args.push("-sigmoidal-contrast", "6.5,50%");
-                    args.push("-colorspace", "sRGB");
+                    args.push('-sigmoidal-contrast', '6.5,50%');
+                    args.push('-colorspace', 'sRGB');
                     break;
             }
         }
 
         // Add progressive/interlace options
         if (conversionOption) {
-            args.push(...conversionOption.split(" "));
+            args.push(...conversionOption.split(' '));
         }
 
         // Output path
         args.push(outputPath);
 
-        log.debug(`ImageMagick command: ${command} ${args.join(" ")}`);
+        log.debug(`ImageMagick command: ${command} ${args.join(' ')}`);
 
         const { stderr } = await execFile(command, args);
 
@@ -165,4 +168,4 @@ export async function imageResizer(
         log.error(`Image conversion failed: ${errorMessage}`);
         throw new Error(`Image conversion failed: ${errorMessage}`);
     }
-}
+}

package/src/conversion/markitdown.ts

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

package/src/conversion/mutool.test.ts

@@ -1,71 +1,86 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { MockActivityEnvironment } from '@temporalio/testing';
-import fs from 'fs';
-import path from 'path';
 import { beforeAll, expect, test } from 'vitest';
 import { mutoolPdfToText, pdfExtractPages, pdfToImages } from './mutool.js';
 
 let activityContext: MockActivityEnvironment;
 
 beforeAll(async () => {
-  activityContext = new MockActivityEnvironment();
+    activityContext = new MockActivityEnvironment();
 });
 
-const TIMEOUT = 10000;
-
-test('[mutool] should convert pdf to text', async () => {
-  const pdf = fs.readFileSync(path.join(__dirname, '../../fixtures', 'test-pdf1.pdf'));
-  const buf = Buffer.from(pdf);
-  console.log("Running mutoolPdfToText")
-  const result = await activityContext.run(mutoolPdfToText, buf);
-  expect(result).toContain('VF primarily uses foreign currency exchange');
- 
-}, TIMEOUT);
-
-test('[mutool] should convert pdf to images', async () => {
-  const filename = path.join(__dirname, '../../fixtures', 'test-pdf1.pdf');
-  
-  console.log("Running pdfToImages")
-  const result = await activityContext.run(pdfToImages, filename);
-  console.log(result);
-
-  expect(result).toBeInstanceOf(Array);
-  expect((result as string[]).length).toBe(119);
-
-}, TIMEOUT); 
-
-test('[mutool] should convert pdf to images with pages', async () => {
-  const filename = path.join(__dirname, '../../fixtures', 'test-pdf1.pdf');
-  const pages = [7, 8, 9];
-  
-  console.log("Running pdfToImages with pages")
-  const result = await activityContext.run(pdfToImages, filename, pages);
-  console.log(result);
-
-  expect(result).toBeInstanceOf(Array);
-  expect((result as string[]).length).toBe(3);
-
-}, TIMEOUT);
-
-test('[mutool] should extract 3 pages from PDF into new PDF', async () => {
-  const filename = path.join(__dirname, '../../fixtures', 'test-pdf1.pdf');
-  const pages = [7, 8, 9];
-  
-  console.log("Running pdfGetPages")
-  const result = await activityContext.run(pdfExtractPages, filename, pages);
-  console.log(result);
-
-  expect(result).toContain(".pdf");
-
-}, TIMEOUT);
-
-test('[mutool] should extract 1 pages from PDF into new PDF', async () => {
-  const filename = path.join(__dirname, '../../fixtures', 'test-pdf1.pdf');
-  const pages = [12];
-  
-  console.log("Running pdfGetPages")
-  const result = await activityContext.run(pdfExtractPages, filename, pages);
-  console.log(result);
-
-  expect(result).toContain(".pdf");
-
-}, TIMEOUT);
+const TIMEOUT = 60000;
+
+test(
+    'should convert pdf to text with mutool',
+    async () => {
+        const pdf = fs.readFileSync(path.join(__dirname, '../../fixtures', 'test-pdf1.pdf'));
+        const buf = Buffer.from(pdf);
+        console.log('Running mutoolPdfToText');
+        const result: string = await activityContext.run(mutoolPdfToText, buf);
+        expect(result).toContain('VF primarily uses foreign currency exchange');
+    },
+    TIMEOUT,
+);
+
+test(
+    'should convert pdf to images with mutool',
+    async () => {
+        const filename = path.join(__dirname, '../../fixtures', 'test-pdf1.pdf');
+
+        console.log('Running pdfToImages');
+        const result: string[] = await activityContext.run(pdfToImages, filename);
+        console.log(result);
+
+        expect(result).toBeInstanceOf(Array);
+        expect(result.length).toBe(119);
+    },
+    TIMEOUT,
+);
+
+test(
+    'should convert pdf to images with pages using mutool',
+    async () => {
+        const filename = path.join(__dirname, '../../fixtures', 'test-pdf1.pdf');
+        const pages = [7, 8, 9];
+
+        console.log('Running pdfToImages with pages');
+        const result: string[] = await activityContext.run(pdfToImages, filename, pages);
+        console.log(result);
+
+        expect(result).toBeInstanceOf(Array);
+        expect(result.length).toBe(3);
+    },
+    TIMEOUT,
+);
+
+test(
+    'should extract 3 pages from PDF into new PDF with mutool',
+    async () => {
+        const filename = path.join(__dirname, '../../fixtures', 'test-pdf1.pdf');
+        const pages = [7, 8, 9];
+
+        console.log('Running pdfGetPages');
+        const result: string = await activityContext.run(pdfExtractPages, filename, pages);
+        console.log(result);
+
+        expect(result).toContain('.pdf');
+    },
+    TIMEOUT,
+);
+
+test(
+    'should extract 1 page from PDF into new PDF with mutool',
+    async () => {
+        const filename = path.join(__dirname, '../../fixtures', 'test-pdf1.pdf');
+        const pages = [12];
+
+        console.log('Running pdfGetPages');
+        const result: string = await activityContext.run(pdfExtractPages, filename, pages);
+        console.log(result);
+
+        expect(result).toContain('.pdf');
+    },
+    TIMEOUT,
+);