@vertesia/workflow 0.24.0-dev.202601221707

package/src/conversion/image.ts

@@ -0,0 +1,168 @@
+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 using ImageMagick
+ * with progressive loading when supported and colorspace correction
+ * @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)
+ * @param colorspaceCorrection Enable colorspace correction (defaults to true), not recommended for Q8 image magick.
+ * @param colorspace Colorspace to use for processing ('RGB', 'LAB', 'LUV', 'sigmoidal') (defaults to 'RGB')
+ * @returns Path to the resized image
+ */
+export async function imageResizer(
+    inputPath: string,
+    max_hw: number,
+    format: string,
+    progressive: boolean = true,
+    colorspaceCorrection: boolean = true,
+    colorspace: 'RGB' | 'LAB' | 'LUV' | 'sigmoidal' = 'RGB'
+): Promise<string> {
+    log.info(`[image-resizer] Resizing image: ${inputPath} to max_hw: ${max_hw}, format: ${format}, progressive: ${progressive}, colorspaceCorrection: ${colorspaceCorrection ? colorspace : 'disabled'}`);
+
+    const allowedFormats = ["jpg", "jpeg", "png", "webp"];
+
+    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`
+        let args = [inputPath];
+
+        // Add JPEG shrink-on-load optimization
+        args.push("-define", `jpeg:size=${max_hw * 3}x${max_hw * 3}`);
+
+        // Remove metadata
+        args.push("-strip");
+
+        // https://usage.imagemagick.org/filter/nicolas/#downsample
+        // Add colorspace correction if enabled
+        if (colorspaceCorrection) {
+            switch (colorspace) {
+                case 'RGB':
+                    // Linear light, recommended default
+                    // Convert from sRGB to linear RGB for processing
+                    args.push("-colorspace", "RGB");
+                    log.info("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.info("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.info("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.info("Using sigmoidal contrast modification for resize processing");
+                    break;
+            }
+        }
+
+        // Resize operation
+        args.push("-resize", `${max_hw}x${max_hw}>`);
+
+        // Restore colorspace after processing
+        if (colorspaceCorrection) {
+            switch (colorspace) {
+                case 'RGB':
+                case 'LAB':
+                case 'LUV':
+                    // Convert back to sRGB for output
+                    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");
+                    break;
+            }
+        }
+
+        // Add progressive/interlace options
+        if (conversionOption) {
+            args.push(...conversionOption.split(" "));
+        }
+
+        // Output path
+        args.push(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.test.ts

@@ -0,0 +1,74 @@
+import { MockActivityEnvironment, TestWorkflowEnvironment } 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 testEnv: TestWorkflowEnvironment;
+let activityContext: MockActivityEnvironment;
+
+beforeAll(async () => {
+  testEnv = await TestWorkflowEnvironment.createLocal();
+  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);

package/src/conversion/mutool.ts

@@ -0,0 +1,180 @@
+import { log } from '@temporalio/activity';
+import { spawn } from 'child_process';
+import fs from 'fs';
+import tmp from 'tmp';
+
+
+
+/**
+ * Convert a pdf file to text
+ * TODO: pass file reference instead of Buffer
+ */
+
+export function mutoolPdfToText(buffer: Buffer): Promise<string> {
+
+    const inputFile = tmp.fileSync({ postfix: '.pdf' });
+    const targetFileName = tmp.tmpNameSync({ postfix: '.txt' });
+
+    fs.writeSync(inputFile.fd, buffer);
+
+    return new Promise((resolve, reject) => {
+
+
+        log.info("Converting pdf to text", { inputFile: inputFile.name, targetFileName });
+
+        const command = spawn("mutool", ["convert", "-o", targetFileName, inputFile.name]);
+
+        command.on('exit', function (code) {
+            if (code) {
+                reject(new Error(`mutool exited with code ${code}`));
+            }
+        });
+
+
+        command.on('close', function (code) {
+            if (code) {
+                reject(new Error(`mutool 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);
+        });
+
+    });
+
+}
+
+/**
+ * 
+ * Convert a pdf files to images (one image per page), as PNG format
+ * 
+ * @param file 
+ * @param pages
+ * @returns  
+ */
+export async function pdfToImages(file: Buffer | string, pages?: number[]): Promise<string[]> {
+
+    const workDir = tmp.dirSync();
+    log.info(`Converting pdf to images`, { workDir: workDir.name, input_type: typeof file, pages });
+
+    if (file instanceof Buffer) {
+        fs.writeFileSync(`${workDir.name}/input.pdf`, file);
+    }
+    const filename = typeof file === 'string' ? file : `${workDir.name}/input.pdf`;
+
+    const args = [
+        "draw", 
+        "-o", `${workDir.name}/page-%d.png`,
+        filename,
+    ];
+
+    if (pages) {
+        args.push(pages.join(','));
+    }
+
+    return new Promise((resolve, reject) => {
+
+        const command = spawn("mutool", args);
+        log.info(`Executing mutool command`, { workDir: workDir.name, filename, command: command.spawnargs });
+
+        let errors = '';
+
+        command.stderr.on('data', (data) => {
+            errors += data;
+        });
+
+        command.on('exit', function (code) {
+
+            if (code) {
+                log.error(`mutool exited with code ${code}`, { errors });
+                reject(new Error(`mutool exited with code ${code}`));
+            }
+        });
+
+        command.on('close', function (code) {
+            if (code) {
+                reject(new Error(`mutool finished with code ${code}`));
+            } else {
+                const files = fs.readdirSync(workDir.name);
+                const images = files.filter(f => f.endsWith('.png')).map(f => `${workDir.name}/${f}`);
+                log.info(`Converted pdf to ${images.length} images`, files);
+                return resolve(images);
+            };
+        });
+
+        command.on('error', (err) => {
+            reject(err);
+        });
+
+    });
+
+}
+
+
+/**
+ * Get some pages from a PDF to create a new one
+ */
+
+export async function pdfExtractPages(file: Buffer | string, pages: number[]): Promise<string> {
+
+    const workDir = tmp.dirSync();
+    log.info(`Getting pages from pdf`, { workDir: workDir.name, input_type: typeof file, pages });
+
+    if (file instanceof Buffer) {
+        fs.writeFileSync(`${workDir.name}/input.pdf`, file);
+    }
+    const filename = typeof file === 'string' ? file : `${workDir.name}/input.pdf`;
+
+    const args = [
+        "merge",
+        "-o", `${workDir.name}/output.pdf`,
+        "-O", "garbage=compact,sanitize",
+        filename,
+        pages.join(','),
+    ];
+
+    return new Promise((resolve, reject) => {
+
+        const command = spawn("mutool", args);
+        log.info(`Executing mutool command`, { workDir: workDir.name, filename, command: command.spawnargs });
+
+        let errors = '';
+
+        command.stderr.on('data', (data) => {
+            errors += data;
+        });
+
+        command.on('exit', function (code) {
+
+            if (code) {
+                log.error(`mutool exited with code ${code}`, { errors });
+                reject(new Error(`mutool exited with code ${code}`));
+            }
+        });
+
+        command.on('close', function (code) {
+            if (code) {
+                reject(new Error(`mutool finished with code ${code}`));
+            } else {
+                const file = `${workDir.name}/output.pdf`;
+                log.info(`Extracted pages from pdf`, { pages, file });
+                return resolve(file);
+            };
+        });
+
+        command.on('error', (err) => {
+            reject(err);
+        });
+
+    });
+
+
+}

