@onify/flow-extensions 8.2.2 → 8.3.1

package/dist/FlowScripts.js

@@ -3,12 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.FlowScriptError = exports.FlowResourceError = void 0;
 exports.FlowScripts = FlowScripts;
+exports.FlowSyntaxError = void 0;
 exports.JavaScript = JavaScript;
 exports.JavaScriptResource = JavaScriptResource;
-var _path = require("path");
-var _fs = require("fs");
-var _vm = require("vm");
+var _nodePath = require("node:path");
+var _nodeFs = require("node:fs");
+var _nodeVm = require("node:vm");
 const kSyntaxError = Symbol.for('syntax error');
 const kResources = Symbol.for('resources base');
 class FlowScriptError extends Error {
@@ -28,9 +30,10 @@ class FlowScriptError extends Error {
     });
   }
   toString() {
-    return '[FlowScriptError] ' + this.message + '\n' + this.stack;
+    return '[' + this.name + '] ' + this.message + '\n' + this.stack;
   }
 }
+exports.FlowScriptError = FlowScriptError;
 class FlowSyntaxError extends Error {
   constructor(fromErr) {
     super(fromErr.message);
@@ -48,14 +51,23 @@ class FlowSyntaxError extends Error {
     });
   }
   toString() {
-    return '[FlowSyntaxError] ' + this.message + '\n' + this.stack;
+    return '[' + this.name + '] ' + this.message + '\n' + this.stack;
   }
 }
