@veridid/workflow-parser 0.3.2 → 0.4.0

package/src/implementations/workflow.default.ts

@@ -0,0 +1,64 @@
+import { Instance, IWorkflow, Workflow } from '../interfaces/workflowinterface'
+import { Client } from 'pg';
+import { v4 as uuidv4 } from 'uuid';
+
+export class DefaultWorkflow implements IWorkflow {
+    dbClient: Client;
+
+    constructor(dbClient: Client) {
+        this.dbClient = dbClient;
+    }
+
+    async getWorkflowByID(workflowID: string): Promise<Workflow> {
+        console.log("*** getWorkflowByID");
+        const res = await this.dbClient?.query('SELECT * FROM workflows WHERE "workflow_id" = $1', [workflowID]);
+        //console.log("WorkflowID=", workflowID);
+        //console.log("Workflow=", res.rows[0]);
+        return res.rows.length > 0 ? res.rows[0] : null;
+    }
+
+    async getInstanceByID(clientID: string, workflowID: string): Promise<Instance> {
+        console.log("*** getInstanceByID");
+        let instance = null;
+        let query = 'SELECT * FROM instances WHERE "client_id" = $1 AND "workflow_id" = $2';
+        let res = await this.dbClient?.query(query, [clientID, workflowID]);
+        //console.log("Look for existing instance clientID=", clientID, " workflowID=", workflowID);
+        //console.log("Found ", res.rows);
+        if(res.rows.length === 0) {
+            // no instance
+            //console.log("getInstanceByID - no instance");
+            const workflow = await this.getWorkflowByID(workflowID);
+            // Create new instance with new instanceID, the initial state fromt he workflow, and empoty instance data
+            instance = await this.newInstance(clientID, workflowID, workflow.initial_state);
+        }
+        else {
+            instance = res.rows.length > 0 ? res.rows[0] : null;
+        }
+
+        //console.log("Instance=",  instance);
+        return instance;
+    }
+
+    async newInstance(clientID: string, workflowID: string, stateID: string): Promise<Instance> {
+        console.log("*** newInstance=", clientID, workflowID, stateID);
+        const query = 'INSERT INTO instances (instance_id, workflow_id, client_id, current_state, state_data) VALUES ($1, $2, $3, $4, $5)';
+        let result = await this.dbClient?.query(query, [uuidv4(), workflowID, clientID, stateID, {}]);
+        let res = await this.getInstanceByID(clientID, workflowID);
+        return res;
+    }
+
+    async updateInstanceByID(clientID: string, workflowID: string, stateID: string, data: any): Promise<Instance> {
+        console.log("*** updateInstance=", clientID, workflowID, stateID, data);
+        // check instance and create new if does not exist
+        let instance = await this.getInstanceByID(clientID, workflowID);
+        // update current_state and state_data
+        const 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);
+        await this.dbClient?.query(query, [stateID, JSON.stringify(data), workflowID, clientID]);
+        instance = await this.getInstanceByID(clientID, workflowID);
+        return instance;
+    }
+
+}

package/src/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowParser = void 0;
+require("reflect-metadata");
+var workflowparser_1 = require("./workflowparser");
+Object.defineProperty(exports, "WorkflowParser", { enumerable: true, get: function () { return workflowparser_1.WorkflowParser; } });

package/src/index.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { WorkflowParser } from './workflowparser';
+
+export {
+    WorkflowParser
+} from './workflowparser'

package/src/interfaces/actionextension.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/actionextension.ts

@@ -0,0 +1,7 @@
+import { Instance, IWorkflow, Workflow } from "./workflowinterface";
+import { IAction, Transition } from "./actioninterface"
+
+
+export interface IActionExtension {
+    actions: (actionInput: any, instance: Instance, action: any, transtion: Transition) => Promise<Transition>;
+}

package/src/interfaces/actioninterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/actioninterface.ts

@@ -0,0 +1,11 @@
+import { Instance, IWorkflow, Workflow } from "./workflowinterface";
+
+export interface IAction {
+    processAction: (currentWorkflow: Workflow, instance: Instance, action: any) => Promise<Transition>;
+}
+
+export interface Transition {
+    type: string,
+    workflow_id: string,
+    state_id: string
+}

package/src/interfaces/displayextension.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/displayextension.ts

@@ -0,0 +1,7 @@
+import { Instance, IWorkflow, Workflow } from "./workflowinterface";
+import { IAction, Transition } from "./actioninterface"
+
+
+export interface IDisplayExtension {
+    displays: (instance: Instance, template: any) => Promise<any>;
+}