package/src/conversion/pandoc.test.ts

@@ -0,0 +1,24 @@
+import { MockActivityEnvironment, TestWorkflowEnvironment } from '@temporalio/testing';
+import fs from 'fs';
+import path from 'path';
+import { beforeAll, expect, test } from 'vitest';
+import { markdownWithPandoc } from '../conversion/pandoc';
+
+
+let testEnv: TestWorkflowEnvironment;
+let activityContext: MockActivityEnvironment;
+
+beforeAll(async () => {
+    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 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

@@ -0,0 +1,40 @@
+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);
+        });
+    });
+}

package/src/dsl/conditions.ts

@@ -0,0 +1,76 @@
+import equal from 'fast-deep-equal';
+
+function $exists(value: any, arg: boolean) {
+    return (value !== undefined) === arg;
+}
+function $null(value: any, arg: boolean) {
+    return (value == null) === arg;
+}
+
+function $eq(value: any, arg: any) {
+    if (Array.isArray(arg)) {
+        return equal(value, arg);
+    } else if (typeof arg === 'object') {
+        return equal(value, arg);
+    } else {
+        return value === arg;
+    }
+}
+function $ne(value: any, arg: any) {
+    return !$eq(value, arg);
+}
+function $or(value: any, arg: any[]) {
+    return arg.some(c => matchCondition(value, c));
+}
+function $in(value: any, arg: any[]) {
+    return arg.includes(value);
+}
+function $nin(value: any, arg: any[]) {
+    return !$in(value, arg);
+}
+function $regexp(value: string, arg: string) {
+    return new RegExp(arg).test(value);
+}
+function $endsWith(value: string, arg: string) {
+    return value.endsWith(arg);
+}
+function $startsWith(value: string, arg: string) {
+    return value.startsWith(arg);
+}
+function $contains(value: string, arg: string) {
+    return value.includes(arg);
+}
+function $lt(value: number, arg: number) {
+    return value < arg;
+}
+function $gt(value: number, arg: number) {
+    return value > arg;
+}
+function $lte(value: number, arg: number) {
+    return value <= arg;
+}
+function $gte(value: number, arg: number) {
+    return value >= arg;
+}
+
+const conditionFns: Record<string, any> = {
+    $exists, $null,
+    $eq, $ne,
+    $in, $nin,
+    $regexp, $startsWith, $endsWith, $contains,
+    $lt, $gt, $lte, $gte,
+    $or,
+}
+
+export function matchCondition(value: any, conditions: Record<string, any>) {
+    for (const key of Object.keys(conditions)) {
+        const cond = conditionFns[key];
+        if (!cond) {
+            throw new Error(`Unknown condition: ${key}`);
+        }
+        if (!cond(value, conditions[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/src/dsl/dsl-workflow.test.ts

@@ -0,0 +1,58 @@
+import { describe, test, expect } from "vitest";
+import { computeActivityOptions } from "./dsl-workflow.ts";
+
+describe('Workflow DSL', () => {
+    test('compute activity options without custom options', () => {
+        expect(computeActivityOptions({}, {
+            startToCloseTimeout: 1000,
+            scheduleToCloseTimeout: 2000,
+            scheduleToStartTimeout: 3000,
+            retry: {
+                initialInterval: 4000,
+                maximumInterval: 5000,
+                maximumAttempts: 6,
+                backoffCoefficient: 7,
+                nonRetryableErrorTypes: ['error']
+            }
+        })).toEqual({
+            startToCloseTimeout: 1000,
+            scheduleToCloseTimeout: 2000,
+            scheduleToStartTimeout: 3000,
+            retry: {
+                initialInterval: 4000,
+                maximumInterval: 5000,
+                maximumAttempts: 6,
+                backoffCoefficient: 7,
+                nonRetryableErrorTypes: ['error']
+            }
+        })
+    })
+
+    test('compute activity options with some custom options', () => {
+        expect(computeActivityOptions({
+            startToCloseTimeout: 100,
+        }, {
+            startToCloseTimeout: 1000,
+            scheduleToCloseTimeout: 2000,
+            scheduleToStartTimeout: 3000,
+            retry: {
+                initialInterval: 4000,
+                maximumInterval: 5000,
+                maximumAttempts: 6,
+                backoffCoefficient: 7,
+                nonRetryableErrorTypes: ['error']
+            }
+        })).toEqual({
+            startToCloseTimeout: `100ms`, // custom value
+            scheduleToCloseTimeout: 2000,
+            scheduleToStartTimeout: 3000,
+            retry: {
+                initialInterval: 4000,
+                maximumInterval: 5000,
+                maximumAttempts: 6,
+                backoffCoefficient: 7,
+                nonRetryableErrorTypes: ['error']
+            }
+        })
+    })
+});