@veridid/workflow-parser 0.3.1 → 0.4.0

package/package.json

@@ -1,42 +1,27 @@
 {
   "name": "@veridid/workflow-parser",
-  "version": "0.3.1",
-  "description": "Workflow Parser is a TypeScript Node.js module for parsing and managing workflow definitions in a PostgreSQL database.",
-  "main": "dist/index.js",
+  "version": "0.4.0",
+  "description": "FOr parsing JOSN data that represents data-driven state machines and delivering the display data for clients to render.",
+  "main": "index.js",
   "scripts": {
-    "build": "mkdir -p dist && cp src/schema.sql dist/",
-    "start": "node dist/index.js",
-    "prepublishOnly": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": " tsc --resolveJsonModule test/test.ts && node test/test.js"
   },
+  "keywords": ["workflow", "Parser", "Data-Driven State Machine"],
+  "author": "VeriDID Corp.  Nas TIl and Dave McKay",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/VeriDID/workflow-parser.git"
-  },
-  "keywords": [
-    "workflow",
-    "parser",
-    "action-menu"
-  ],
-  "author": "Nas Til - VeriDID",
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/VeriDID/workflow-parser/issues"
-  },
-  "homepage": "https://github.com/VeriDID/workflow-parser#readme",
-  "dependencies": {
-    "dotenv": "^16.4.5",
-    "pg": "^8.12.0",
-    "uuid": "^10.0.0"
+    "url": "git+https://github.com/DigiCred-Holdings/workflow-parser.git"
   },
+  "homepage": "https://github.com/DigiCred-Holdings/workflow-parser#readme",
   "devDependencies": {
-    "@types/dotenv": "^8.2.0",
-    "@types/node": "^20.14.2",
-    "@types/pg": "^8.11.6",
-    "@types/uuid": "^9.0.8",
-    "typescript": "^5.4.5"
+    "typescript": "^5.8.2"
   },
-  "files": [
-    "dist"
-  ]
+  "dependencies": {
+    "@types/pg": "^8.11.11",
+    "pg": "^8.14.1",
+    "reflect-metadata": "^0.2.2",
+    "typedi": "^0.10.0",
+    "uuid": "^11.1.0"
+  }
 }

package/src/implementations/action.default.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultAction = void 0;
+var DefaultAction = /** @class */ (function () {
+    function DefaultAction(actionExtension) {
+        this.actionExtension = actionExtension;
+    }
+    DefaultAction.prototype.processAction = function (currentWorkflow, instance, actionInput) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transition, state, action, findtransition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("*** processAction action=", actionInput);
+                        transition = {
+                            type: "none",
+                            workflow_id: instance.workflow_id,
+                            state_id: instance.current_state
+                        };
+                        if (!(actionInput.actionID != "")) return [3 /*break*/, 4];
+                        state = currentWorkflow.states.find(function (item) { return item.state_id == instance.current_state; });
+                        if (!(state.actions.length > 0)) return [3 /*break*/, 3];
+                        action = state.actions.find(function (item) { return item.action_id == actionInput.actionID; });
+                        if (!this.actionExtension) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.actionExtension.actions(actionInput, instance, action, transition)];
+                    case 1:
+                        transition = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        // handle the types of actions
+                        switch (action === null || action === void 0 ? void 0 : action.type) {
+                            case "saveData":
+                                // check condition
+                                if (eval(action.condition)) {
+                                    // save the data from the workflow action to the instance data
+                                    instance.state_data = Object.assign(instance.state_data, action.value);
+                                }
+                                break;
+                            case "stateData":
+                                // check condition
+                                if (eval(action.condition)) {
+                                    // save the data from the actionInput to the instance data
+                                    instance.state_data = Object.assign(instance.state_data, actionInput.data);
+                                }
+                                break;
+                            case "stateTransition":
+                                // check condition
+                                if (eval(action.condition)) {
+                                    // set the transition condition for a new state
+                                    transition.type = "stateTransition";
+                                    transition.state_id = action.state_id;
+                                }
+                                break;
+                            case "workflowTransition":
+                                // check condition
+                                if (eval(action.condition)) {
+                                    // set the transition condition for a new workflow
+                                    transition.type = "workflowTransition";
+                                    transition.workflow_id = action.workflow_id;
+                                }
+                                break;
+                            default:
+                        }
+                        _a.label = 3;
+                    case 3:
+                        findtransition = state.transitions.find(function (item) { return eval(item.condition); });
+                        if (findtransition) {
+                            transition = findtransition;
+                        }
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, transition];
+                }
+            });
+        });
+    };
+    return DefaultAction;
+}());
+exports.DefaultAction = DefaultAction;