package/src/interfaces/displayinterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/displayinterface.ts

@@ -0,0 +1,13 @@
+import { Workflow, Instance } from "./workflowinterface";
+
+export interface IDisplay {
+    processDisplay: (
+        clientID: string, 
+        curentWorkflow: Workflow, 
+        instance: Instance, 
+        currentState: string) => Promise<DisplayData>;
+}
+
+export interface DisplayData {
+    displayData: any[]
+}

package/src/interfaces/workflowinterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/workflowinterface.ts

@@ -0,0 +1,24 @@
+export interface IWorkflow {
+
+    getWorkflowByID: (workflowID: string) => Promise<Workflow>;
+    getInstanceByID: (workflowID: string, clientID: string) => Promise<Instance>;
+    updateInstanceByID: (clientID: string, workflowID: string, stateID: string, data: any) => Promise<Instance>;
+    newInstance: (clientID: string, workflowID: string, stateID: string, data: any) => Promise<Instance>;
+
+}
+
+export interface Workflow {
+    workflow_id: string;
+    name: string;
+    initial_state: string;
+    render: any[];
+    states: [{state_id: string, display_data: any, actions: any, transitions: any}]
+}
+
+export interface Instance {
+    instance_id: string;
+    workflow_id: string;
+    client_id: string,
+    current_state: string;
+    state_data: any;
+}

package/{dist/schema.sql → src/support/Schema.sql}

@@ -10,7 +10,7 @@ CREATE TABLE workflows (
 CREATE TABLE instances (
   "instanceID" UUID PRIMARY KEY DEFAULT gen_random_uuid(),
   "workflowID" VARCHAR(255) REFERENCES workflows("workflowID"),
-  "connectionID" VARCHAR(255),
+  "clientID" VARCHAR(255),
   "currentState" VARCHAR(255),
   "stateData" JSONB
-);
+);

package/src/workflowparser.js

@@ -0,0 +1,100 @@
+"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.WorkflowParser = void 0;
+var WorkflowParser = /** @class */ (function () {
+    function WorkflowParser(display, action, workflow) {
+        this.display = display;
+        this.action = action;
+        this.workflow = workflow;
+    }
+    WorkflowParser.prototype.parse = function (clientID, action) {
+        return __awaiter(this, void 0, void 0, function () {
+            var curentWorkflow, instance, currentState, transition, updatedInstance, display;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("=== parse clientID=", clientID, " action=", action);
+                        return [4 /*yield*/, this.workflow.getWorkflowByID(action === null || action === void 0 ? void 0 : action.workflowID)];
+                    case 1:
+                        curentWorkflow = _a.sent();
+                        console.log("+++ currentWorkflow");
+                        return [4 /*yield*/, this.workflow.getInstanceByID(clientID, action === null || action === void 0 ? void 0 : action.workflowID)];
+                    case 2:
+                        instance = _a.sent();
+                        console.log("+++ instance");
+                        currentState = instance.current_state;
+                        return [4 /*yield*/, this.action.processAction(curentWorkflow, instance, action)];
+                    case 3:
+                        transition = _a.sent();
+                        console.log("+++ transition");
+                        if (!(transition.type != "none")) return [3 /*break*/, 7];
+                        if (!(transition.type === 'workflowTransition')) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.workflow.getWorkflowByID(transition === null || transition === void 0 ? void 0 : transition.workflow_id)];
+                    case 4:
+                        // get the new workflow
+                        curentWorkflow = _a.sent();
+                        return [4 /*yield*/, this.workflow.getInstanceByID(clientID, transition === null || transition === void 0 ? void 0 : transition.workflow_id)];
+                    case 5:
+                        // get the new instance
+                        instance = _a.sent();
+                        currentState = instance.current_state;
+                        _a.label = 6;
+                    case 6:
+                        if (transition.type === 'stateTransition') {
+                            // set the new current state
+                            currentState = transition.state_id;
+                        }
+                        _a.label = 7;
+                    case 7: return [4 /*yield*/, this.workflow.updateInstanceByID(clientID, curentWorkflow.workflow_id, currentState, instance.state_data)];
+                    case 8:
+                        updatedInstance = _a.sent();
+                        console.log("+++ Updated instance");
+                        return [4 /*yield*/, this.display.processDisplay(clientID, curentWorkflow, updatedInstance, currentState)];
+                    case 9:
+                        display = _a.sent();
+                        console.log("+++ Prcoessed display");
+                        // return workflowID and display
+                        return [2 /*return*/, { workflowID: curentWorkflow.workflow_id, displayData: display.displayData }];
+                }
+            });
+        });
+    };
+    return WorkflowParser;
+}());
+exports.WorkflowParser = WorkflowParser;

