@accordproject/template-engine 2.9.0 → 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 offer, defaults to zero
-     * @returns {Promise} the response and any events
+     * @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
      */
-    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 offer, defaults to zero
-     * @returns {Promise} the response and any events
+     * @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;
@@ -714,7 +740,7 @@ function getJsonPath(rootData, currentNode, paths) {
       }
     }
   }
-  if (currentNode.name !== "this") {
+  if (currentNode.name !== "this" && currentNode.name !== "top") {
     withPath.push(`['${currentNode.name}']`);
   }
   return withPath.length > 0 ? `$${withPath.join("")}` : "$";
@@ -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;
@@ -904,8 +934,17 @@ async function generateAgreement(modelManager, clauseLibrary, templateMark, data
         }
       } else if (CONDITIONAL_DEFINITION_RE.test(nodeClass)) {
         if (context.condition) {
-          const result = userCodeResults[this.path.join("/")];
-          context.isTrue = !!result;
+          const key = this.path.join("/");
+          const resultStr = userCodeResults[key];
+          if (resultStr === void 0 || resultStr === null) {
+            context.isTrue = false;
+          } else {
+            try {
+              context.isTrue = !!JSON.parse(resultStr);
+            } catch (err) {
+              throw new Error(`Invalid JSON boolean result for condition '${key}': ${String(err)}`);
+            }
+          }
         } else {
           const path = getJsonPath(templateMark, context, this.path);
           const variableValues = jp.query(data, path, 1);
@@ -926,16 +965,27 @@ async function generateAgreement(modelManager, clauseLibrary, templateMark, data
       } else if (CLAUSE_DEFINITION_RE.test(nodeClass)) {
         const path = getJsonPath(templateMark, context, this.path);
         const variableValues = jp.query(data, path, 1);
-        if (context.name !== "top" && (variableValues.length === 0 || variableValues[0] === void 0 || variableValues[0] === null)) {
-          delete context.nodes;
-          stopHere = true;
-        } else if (context.condition) {
+        if (context.condition) {
           checkCode(context.condition);
-          const result = !!userCodeResults[this.path.join("/")];
+          const key = this.path.join("/");
+          const resultStr = userCodeResults[key];
+          let result = false;
+          if (resultStr === void 0 || resultStr === null) {
+            result = false;
+          } else {
+            try {
+              result = !!JSON.parse(resultStr);
+            } catch (err) {
+              throw new Error(`Invalid JSON boolean result for condition '${key}': ${String(err)}`);
+            }
+          }
           if (!result) {
             delete context.nodes;
             stopHere = true;
           }
+        } else if (context.name !== "top" && (variableValues.length === 0 || variableValues[0] === void 0 || variableValues[0] === null)) {
+          delete context.nodes;
+          stopHere = true;
         }
         delete context.condition;
         delete context.functionName;
@@ -984,14 +1034,14 @@ class TemplateMarkInterpreter {
    * @throws {Error} if the templateMark document is invalid
    */
   checkTypes(templateMark) {
-    const modelManager = new concertoCore.ModelManager({ strict: true });
+    const modelManager = new concertoCore.ModelManager();
     modelManager.addCTOModel(markdownCommon.ConcertoMetaModel.MODEL, "concertometamodel.cto");
     modelManager.addCTOModel(markdownCommon.CommonMarkModel.MODEL, "commonmark.cto");
     modelManager.addCTOModel(markdownCommon.TemplateMarkModel.MODEL, "templatemark.cto");
     const factory = new concertoCore.Factory(modelManager);
-    const serializer = new concertoCore.Serializer(factory, modelManager);
+    const serializer = new concertoCore.Serializer(factory, modelManager, {});
     try {
-      serializer.fromJSON(templateMark);
+      serializer.fromJSON(templateMark, {});
     } catch (err) {
       throw new Error(`Generated invalid agreement: ${err}: ${JSON.stringify(templateMark, null, 2)}`);
     }
@@ -1063,22 +1113,22 @@ class TemplateMarkInterpreter {
     return compiler.compile(templateMark);
   }
   validateCiceroMark(ciceroMark) {
-    const modelManager = new concertoCore.ModelManager({ strict: true });
+    const modelManager = new concertoCore.ModelManager();
     modelManager.addCTOModel(markdownCommon.ConcertoMetaModel.MODEL, "concertometamodel.cto");
     modelManager.addCTOModel(markdownCommon.CommonMarkModel.MODEL, "commonmark.cto");
     modelManager.addCTOModel(markdownCommon.CiceroMarkModel.MODEL, "ciceromark.cto");
     const factory = new concertoCore.Factory(modelManager);
-    const serializer = new concertoCore.Serializer(factory, modelManager);
+    const serializer = new concertoCore.Serializer(factory, modelManager, {});
     try {
-      return serializer.fromJSON(ciceroMark);
+      return serializer.fromJSON(ciceroMark, {});
     } catch (err) {
       throw new Error(`Generated invalid agreement: ${err}: ${JSON.stringify(ciceroMark, null, 2)}`);
     }
   }
   async generate(templateMark, data, options) {
     const factory = new concertoCore.Factory(this.modelManager);
-    const serializer = new concertoCore.Serializer(factory, this.modelManager);
-    const templateData = serializer.fromJSON(data);
+    const serializer = new concertoCore.Serializer(factory, this.modelManager, {});
+    const templateData = serializer.fromJSON(data, {});
     if (templateData.getFullyQualifiedType() !== this.templateClass.getFullyQualifiedName()) {
       throw new Error(`Template data must be of type '${this.templateClass.getFullyQualifiedName()}'.`);
     }
@@ -1123,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 offer, 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 = {};
@@ -1147,65 +1197,70 @@ class TemplateArchiveProcessor {
         const result = compiler.compile(code);
         compiledCode[tsFile.getIdentifier()] = result;
       }
-      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, currentTime, utcOffset]
-      });
-      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 offer, defaults to zero
-   * @returns {Promise} the response and any events
+   * @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 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 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, currentTime, utcOffset]
-      });
-      if (evalResponse.result) {
-        return evalResponse.result;
-      } else {
-        throw new Error("Init failed with message: " + evalResponse.message);
-      }
+  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("Only TypeScript is supported at this time");
+      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, 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("Init failed with message: " + evalResponse.message);
     }
   }
 }