package/src/implementations/action.default.ts

@@ -0,0 +1,74 @@
+import { IActionExtension } from "../interfaces/actionextension";
+import { IAction, Transition } from "../interfaces/actioninterface";
+import { Instance, Workflow } from "../interfaces/workflowinterface";
+
+export class DefaultAction implements IAction{
+    actionExtension: IActionExtension;
+
+    constructor(actionExtension: IActionExtension) {
+        this.actionExtension = actionExtension;
+    }
+    
+    async processAction(currentWorkflow: Workflow, instance: Instance, actionInput: any): Promise<Transition>{
+        console.log("*** processAction action=", actionInput);
+        // start with a blank transition
+        let transition:Transition = {    
+            type: "none",
+            workflow_id: instance.workflow_id,
+            state_id: instance.current_state
+        };
+
+        if(actionInput.actionID!="") {
+            // find the state
+            const state = currentWorkflow.states.find(item => { return item.state_id == instance.current_state });
+            // Only process actions if there are any
+            if(state.actions.length>0) {
+                const action = state.actions.find(item => { return item.action_id == actionInput.actionID })
+                // handle the types of actions from the extension first
+                if(this.actionExtension) {
+                    transition = await this.actionExtension.actions(actionInput, instance, action, transition)
+                }
+                // handle the types of actions
+                switch(action?.type) {
+                    case "saveData":
+                        // check condition
+                        if(eval(action.condition)) {
+                            // save the data from the workflow action to the instance data
+                            instance.state_data = Object.assign(instance.state_data, action.value);
+                        }
+                        break;
+                    case "stateData":
+                        // check condition
+                        if(eval(action.condition)) {
+                            // save the data from the actionInput to the instance data
+                            instance.state_data = Object.assign(instance.state_data, actionInput.data);
+                        }
+                        break;
+                    case "stateTransition":
+                        // check condition
+                        if(eval(action.condition)) {
+                            // set the transition condition for a new state
+                            transition.type = "stateTransition";
+                            transition.state_id = action.state_id;
+                        }
+                        break;
+                    case "workflowTransition":
+                        // check condition
+                        if(eval(action.condition)) {
+                            // set the transition condition for a new workflow
+                            transition.type = "workflowTransition";
+                            transition.workflow_id = action.workflow_id;
+                        }
+                        break;
+                    default:
+                }
+            }
+            // check the transitions until the first true condition
+            let findtransition = state.transitions.find(item => { return eval(item.condition) })
+            if(findtransition) {
+                transition = findtransition;
+            }
+        }
+        return transition;
+    }
+}

package/src/implementations/display.default.js

@@ -0,0 +1,132 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultDisplay = void 0;
+var DefaultDisplay = /** @class */ (function () {
+    function DefaultDisplay(displayExtension) {
+        this.displayExtension = displayExtension;
+    }
+    DefaultDisplay.prototype.processDisplay = function (clientID, curentWorkflow, instance, currentState) {
+        return __awaiter(this, void 0, void 0, function () {
+            var displayData, display, displayTemplate, i, newValue;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log("*** processDisplay");
+                        displayData = { displayData: [] };
+                        display = curentWorkflow.states.find(function (item) { return item.state_id == currentState; });
+                        displayTemplate = display.display_data;
+                        i = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(i < displayTemplate.length)) return [3 /*break*/, 5];
+                        // condition can use instance.stateData
+                        if ((_a = displayTemplate[i]) === null || _a === void 0 ? void 0 : _a.condition) {
+                            if (!eval(displayTemplate[i].condition)) {
+                                return [3 /*break*/, 4]; // don't process if condition not met
+                            }
+                        }
+                        if (!this.displayExtension) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.displayExtension.displays(instance, displayTemplate[i])];
+                    case 2:
+                        newValue = _b.sent();
+                        if (newValue) {
+                            displayTemplate[i] = newValue;
+                        }
+                        _b.label = 3;
+                    case 3:
+                        switch (displayTemplate[i].type) {
+                            case "text":
+                                displayTemplate[i].text = this.parseString(displayTemplate[i].text, instance.state_data);
+                                break;
+                            case "control":
+                                displayTemplate[i].text = this.parseString(displayTemplate[i].text, instance.state_data);
+                                break;
+                        }
+                        displayData.displayData[i] = displayTemplate[i];
+                        _b.label = 4;
+                    case 4:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 5: return [2 /*return*/, displayData];
+                }
+            });
+        });
+    };
+    DefaultDisplay.prototype.parseString = function (text, data) {
+        // Split out the string
+        var parts = text.split(/[{,}]/);
+        // check every other string segment looking for a key in data
+        // Text for parsing should not start with a variable "{variable} hello!"
+        // *** repalce this code with a more comprehensive parser
+        for (var i = 1; i < parts.length; i += 2) {
+            // find this value in the data
+            var value = this.findNode(parts[i], data);
+            if (value) {
+                // if there is a value, replace the entry
+                parts[i] = value;
+            }
+        }
+        // put the string back together again
+        return parts.join("");
+    };
+    DefaultDisplay.prototype.findNode = function (id, currentNode) {
+        var currentChild, result;
+        if (id in currentNode) {
+            return currentNode[id];
+        }
+        else {
+            // use a for loop instead of forEach to avoid nested functions
+            // otherwise "return" will not work properly
+            for (var i = 0; currentNode.children !== undefined; i += 1) {
+                currentChild = currentNode.children[i];
+                // Search in the current child
+                result = this.findNode(id, currentChild);
+                // Return the result if the node has been found
+                if (result !== false) {
+                    return result;
+                }
+            }
+            // the node has not been found and we have no more options
+            return false;
+        }
+    };
+    return DefaultDisplay;
+}());
+exports.DefaultDisplay = DefaultDisplay;

