Error handeling

(async requests, prevent server from crashing on user-error)

shared-operations/src/functions/impose.ts

@@ -21,7 +21,7 @@ export class Impose extends Operator {
 
     /** PDF-Imposition, PDF-N-Up: Put multiple pages of the input document into a single page of the output document. - see: {@link https://en.wikipedia.org/wiki/N-up}  */
     async run(input: PdfFile[], progressCallback: (state: Progress) => void): Promise<PdfFile[]> {
-        return this.nToN<PdfFile, PdfFile>(input, async (input, index, max) => {
+        return this.oneToOne<PdfFile, PdfFile>(input, async (input, index, max) => {
             // https://pdfcpu.io/generate/nup.html
             const uint8Array = await pdfcpuWrapper.oneToOne(
                 [
@@ -47,7 +47,7 @@ export class Impose extends Operator {
             progressCallback({ curFileProgress: 1, operationProgress: index/max })
             
             console.log("ImposeResult: ", result);
-            return [result];
+            return result;
         })
     }
 

shared-operations/src/functions/index.ts

@@ -4,10 +4,15 @@ export enum IOType {
     PDF, Image, Text // TODO: Extend with Document File Types
 }
 
+export interface ValidationResult { 
+    valid: boolean, 
+    reason?: string 
+}
+
 export interface Progress {
-    /** 0-1 */
+    /** A percentage between 0-1 describing the progress on the currently processed file */
     curFileProgress: number,
-    /** 0-1 */
+    /** A percentage between 0-1 describing the progress on all input files / operations */
     operationProgress: number,
 }
 
@@ -25,27 +30,24 @@ export class Operator {
         this.actionValues = action.values;
     }
 
-    // TODO: Type callback state, it should give updates on the progress of the current operator
     async run(input: any[], progressCallback: (progress: Progress) => void): Promise<any[]> {
         return [];
     }
 
-    validate(): { valid: boolean, reason?: string } {
+    validate(): ValidationResult {
         if(!this.actionValues) {
             return { valid: false, reason: "The Operators action values were empty."}
         }
         return { valid: true };
     }
 
+    /** This function should be used if the Operation may take multiple files as inputs and only outputs one file */
     protected async nToOne <I, O>(inputs: I[], callback: (input: I[]) => Promise<O>): Promise<O[]> {
         return [await callback(inputs)];
     }
 
+    /** This function should be used if the Operation takes one file as input and may output multiple files */
     protected async oneToN <I, O>(inputs: I[], callback: (input: I, index: number, max: number) => Promise<O[]>): Promise<O[]> {
-        return this.nToN(inputs, callback); // nToN is able to handle single inputs now.
-    }
-
-    protected async nToN <I, O>(inputs: I[], callback: (input: I, index: number, max: number) => Promise<O[]>): Promise<O[]> {
         let output: O[] = []
         for (let i = 0; i < inputs.length; i++) {
             output = output.concat(await callback(inputs[i], i, inputs.length));
@@ -53,4 +55,11 @@ export class Operator {
 
         return output;
     }
+
+    /** This function should be used if the Operation takes one file as input and outputs only one file */
+    protected async oneToOne <I, O>(inputs: I[], callback: (input: I, index: number, max: number) => Promise<O>): Promise<O[]> {
+        return this.oneToN(inputs, async (input, index, max) => {
+            return [await callback(input, index, max)]
+        });
+    }
 }

shared-operations/src/workflow/getOperatorByName.ts

@@ -1,6 +1,6 @@
 import { Operator } from "../functions";
 
-// TODO: Import other Operators
+// TODO: Import other Operators (could make this dynamic?)
 import { Impose } from "../functions/impose";
 export const Operators = {
     Impose: Impose
@@ -23,4 +23,9 @@ export function getOperatorByName(name: string): typeof Operator {
     });
     
     return foundClass;
+}
+
+export function listOperatorNames(): string[] {
+    // TODO: Implement this
+    return
 }

shared-operations/src/workflow/traverseOperations.ts

@@ -42,78 +42,13 @@ export async function traverseOperations(operations: Action[], input: PdfFile[],
             case "wait":
                 const waitOperation = waitOperations[(action as WaitAction).values.id];
 
-                if(Array.isArray(input)) {
-                    waitOperation.input.concat(input); // TODO: May have unexpected concequences. Needs further testing!
-                }
-                else {
-                    waitOperation.input.push(input);
-                }
+                waitOperation.input.concat(input); // TODO: May have unexpected concequences. Needs further testing!
 
                 waitOperation.waitCount--;
                 if(waitOperation.waitCount == 0 && waitOperation.doneOperation.actions) {
                     await nextOperation(waitOperation.doneOperation.actions, waitOperation.input, progressCallback);
                 }
                 break;
-            /*case "extract":
-                yield* nToN(input, action, async (input) => {
-                    const newPdf = await Operations.extractPages({file: input, pageIndexes: action.values["pageIndexes"]});
-                    return newPdf;
-                });
-                break;
-            case "impose":
-                let impose = new Impose(action);
-                input = await impose.run(input, progressCallback);
-                await nextOperation(action.actions, input, progressCallback);
-                break;
-            case "merge":
-                yield* nToOne(input, action, async (inputs) => {
-                    const newPdf = await Operations.mergePDFs({files: inputs});
-                    return newPdf;
-                });
-                break;
-            case "removeBlankPages":
-                yield* nToN(input, action, async (input) => {
-                    const newPdf = await Operations.removeBlankPages({file: input, whiteThreashold: action.values["whiteThreashold"]});
-                    return newPdf;
-                });
-                break;
-            case "rotate":
-                yield* nToN(input, action, async (input) => {
-                    const newPdf = await Operations.rotatePages({file: input, rotation: action.values["rotation"]});
-                    return newPdf;
-                });
-                break;
-            case "sortPagesWithPreset":
-                yield* nToN(input, action, async (input) => {
-                    const newPdf = await Operations.arrangePages({file: input, arrangementConfig: action.values["arrangementConfig"]});
-                    return newPdf;
-                });
-                break;
-            case "split":
-                // TODO: A split might break the done condition, it may count multiple times. Needs further testing!
-                yield* oneToN(input, action, async (input) => {
-                    const splitResult = await Operations.splitPdfByIndex({file: input, pageIndexes: action.values["splitAfterPageArray"]});
-                    for (let j = 0; j < splitResult.length; j++) {
-                        splitResult[j].filename = splitResult[j].filename + "_split" + j;
-                    }
-                    return splitResult;
-                });
-                break;
-            case "splitOn":
-                yield* oneToN(input, action, async (input) => {
-                    const splitResult = await Operations.splitPagesByPreset({file: input, type: action.values["type"], whiteThreashold: action.values["whiteThreashold"]});
-                    for (let j = 0; j < splitResult.length; j++) {
-                        splitResult[j].filename = splitResult[j].filename + "_split" + j;
-                    }
-                    return splitResult;
-                });
-                break;
-            case "updateMetadata":
-                yield* nToN(input, action, async (input) => {
-                    const newPdf = await Operations.updateMetadata({file: input, ...action.values["metadata"]});
-                    return newPdf;
-                });
-                break;*/
             default:
                 const operator = getOperatorByName(action.type);
                 if(operator) {