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

package/src/conversion/mutool.ts

@@ -1,37 +1,31 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
 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]);
 
-        log.info("Converting pdf to text", { inputFile: inputFile.name, targetFileName });
-
-        const command = spawn("mutool", ["convert", "-o", targetFileName, inputFile.name]);
-
-        command.on('exit', function (code) {
+        command.on('exit', (code) => {
             if (code) {
                 reject(new Error(`mutool exited with code ${code}`));
             }
         });
 
-
-        command.on('close', function (code) {
+        command.on('close', (code) => {
             if (code) {
                 reject(new Error(`mutool exited with code ${code}`));
             } else {
@@ -41,27 +35,24 @@ export function mutoolPdfToText(buffer: Buffer): Promise<string> {
                     }
                     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 file
  * @param pages
- * @returns  
+ * @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 });
 
@@ -70,19 +61,14 @@ export async function pdfToImages(file: Buffer | string, pages?: number[]): Prom
     }
     const filename = typeof file === 'string' ? file : `${workDir.name}/input.pdf`;
 
-    const args = [
-        "draw", 
-        "-o", `${workDir.name}/page-%d.png`,
-        filename,
-    ];
+    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);
+        const command = spawn('mutool', args);
         log.info(`Executing mutool command`, { workDir: workDir.name, filename, command: command.spawnargs });
 
         let errors = '';
@@ -91,40 +77,35 @@ export async function pdfToImages(file: Buffer | string, pages?: number[]): Prom
             errors += data;
         });
 
-        command.on('exit', function (code) {
-
+        command.on('exit', (code) => {
             if (code) {
                 log.error(`mutool exited with code ${code}`, { errors });
                 reject(new Error(`mutool exited with code ${code}`));
             }
         });
 
-        command.on('close', function (code) {
+        command.on('close', (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}`);
+                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 });
 
@@ -134,16 +115,17 @@ export async function pdfExtractPages(file: Buffer | string, pages: number[]): P
     const filename = typeof file === 'string' ? file : `${workDir.name}/input.pdf`;
 
     const args = [
-        "merge",
-        "-o", `${workDir.name}/output.pdf`,
-        "-O", "garbage=compact,sanitize",
+        'merge',
+        '-o',
+        `${workDir.name}/output.pdf`,
+        '-O',
+        'garbage=compact,sanitize',
         filename,
         pages.join(','),
     ];
 
     return new Promise((resolve, reject) => {
-
-        const command = spawn("mutool", args);
+        const command = spawn('mutool', args);
         log.info(`Executing mutool command`, { workDir: workDir.name, filename, command: command.spawnargs });
 
         let errors = '';
@@ -152,29 +134,25 @@ export async function pdfExtractPages(file: Buffer | string, pages: number[]): P
             errors += data;
         });
 
-        command.on('exit', function (code) {
-
+        command.on('exit', (code) => {
             if (code) {
                 log.error(`mutool exited with code ${code}`, { errors });
                 reject(new Error(`mutool exited with code ${code}`));
             }
         });
 
-        command.on('close', function (code) {
+        command.on('close', (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

@@ -1,8 +1,8 @@
+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 { markdownWithPandoc } from '../conversion/pandoc';
+import { markdownWithPandoc } from '../conversion/pandoc.js';
 
 let activityContext: MockActivityEnvironment;
 
@@ -10,12 +10,11 @@ beforeAll(async () => {
     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);
+    console.log('Converting file from', filepath);
     const docx = fs.readFileSync(filepath);
-    const result = await activityContext.run(markdownWithPandoc, Buffer.from(docx), 'docx');
+    const result: string = await activityContext.run(markdownWithPandoc, Buffer.from(docx), 'docx');
     expect(result).to.include('confidential');
 });

package/src/conversion/pandoc.ts

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

package/src/dsl/conditions.ts

@@ -1,13 +1,13 @@
 import equal from 'fast-deep-equal';
 
-function $exists(value: any, arg: boolean) {
+function $exists(value: unknown, arg: boolean) {
     return (value !== undefined) === arg;
 }
-function $null(value: any, arg: boolean) {
+function $null(value: unknown, arg: boolean) {
     return (value == null) === arg;
 }
 
-function $eq(value: any, arg: any) {
+function $eq(value: unknown, arg: unknown) {
     if (Array.isArray(arg)) {
         return equal(value, arg);
     } else if (typeof arg === 'object') {
@@ -16,16 +16,16 @@ function $eq(value: any, arg: any) {
         return value === arg;
     }
 }
-function $ne(value: any, arg: any) {
+function $ne(value: unknown, arg: unknown) {
     return !$eq(value, arg);
 }
-function $or(value: any, arg: any[]) {
-    return arg.some(c => matchCondition(value, c));
+function $or(value: unknown, arg: unknown[]) {
+    return arg.some((c) => matchCondition(value, c));
 }
-function $in(value: any, arg: any[]) {
+function $in(value: unknown, arg: unknown[]) {
     return arg.includes(value);
 }
-function $nin(value: any, arg: any[]) {
+function $nin(value: unknown, arg: unknown[]) {
     return !$in(value, arg);
 }
 function $regexp(value: string, arg: string) {
@@ -53,16 +53,34 @@ 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,
+type ConditionFn = (value: unknown, arg: unknown) => boolean;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 
-export function matchCondition(value: any, conditions: Record<string, any>) {
+const conditionFns: Record<string, ConditionFn> = {
+    $exists: (value, arg) => typeof arg === 'boolean' && $exists(value, arg),
+    $null: (value, arg) => typeof arg === 'boolean' && $null(value, arg),
+    $eq,
+    $ne,
+    $in: (value, arg) => Array.isArray(arg) && $in(value, arg),
+    $nin: (value, arg) => Array.isArray(arg) && $nin(value, arg),
+    $regexp: (value, arg) => typeof value === 'string' && typeof arg === 'string' && $regexp(value, arg),
+    $startsWith: (value, arg) => typeof value === 'string' && typeof arg === 'string' && $startsWith(value, arg),
+    $endsWith: (value, arg) => typeof value === 'string' && typeof arg === 'string' && $endsWith(value, arg),
+    $contains: (value, arg) => typeof value === 'string' && typeof arg === 'string' && $contains(value, arg),
+    $lt: (value, arg) => typeof value === 'number' && typeof arg === 'number' && $lt(value, arg),
+    $gt: (value, arg) => typeof value === 'number' && typeof arg === 'number' && $gt(value, arg),
+    $lte: (value, arg) => typeof value === 'number' && typeof arg === 'number' && $lte(value, arg),
+    $gte: (value, arg) => typeof value === 'number' && typeof arg === 'number' && $gte(value, arg),
+    $or: (value, arg) => Array.isArray(arg) && $or(value, arg),
+};
+
+export function matchCondition(value: unknown, conditions: unknown) {
+    if (!isRecord(conditions)) {
+        return $eq(value, conditions);
+    }
     for (const key of Object.keys(conditions)) {
         const cond = conditionFns[key];
         if (!cond) {
@@ -73,4 +91,4 @@ export function matchCondition(value: any, conditions: Record<string, any>) {
         }
     }
     return true;
-}
+}

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

@@ -1,9 +1,25 @@
-import { describe, test, expect } from "vitest";
-import { computeActivityOptions } from "./dsl-workflow.ts";
+import { describe, expect, test } from 'vitest';
+import { computeActivityOptions } from './dsl-workflow.js';
 
 describe('Workflow DSL', () => {
-    test('compute activity options without custom options', () => {
-        expect(computeActivityOptions({}, {
+    test('should 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,
@@ -12,37 +28,31 @@ describe('Workflow DSL', () => {
                 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']
-            }
-        })
-    })
+                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({
+    test('should 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,
@@ -51,8 +61,8 @@ describe('Workflow DSL', () => {
                 maximumInterval: 5000,
                 maximumAttempts: 6,
                 backoffCoefficient: 7,
-                nonRetryableErrorTypes: ['error']
-            }
-        })
-    })
-});
+                nonRetryableErrorTypes: ['error'],
+            },
+        });
+    });
+});