package/src/implementations/display.default.ts

@@ -0,0 +1,98 @@
+import { IDisplayExtension } from "../interfaces/displayextension";
+import { DisplayData, IDisplay } from "../interfaces/displayinterface";
+import { Instance, Workflow } from "../interfaces/workflowinterface";
+
+export class DefaultDisplay implements IDisplay {
+    displayExtension: IDisplayExtension;
+
+    constructor(displayExtension: IDisplayExtension) {
+        this.displayExtension = displayExtension;
+    }
+
+    async processDisplay(
+        clientID: string, 
+        curentWorkflow: Workflow, 
+        instance: Instance, 
+        currentState: string): Promise<DisplayData> {
+        
+        console.log("*** processDisplay");
+        // build the display data to return
+        let displayData: DisplayData = {displayData: []};
+        // for each display entry check condition and process if required
+        const display = curentWorkflow.states.find(item => { return item.state_id == currentState});
+        const displayTemplate = display.display_data;
+        for(var i=0; i<displayTemplate.length; i++) {
+            // condition can use instance.stateData
+            if(displayTemplate[i]?.condition) {
+                if(!eval(displayTemplate[i].condition)) {
+                    continue;   // don't process if condition not met
+                }
+            }
+            
+            // handle the types of displays from the extension first
+            if(this.displayExtension) {
+                let newValue = await this.displayExtension.displays(instance, displayTemplate[i]);
+                if(newValue) {
+                    displayTemplate[i]=newValue;
+                }
+            }
+
+            switch(displayTemplate[i].type) {
+                case "text":
+                    displayTemplate[i].text= this.parseString(displayTemplate[i].text, instance.state_data);
+                    break;
+                case "control":
+                    displayTemplate[i].text= this.parseString(displayTemplate[i].text, instance.state_data);
+                    break;
+            }
+            displayData.displayData[i]=displayTemplate[i];
+        }
+
+        return displayData;
+    }
+
+    parseString(text: string, data: any) {
+        // Split out the string
+        const parts = text.split(/[{,}]/);
+        // check every other string segment looking for a key in data
+        // Text for parsing should not start with a variable "{variable} hello!"
+        // *** repalce this code with a more comprehensive parser
+
+        for(var i=1;i<parts.length; i+=2) {
+            // find this value in the data
+            let value = this.findNode(parts[i], data);
+            if(value) {
+                // if there is a value, replace the entry
+                parts[i]=value;
+            }
+        }
+        // put the string back together again
+        return parts.join("");
+    }
+
+
+    findNode(id: string, currentNode: any): any {
+        var currentChild: any, result: any;
+
+        if (id in currentNode) {
+            return currentNode[id];
+        } else {
+            // use a for loop instead of forEach to avoid nested functions
+            // otherwise "return" will not work properly
+            for (var i = 0; currentNode.children !== undefined ; i += 1) {
+                currentChild = currentNode.children[i];
+    
+                // Search in the current child
+                result = this.findNode(id, currentChild);
+    
+                // Return the result if the node has been found
+                if (result !== false) {
+                    return result;
+                }
+            }
+    
+            // the node has not been found and we have no more options
+            return false;
+        }
+    }
+}

