@accordproject/template-engine 3.0.1 → 3.1.0

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { ModelManager, ClassDeclaration } from '@accordproject/concerto-core';
 import { Template } from '@accordproject/cicero-core';
+import { TwoSlashReturn } from '@typescript/twoslash';
 
 /*
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -133,6 +134,7 @@ type InitResponse = {
  */
 declare class TemplateArchiveProcessor {
     template: Template;
+    private compiledLogicCache?;
     /**
      * Creates a template archive processor
      * @param {Template} template - the template to be used by the processor
@@ -148,21 +150,31 @@ declare class TemplateArchiveProcessor {
      */
     draft(data: any, format: string, options: any, currentTime?: string): Promise<any>;
     /**
-     * Trigger the logic of a template
+     * Compile the logic of a template
+     * @param {boolean} [enableCompiledLogicCache] - whether to cache the compiled logic for future use
+     * @returns {Promise<Record<string, TwoSlashReturn>>} the compiled code for each typescript file
+     */
+    compileLogic(enableCompiledLogicCache?: boolean): Promise<Record<string, TwoSlashReturn>>;
+    /**
+     * Trigger the logic of a template.
+     * @param {object} data - the data for the template
      * @param {object} request - the request to send to the template logic
      * @param {object} state - the current state of the template
      * @param {[string]} currentTime - the current time, defaults to now
      * @param {[number]} utcOffset - the UTC offset, defaults to zero
-     * @returns {Promise} the response and any events
+     * @param {boolean} [enableCompiledLogicCache] - whether to use the compiled logic cache
+     * @returns {Promise<TriggerResponse>} the response and any events
      */
-    trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number): Promise<TriggerResponse>;
+    trigger(data: any, request: any, state?: any, currentTime?: string, utcOffset?: number, enableCompiledLogicCache?: boolean): Promise<TriggerResponse>;
     /**
-     * Init the logic of a template
+     * Init the logic of a template.
+     * @param {object} data - the data for the template
      * @param {[string]} currentTime - the current time, defaults to now
      * @param {[number]} utcOffset - the UTC offset, defaults to zero
+     * @param {boolean} [enableCompiledLogicCache] - whether to use the compiled logic cache
      * @returns {Promise<InitResponse>} the new state
      */
-    init(data: any, currentTime?: string, utcOffset?: number): Promise<InitResponse>;
+    init(data: any, currentTime?: string, utcOffset?: number, enableCompiledLogicCache?: boolean): Promise<InitResponse>;
 }
 
 declare function ensureDirSync(path: string): void;

package/dist/index.js

@@ -529,17 +529,31 @@ class JavaScriptEvaluator {
             const end = (/* @__PURE__ */ new Date()).getTime();
             resolve({ result, elapsed: end - start });
           }).catch((err) => {
-            console.log(err);
-            reject({
-              message: err.message
-            });
+            console.error(err);
+            if (err instanceof Error) {
+              reject({
+                message: err.message,
+                stack: err.stack
+              });
+            } else {
+              reject({
+                message: String(err)
+              });
+            }
           });
         }
       } catch (err) {
-        console.log(err);
-        reject({
-          message: err.message
-        });
+        console.error(err);
+        if (err instanceof Error) {
+          reject({
+            message: err.message,
+            stack: err.stack
+          });
+        } else {
+          reject({
+            message: String(err)
+          });
+        }
       }
     });
   }
@@ -561,6 +575,7 @@ class JavaScriptEvaluator {
       };
       if (this.queue.length >= this.options.maxQueueDepth) {
         reject({ maxQueueDepthExceeded: true, elapsed: 0 });
+        return;
       }
       this.queue.push(workItem);
       this.processQueue(options);
@@ -601,7 +616,7 @@ class JavaScriptEvaluator {
       }
       const workerPath = this.getWorkerPath();
       const worker = child_process.fork(workerPath, { timeout: options.timeout, env: {} });