+exports.FlowSyntaxError = FlowSyntaxError;
+class FlowResourceError extends FlowScriptError {
+  constructor(fromErr, filename) {
+    super(fromErr);
+    this.filename = filename;
+    this.inner = fromErr;
+  }
+}
+exports.FlowResourceError = FlowResourceError;
 function FlowScripts(flowName, resourceBase, runContext, timeout = 60000) {
-  this._name = flowName;
-  this._scripts = {};
-  this._timeout = timeout;
-  this._runContext = runContext;
+  this.flowName = flowName;
+  this.scripts = new Map();
+  this.timeout = timeout;
+  this.runContext = runContext;
   this[kResources] = resourceBase;
 }
 FlowScripts.prototype.register = function register({
@@ -83,31 +95,40 @@ FlowScripts.prototype.register = function register({
   if (!language) return;
   if (!['js', 'javascript'].includes(language.toLowerCase().trim())) return;
   language = 'javascript';
-  const name = this._name;
-  const filename = `${name}/${type}/${id}`;
+  const flowName = this.flowName;
+  const filename = `${flowName}/${type}/${id}`;
   if (scriptBody) {
-    this._scripts[id] = new JavaScript(name, scriptBody, this._runContext, {
+    this.scripts.set(id, new JavaScript(flowName, scriptBody, this.runContext, {
       filename,
-      timeout: this._timeout
-    });
+      timeout: this.timeout
+    }));
   } else if (resource) {
-    this._scripts[id] = new JavaScriptResource(name, resource, this[kResources], this._runContext, {
+    this.scripts.set(id, new JavaScriptResource(flowName, resource, this[kResources], this.runContext, {
       filename,
-      timeout: this._timeout
-    });
+      timeout: this.timeout
+    }));
   }
 };
 FlowScripts.prototype.getScript = function getScript(scriptType, {
   id
 }) {
-  return this._scripts[id];
+  return this.scripts.get(id);
 };
+
+/**
+ * Java script
+ * @param {string} flowName
+ * @param {string|Buffer} scriptBody
+ * @param {any} [runContext]
+ * @param {import('node:vm').ScriptOptions} options
+ */
 function JavaScript(flowName, scriptBody, runContext, options) {
   this.flowName = flowName;
-  this._runContext = runContext;
+  this.options = options;
+  this.runContext = runContext;
   this.timeout = options?.timeout;
   try {
-    this.script = new _vm.Script(scriptBody, options);
+    this.script = new _nodeVm.Script(scriptBody, options);
   } catch (err) {
     this[kSyntaxError] = new FlowSyntaxError(err);
   }
@@ -127,7 +148,7 @@ JavaScript.prototype.execute = async function execute(executionContext, callback
         from: Buffer.from
       },
       contextName: this.flowName,
-      ...this._runContext,
+      ...this.runContext,
       next
     }, {
       timeout: this.timeout
@@ -145,25 +166,37 @@ JavaScript.prototype.execute = async function execute(executionContext, callback
 function JavaScriptResource(flowName, resource, resourceBase, runContext, options) {
   this.flowName = flowName;
   this.resource = resource;
+  this.runContext = runContext;
   this.options = options;
-  this._runContext = runContext;
-  this[kResources] = resourceBase;
+  this.timeout = options?.timeout;
+  this.resourceBase = resourceBase;
 }
+
+/**
+ * Get javascript resource content
+ * @param {string} resourceBase Resource base
+ * @param {*} resource Resource name or path
+ * @returns {Promise<string|Buffer} Resource content
+ */
+JavaScriptResource.prototype.getResourceContent = function getResourceContent(resourceBase, resource) {
+  return _nodeFs.promises.readFile((0, _nodePath.join)(resourceBase, resource));
+};
 JavaScriptResource.prototype.execute = async function execute(executionContext, callback) {
   let resource;
   try {
     resource = executionContext.resolveExpression(this.resource);
-    var scriptBody = await _fs.promises.readFile((0, _path.join)(this[kResources], resource)); // eslint-disable-line no-var
+    var scriptBody = await this.getResourceContent(this.resourceBase, resource); // eslint-disable-line no-var
+    if (!scriptBody) throw new TypeError(`${this.options.filename}: script resource ${resource || this.resource} is empty`);
   } catch (err) {
     if (err instanceof SyntaxError) {
       return callback(err);
     }
-    const {
-      filename
-    } = this.options;
-    return callback(new Error(`${filename}: script resource ${resource || this.resource} not found`));
+    return callback(new FlowResourceError(err, this.options.filename));
+  }
+  if (!scriptBody) {
+    throw new FlowResourceError();
   }
-  const script = new JavaScript(this.flowName, scriptBody, this._runContext, {
+  const script = new JavaScript(this.flowName, scriptBody, this.runContext, {
     ...this.options,
     filename: `${this.options.filename}/${resource}`
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onify/flow-extensions",
-  "version": "8.2.2",
+  "version": "8.3.1",
   "description": "Onify Flow extensions",
   "type": "module",
   "module": "src/index.js",
@@ -50,9 +50,9 @@
     "@babel/core": "^7.23.9",
     "@babel/preset-env": "^7.23.9",
     "@babel/register": "^7.23.7",
-    "bpmn-elements": "^15.0.3",
+    "bpmn-elements": "^16.2.0",
     "bpmn-elements-8-1": "npm:bpmn-elements@8.1",
-    "bpmn-engine": "^21.1.0",
+    "bpmn-engine": "^23.0.1",
     "bpmn-engine-14": "npm:bpmn-engine@14",
     "bpmn-moddle": "^9.0.1",
     "c8": "^10.1.2",
@@ -66,13 +66,13 @@
     "moddle-context-serializer": "^4.1.1",
     "nock": "^13.5.4",
     "prettier": "^3.2.4",
-    "texample": "^0.0.5"
+    "texample": "^0.0.6"
   },
   "peerDependencies": {
+    "@0dep/piso": ">=2",
     "bpmn-elements": ">=14"
   },
   "dependencies": {
-    "@0dep/piso": "^2.0.0",
     "cron-parser": "^4.9.0"
   },
   "files": [

package/types/index.d.ts

@@ -1,5 +1,5 @@
 declare module '@onify/flow-extensions' {
-  import { SequenceFlow, TimerEventDefinition, ElementBase, IExtension, ContextInstance } from 'bpmn-elements';
+  import { SequenceFlow, TimerEventDefinition, ElementBase, IExtension, ContextInstance, SequenceFlow } from 'bpmn-elements';
   import { extendFn as extendFunction } from 'moddle-context-serializer';
 
   export class OnifySequenceFlow extends SequenceFlow {}
@@ -11,6 +11,48 @@ declare module '@onify/flow-extensions' {
 }
 
 declare module '@onify/flow-extensions/FlowScripts' {
-  import { IScripts } from 'bpmn-elements';
-  export var FlowScripts: IScripts;
+  import { IScripts, Script, ExecutionScope } from 'bpmn-elements';
+  import { SerializableElement } from 'moddle-context-serializer';
+  import { ScriptOptions } from 'node:vm';
+
+  declare type registerArgument = SerializableElement | { id: string; type: string; behavior: any };
+
+  export interface FlowScriptOptions extends ScriptOptions {
+    timeout?: number;
+  }
+
+  export class FlowScripts implements IScripts {
+    /**
+     * @param flowName Flow name
+     * @param resourceBase External resource base
+     * @param runContext Optional script globals
+     * @param timeout Optional execution timeout in milliseconds, default 60000
+     */
+    constructor(flowName: string, resourceBase: string, runContext?: any, timeout?: number);
+    flowName: string;
+    timeout: number;
+    /** Registered scripts */
+    get scripts(): Map<string, Script | JavaScriptResource>;
+    /** Registered scripts */
+    register(element: registerArgument): Script | undefined;
+    getScript(language: string, identifier: { id: string; [x: string]: any }): Script;
+  }
+
+  export class JavaScript implements Script {
+    constructor(flowName: string, scriptBody: string | Buffer, runContext: any, options?: FlowScriptOptions);
+    get flowName(): string;
+    get runContext(): unknown;
+    get options(): FlowScriptOptions;
+    execute(executionContext: ExecutionScope, callback: CallableFunction): void;
+  }
+
+  export class JavaScriptResource extends JavaScript {
+    constructor(flowName: string, resource: string, resourceBase: string, runContext?: unknown, options?: FlowScriptOptions);
+    /**
+     * Get javascript resource content
+     * @param resourceBase Resource base
+     * @param resource Resolved resource name or path
+     */
+    getResourceContent(resourceBase: string, resource: string): Promise<string | Buffer>;
+  }
 }