package/src/implementations/workflow.default.js

@@ -0,0 +1,146 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultWorkflow = void 0;
+var uuid_1 = require("uuid");
+var DefaultWorkflow = /** @class */ (function () {
+    function DefaultWorkflow(dbClient) {
+        this.dbClient = dbClient;
+    }
+    DefaultWorkflow.prototype.getWorkflowByID = function (workflowID) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log("*** getWorkflowByID");
+                        return [4 /*yield*/, ((_a = this.dbClient) === null || _a === void 0 ? void 0 : _a.query('SELECT * FROM workflows WHERE "workflow_id" = $1', [workflowID]))];
+                    case 1:
+                        res = _b.sent();
+                        //console.log("WorkflowID=", workflowID);
+                        //console.log("Workflow=", res.rows[0]);
+                        return [2 /*return*/, res.rows.length > 0 ? res.rows[0] : null];
+                }
+            });
+        });
+    };
+    DefaultWorkflow.prototype.getInstanceByID = function (clientID, workflowID) {
+        return __awaiter(this, void 0, void 0, function () {
+            var instance, query, res, workflow;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log("*** getInstanceByID");
+                        instance = null;
+                        query = 'SELECT * FROM instances WHERE "client_id" = $1 AND "workflow_id" = $2';
+                        return [4 /*yield*/, ((_a = this.dbClient) === null || _a === void 0 ? void 0 : _a.query(query, [clientID, workflowID]))];
+                    case 1:
+                        res = _b.sent();
+                        if (!(res.rows.length === 0)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.getWorkflowByID(workflowID)];
+                    case 2:
+                        workflow = _b.sent();
+                        return [4 /*yield*/, this.newInstance(clientID, workflowID, workflow.initial_state)];
+                    case 3:
+                        // Create new instance with new instanceID, the initial state fromt he workflow, and empoty instance data
+                        instance = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        instance = res.rows.length > 0 ? res.rows[0] : null;
+                        _b.label = 5;
+                    case 5: 
+                    //console.log("Instance=",  instance);
+                    return [2 /*return*/, instance];
+                }
+            });
+        });
+    };
+    DefaultWorkflow.prototype.newInstance = function (clientID, workflowID, stateID) {
+        return __awaiter(this, void 0, void 0, function () {
+            var query, result, res;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log("*** newInstance=", clientID, workflowID, stateID);
+                        query = 'INSERT INTO instances (instance_id, workflow_id, client_id, current_state, state_data) VALUES ($1, $2, $3, $4, $5)';
+                        return [4 /*yield*/, ((_a = this.dbClient) === null || _a === void 0 ? void 0 : _a.query(query, [(0, uuid_1.v4)(), workflowID, clientID, stateID, {}]))];
+                    case 1:
+                        result = _b.sent();
+                        return [4 /*yield*/, this.getInstanceByID(clientID, workflowID)];
+                    case 2:
+                        res = _b.sent();
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    DefaultWorkflow.prototype.updateInstanceByID = function (clientID, workflowID, stateID, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var instance, query;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log("*** updateInstance=", clientID, workflowID, stateID, data);
+                        return [4 /*yield*/, this.getInstanceByID(clientID, workflowID)];
+                    case 1:
+                        instance = _b.sent();
+                        query = "UPDATE instances SET current_state = $1, state_data = $2 WHERE workflow_id = $3 AND client_id = $4";
+                        //console.log("query=", query);
+                        //console.log("stateID=", stateID, " data=", data);
+                        //console.log("workflowID=", stateID, " clientID=", clientID);
+                        return [4 /*yield*/, ((_a = this.dbClient) === null || _a === void 0 ? void 0 : _a.query(query, [stateID, JSON.stringify(data), workflowID, clientID]))];
+                    case 2:
+                        //console.log("query=", query);
+                        //console.log("stateID=", stateID, " data=", data);
+                        //console.log("workflowID=", stateID, " clientID=", clientID);
+                        _b.sent();
+                        return [4 /*yield*/, this.getInstanceByID(clientID, workflowID)];
+                    case 3:
+                        instance = _b.sent();
+                        return [2 /*return*/, instance];
+                }
+            });
+        });
+    };
+    return DefaultWorkflow;
+}());
+exports.DefaultWorkflow = DefaultWorkflow;