package/src/workflowparser.ts

@@ -0,0 +1,70 @@
+import { IDisplay } from "./interfaces/displayinterface";
+import { IAction } from "./interfaces/actioninterface";
+import { IWorkflow } from "./interfaces/workflowinterface";
+
+export class WorkflowParser {
+    display: IDisplay;
+    action: IAction;
+    workflow: IWorkflow;
+
+    constructor(
+        display: IDisplay,
+        action: IAction,
+        workflow: IWorkflow
+    ) {
+        this.display = display;
+        this.action = action;
+        this.workflow = workflow;
+    }
+
+    async parse(
+        clientID: string, 
+        action: { 
+            workflowID: string; 
+            actionID: string; 
+            data?: any }
+    ): Promise<any> {
+        console.log("=== parse clientID=", clientID, " action=", action);
+
+        // get the workflow as JSON
+        let curentWorkflow = await this.workflow.getWorkflowByID(action?.workflowID);
+        console.log("+++ currentWorkflow");
+
+        // get the instance as JSON
+        let instance = await this.workflow.getInstanceByID(clientID, action?.workflowID);
+        console.log("+++ instance");
+
+        // current state in the workflow
+        let currentState = instance.current_state;
+
+        // process the action
+        let transition = await this.action.processAction(curentWorkflow, instance, action);
+        console.log("+++ transition");
+
+        if(transition.type != "none") {
+            // process the transition
+            if(transition.type === 'workflowTransition') {
+                // get the new workflow
+                curentWorkflow = await this.workflow.getWorkflowByID(transition?.workflow_id);
+                // get the new instance
+                instance = await this.workflow.getInstanceByID(clientID, transition?.workflow_id);
+                currentState = instance.current_state;
+            }
+            if(transition.type === 'stateTransition') {
+                // set the new current state
+                currentState = transition.state_id;
+            }
+        }
+
+        // update the instance
+        const updatedInstance = await this.workflow.updateInstanceByID(clientID, curentWorkflow.workflow_id, currentState, instance.state_data);
+        console.log("+++ Updated instance");
+
+        // process the display
+        const display = await this.display.processDisplay(clientID, curentWorkflow, updatedInstance, currentState)
+        console.log("+++ Prcoessed display");
+
+        // return workflowID and display
+        return {workflowID: curentWorkflow.workflow_id, displayData: display.displayData};
+    }
+}

package/test/action.extension.js

@@ -0,0 +1,65 @@
+"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.ExtendedAction = void 0;
+var ExtendedAction = /** @class */ (function () {
+    function ExtendedAction() {
+    }
+    ExtendedAction.prototype.actions = function (actionInput, instance, action, transition) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                console.log("^^^ Extension -> actions");
+                // handle the types of actions
+                switch (action === null || action === void 0 ? void 0 : action.type) {
+                    case "extension":
+                        // 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;
+                    default:
+                }
+                return [2 /*return*/, transition];
+            });
+        });
+    };
+    ;
+    return ExtendedAction;
+}());
+exports.ExtendedAction = ExtendedAction;

package/test/action.extension.ts

@@ -0,0 +1,22 @@
+import { IActionExtension } from "../src/interfaces/actionextension";
+import { Transition } from "../src/interfaces/actioninterface";
+import { Instance, Workflow } from "../src/interfaces/workflowinterface";
+
+export class ExtendedAction implements IActionExtension {
+    async actions(actionInput: any, instance: Instance, action: any, transition: Transition): Promise<Transition>{
+        console.log("^^^ Extension -> actions");
+        // handle the types of actions
+        switch(action?.type) {
+            case "extension":
+                // 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;
+            default:
+        }
+    
+        return transition;
+    };
+}

package/test/display.extension.js

@@ -0,0 +1,60 @@
+"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.ExtendedDisplay = void 0;
+var ExtendedDisplay = /** @class */ (function () {
+    function ExtendedDisplay() {
+    }
+    ExtendedDisplay.prototype.displays = function (instance, template) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                console.log("^^^ Extension -> displays");
+                // handle the types of actions
+                switch (template.type) {
+                    case "extended":
+                        template.text = "Extended display render!!";
+                        break;
+                }
+                return [2 /*return*/, template];
+            });
+        });
+    };
+    ;
+    return ExtendedDisplay;
+}());
+exports.ExtendedDisplay = ExtendedDisplay;

package/test/display.extension.ts