-      if (!worker.pid) {
+      if (worker.pid === void 0 || worker.pid === null) {
         throw new Error("Failed to fork child process");
       }
       this.workers.push(worker);
@@ -610,7 +625,18 @@ class JavaScriptEvaluator {
       worker.on("error", (err) => {
         this.workers = this.workers.filter((w) => w.pid !== worker.pid);
         const end = (/* @__PURE__ */ new Date()).getTime();
-        reject({ message: err.message, elapsed: end - start });
+        if (err instanceof Error) {
+          reject({
+            message: err.message,
+            stack: err.stack,
+            elapsed: end - start
+          });
+        } else {
+          reject({
+            message: String(err),
+            elapsed: end - start
+          });
+        }
       });
       worker.on("message", (msg) => {
         result = msg;
@@ -793,13 +819,17 @@ async function generateRecursiveBlocks(modelManager, clauseLibrary, templateMark
           if (!Array.isArray(arrayData)) {
             throw new Error(`Values found for path '${path}' in data ${data} is not an array: ${arrayData}.`);
           } else {
+            const firstChild = context.nodes[0];
+            const hasListWrapper = firstChild && firstChild.$class === `${markdownCommon.CommonMarkModel.NAMESPACE}.List` && Array.isArray(firstChild.nodes) && firstChild.nodes.length > 0;
+            const itemTemplate = hasListWrapper ? firstChild.nodes[0] : firstChild;
             const nodes = [];
             for (let n2 = 0; n2 < arrayData.length; n2++) {
               const arrayItem = arrayData[n2];
-              const subResult = await generateAgreement(modelManager, clauseLibrary, context.nodes[0].nodes[0], arrayItem, options);
+              const subResult = await generateAgreement(modelManager, clauseLibrary, itemTemplate, arrayItem, options);
+              const childNodes = hasListWrapper ? subResult.nodes ? subResult.nodes : [] : [subResult];
               nodes.push({
                 $class: childNodeClass,
-                nodes: subResult.nodes ? subResult.nodes : []
+                nodes: childNodes
               });
             }
             result[thisPath.join("/")] = nodes;
@@ -1143,14 +1173,14 @@ class TemplateArchiveProcessor {
     return result;
   }
   /**
-   * Trigger the logic of a template
-   * @param {object} request - the request to send to the template logic
-   * @param {object} state - the current state of the template
-   * @param {[string]} currentTime - the current time, defaults to now
-   * @param {[number]} utcOffset - the UTC offset, defaults to zero
-   * @returns {Promise} the response and any events
+   * Compile the logic of a template
+   * @param {boolean} [enableCompiledLogicCache] - whether to cache the compiled logic for future use
+   * @returns {Promise<Record<string, TwoSlashReturn>>} the compiled code for each typescript file
    */
-  async trigger(data, request, state, currentTime, utcOffset) {
+  async compileLogic(enableCompiledLogicCache = false) {
+    if (enableCompiledLogicCache && this.compiledLogicCache) {
+      return this.compiledLogicCache;
+    }
     const logicManager = this.template.getLogicManager();
     if (logicManager.getLanguage() === "typescript") {
       const compiledCode = {};
@@ -1167,69 +1197,70 @@ class TemplateArchiveProcessor {
         const result = compiler.compile(code);
         compiledCode[tsFile.getIdentifier()] = result;
       }
-      const resolvedTime = currentTime ?? (/* @__PURE__ */ new Date()).toISOString();
-      const resolvedOffset = utcOffset ?? 0;
-      const evaluator = new JavaScriptEvaluator();
-      const evalResponse = await evaluator.evalDangerously({
-        templateLogic: true,
-        verbose: false,
-        functionName: "trigger",
-        code: compiledCode["logic/logic.ts"].code,
-        // TODO DCS - how to find the code to run?
-        argumentNames: ["data", "request", "state"],
-        arguments: [data, request, state, resolvedTime, resolvedOffset]
-      });
-      if (evalResponse.result) {
-        return evalResponse.result;
-      } else {
-        throw new Error("Trigger failed with message: " + evalResponse.message);
+      if (enableCompiledLogicCache) {
+        this.compiledLogicCache = compiledCode;
       }
+      return compiledCode;
     } else {
       throw new Error("Only TypeScript is supported at this time");
     }
   }
   /**
-   * Init the logic of a template
+   * Trigger the logic of a template.
+   * @param {object} data - the data for the template
+   * @param {object} request - the request to send to the template logic
+   * @param {object} state - the current state of the template
+   * @param {[string]} currentTime - the current time, defaults to now
+   * @param {[number]} utcOffset - the UTC offset, defaults to zero
+   * @param {boolean} [enableCompiledLogicCache] - whether to use the compiled logic cache
+   * @returns {Promise<TriggerResponse>} the response and any events
+   */
+  async trigger(data, request, state, currentTime, utcOffset, enableCompiledLogicCache) {
+    const compiledCode = await this.compileLogic(enableCompiledLogicCache);
+    const resolvedTime = currentTime ?? (/* @__PURE__ */ new Date()).toISOString();
+    const resolvedOffset = utcOffset ?? 0;
+    const evaluator = new JavaScriptEvaluator();
+    const evalResponse = await evaluator.evalDangerously({
+      templateLogic: true,
+      verbose: false,
+      functionName: "trigger",
+      code: compiledCode["logic/logic.ts"].code,
+      // TODO DCS - how to find the code to run?
+      argumentNames: ["data", "request", "state"],
+      arguments: [data, request, state, resolvedTime, resolvedOffset]
+    });
+    if (evalResponse.result) {
+      return evalResponse.result;
+    } else {
+      throw new Error("Trigger failed with message: " + evalResponse.message);
+    }
+  }
+  /**
+   * Init the logic of a template.
+   * @param {object} data - the data for the template
    * @param {[string]} currentTime - the current time, defaults to now
    * @param {[number]} utcOffset - the UTC offset, defaults to zero
+   * @param {boolean} [enableCompiledLogicCache] - whether to use the compiled logic cache
    * @returns {Promise<InitResponse>} the new state
    */
-  async init(data, currentTime, utcOffset) {
-    const logicManager = this.template.getLogicManager();
-    if (logicManager.getLanguage() === "typescript") {
-      const compiledCode = {};
-      const tsFiles = logicManager.getScriptManager().getScriptsForTarget("typescript");
-      for (let n = 0; n < tsFiles.length; n++) {
-        const tsFile = tsFiles[n];
-        const compiler = new TypeScriptToJavaScriptCompiler(
-          this.template.getModelManager(),
-          this.template.getTemplateModel().getFullyQualifiedName()
-        );
-        await compiler.initialize();
-        const code = `${Buffer.from(SMART_LEGAL_CONTRACT_BASE64, "base64").toString()}
-                ${tsFile.getContents()}`;
-        const result = compiler.compile(code);
-        compiledCode[tsFile.getIdentifier()] = result;
-      }
-      const resolvedTime = currentTime ?? (/* @__PURE__ */ new Date()).toISOString();
-      const resolvedOffset = utcOffset ?? 0;
-      const evaluator = new JavaScriptEvaluator();
-      const evalResponse = await evaluator.evalDangerously({
-        templateLogic: true,
-        verbose: false,
-        functionName: "init",
-        code: compiledCode["logic/logic.ts"].code,
-        // TODO DCS - how to find the code to run?
-        argumentNames: ["data"],
-        arguments: [data, resolvedTime, resolvedOffset]
-      });
-      if (evalResponse.result) {
-        return evalResponse.result;
-      } else {
-        throw new Error("Init failed with message: " + evalResponse.message);
-      }
+  async init(data, currentTime, utcOffset, enableCompiledLogicCache) {
+    const compiledCode = await this.compileLogic(enableCompiledLogicCache);
+    const resolvedTime = currentTime ?? (/* @__PURE__ */ new Date()).toISOString();
+    const resolvedOffset = utcOffset ?? 0;
+    const evaluator = new JavaScriptEvaluator();
+    const evalResponse = await evaluator.evalDangerously({
+      templateLogic: true,
+      verbose: false,
+      functionName: "init",
+      code: compiledCode["logic/logic.ts"].code,
+      // TODO DCS - how to find the code to run?
+      argumentNames: ["data"],
+      arguments: [data, resolvedTime, resolvedOffset]
+    });
+    if (evalResponse.result) {
+      return evalResponse.result;
     } else {
-      throw new Error("Only TypeScript is supported at this time");
+      throw new Error("Init failed with message: " + evalResponse.message);
     }
   }
 }