@@ -0,0 +1,16 @@
+import { Transition } from "../src/interfaces/actioninterface";
+import { IDisplayExtension } from "../src/interfaces/displayextension";
+import { Instance, Workflow } from "../src/interfaces/workflowinterface";
+
+export class ExtendedDisplay implements IDisplayExtension {
+    async displays(instance: Instance, template: any): Promise<any>{
+        console.log("^^^ Extension -> displays");
+        // handle the types of actions
+        switch(template.type) {
+            case "extended":
+                template.text= "Extended display render!!";
+                break;
+        }    
+        return template;
+    };
+}

package/test/docker-compose.yml

@@ -0,0 +1,33 @@
+version: '3.8'
+services:
+  postgres:
+    container_name: container-pg
+    image: postgres:16.2
+    command: -c config_file=/etc/postgresql.conf
+    hostname: localhost
+    ports:
+      - "5432:5432"
+    environment:
+      POSTGRES_USER: admin
+      POSTGRES_PASSWORD: root
+      POSTGRES_DB: test_workflows
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+      - ./postgresql.conf:/etc/postgresql.conf
+      - ./pg_hba.conf:/etc/pg_hba.conf
+    restart: unless-stopped
+
+  pgadmin:
+    container_name: container-pgadmin
+    image: dpage/pgadmin4
+    depends_on:
+      - postgres
+    ports:
+      - "5050:80"
+    environment:
+      PGADMIN_DEFAULT_EMAIL: admin@admin.com
+      PGADMIN_DEFAULT_PASSWORD: root
+    restart: unless-stopped
+
+volumes:
+  postgres-data:

package/test/pg_hba.conf

@@ -0,0 +1,14 @@
+# TYPE  DATABASE        USER            ADDRESS                 METHOD
+
+# "local" is for Unix domain socket connections only
+local   all             all                                     trust
+# IPv4 local connections:
+host    all             all             0.0.0.0/0               trust
+host    all             all             all                     trust
+# IPv6 local connections:
+host    all             all             ::1/128                 trust
+# Allow replication connections from localhost, by a user with the
+# replication privilege.
+#local   replication     postgres                                trust
+#host    replication     postgres        127.0.0.1/32            trust
+#host    replication     postgres        ::1/128                 trust

package/test/postgresql.conf

@@ -0,0 +1,42 @@
+#------------------------------------------------------------------------------
+# FILE LOCATIONS
+#------------------------------------------------------------------------------
+
+# The default values of these variables are driven from the -D command-line
+# option or PGDATA environment variable, represented here as ConfigDir.
+
+#data_directory = 'ConfigDir'           # use data in another directory
+                                        # (change requires restart)
+hba_file = '/etc/pg_hba.conf'           # host-based authentication file
+                                        # (change requires restart)
+#ident_file = 'ConfigDir/pg_ident.conf' # ident configuration file
+                                        # (change requires restart)
+
+# If external_pid_file is not explicitly set, no extra PID file is written.
+#external_pid_file = ''                 # write an extra PID file
+                                        # (change requires restart)
+
+
+#------------------------------------------------------------------------------
+# CONNECTIONS AND AUTHENTICATION
+#------------------------------------------------------------------------------
+
+# - Connection Settings -
+
+listen_addresses = '*'          # what IP address(es) to listen on;
+                                        # comma-separated list of addresses;
+                                        # defaults to 'localhost'; use '*' for all
+                                        # (change requires restart)
+port = 5432                             # (change requires restart)
+#max_connections = 100                  # (change requires restart)
+#reserved_connections = 0               # (change requires restart)
+#superuser_reserved_connections = 3     # (change requires restart)
+#unix_socket_directories = '/tmp'       # comma-separated list of directories
+                                        # (change requires restart)
+#unix_socket_group = ''                 # (change requires restart)
+#unix_socket_permissions = 0777         # begin with 0 to use octal notation
+                                        # (change requires restart)
+#bonjour = off                          # advertise server via Bonjour
+                                        # (change requires restart)
+#bonjour_name = ''                      # defaults to the computer name
+                                        # (change requires restart)

package/test/tables.sql

@@ -0,0 +1,17 @@
+CREATE TABLE workflows (
+  workflowID VARCHAR(255) PRIMARY KEY, 
+  name VARCHAR(255),
+  formatVersion VARCHAR(50),
+  initialState VARCHAR(255),
+  render JSONB,
+  states JSONB
+);
+
+CREATE TABLE instances (
+  instanceID UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  workflowID VARCHAR(255),
+  clientID VARCHAR(255), 
+  connectionID VARCHAR(255),
+  currentState VARCHAR(255),
+  stateData JSONB
+);