@pxp-nd/flow 1.0.56 → 1.0.58

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/controllers/Node.js

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * Effex 2021
+ *
+ * MIT
+ *
+ * Member Controller
+ *
+ * @summary Member Controller
+ * @author Favio Figueroa
+ *
+ * Created at     : 2021-07-08 12:55:38
+ * Last modified  :
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const Node_1 = __importDefault(require("../entity/Node"));
+const NodeConnection_1 = __importDefault(require("../entity/NodeConnection"));
+const core_1 = require("@pxp-nd/core");
+const lodash_1 = __importDefault(require("lodash"));
+const FieldMap_1 = __importDefault(require("../entity/FieldMap"));
+const OriginName_1 = __importDefault(require("../entity/OriginName"));
+const axios_1 = __importDefault(require("axios"));
+let Node = class Node extends core_1.Controller {
+    async getNodeData(node, dataId, manager) {
+        const { action: { originName, originKey } } = node;
+        const executeView = `select * from ${originName} where ${originKey} = ${dataId}`;
+        const resExecuteView = await core_1.__(manager.query(executeView));
+        return JSON.stringify(resExecuteView[0]);
+    }
+    async add(params, manager) {
+        let node = new Node_1.default();
+        node.isInit = params.isInit;
+        node.isEnd = params.isEnd;
+        node.actionId = params.actionId;
+        node.flowId = params.flowId;
+        node = await manager.save(node);
+        if (params.parents) {
+            for (let parent of params.parents) {
+                const nc = await NodeConnection_1.default.find({ nodeIdMaster: parent.parentId });
+                for (let connection of nc) {
+                    connection.nodeIdMaster = node.nodeId;
+                    await manager.save(connection);
+                }
+                let nodeConnection = new NodeConnection_1.default();
+                nodeConnection.nodeIdChild = node.nodeId;
+                nodeConnection.nodeIdMaster = parent.parentId;
+                nodeConnection.condition = parent.condition;
+                nodeConnection = await manager.save(nodeConnection);
+            }
+        }
+        const { nodeId } = node;
+        const nodeData = await manager.findOne(Node_1.default, nodeId);
+        return nodeData;
+    }
+    async AddActionConfigJson(params, manager) {
+        let { nodeId: removed, __metadata: removed2, ...actionConfigJson } = params;
+        Object.entries(params.__metadata).forEach(([nameKey, values]) => {
+            actionConfigJson[nameKey] = `{{ ${values.name} }}`;
+        });
+        const upd = await core_1.__(manager.update(Node_1.default, params.nodeId, {
+            actionConfigJson: JSON.stringify(actionConfigJson),
+        }));
+        return {
+            actionConfigJson,
+            success: true,
+            nodeId: params.nodeId,
+            upd
+        };
+    }
+    async getParameterizedNode(params, manager) {
+        lodash_1.default.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
+        const { nodeId, flowId, substitutionsSchemaJson = {} } = params;
+        const tNodeOrigin = await core_1.__(Node_1.default.findOne({
+            relations: ['action'],
+            where: {
+                flowId: flowId,
+                isInit: 'Y',
+                action: {
+                    originName: typeorm_1.Not(typeorm_1.IsNull())
+                }
+            }
+        }));
+        const tNodeData = core_1.__(Node_1.default.findOne(nodeId));
+        const tFieldMapData = core_1.__(manager.createQueryBuilder(FieldMap_1.default, 'fm')
+            .innerJoin(OriginName_1.default, 'on', 'on.originNameId = fm.originNameId')
+            .where("on.name = :n ", { n: tNodeOrigin.action.originName })
+            .getMany());
+        //const nodeOrigin = await tNodeOrigin; todo
+        const nodeData = await tNodeData;
+        const fieldMapData = await tFieldMapData;
+        /*const [nodeData, fieldMapData] = await Promise.all([
+          tNodeData,
+          tFieldMapData
+        ]);*/
+        const { actionConfigJson, action: { schemaJson, configJsonTemplate, actionType: { schemaJson: schemaJsonFromActionType } } } = nodeData;
+        const actionConfigJsonObject = actionConfigJson ? JSON.parse(actionConfigJson) : {};
+        const configJsonTemplateObject = configJsonTemplate ? JSON.parse(configJsonTemplate) : {};
+        let schemaJsonFromActionTypeObject = schemaJsonFromActionType ? JSON.parse(lodash_1.default.template(schemaJsonFromActionType)(substitutionsSchemaJson)) : {};
+        let schemaJsonFromActionObject = schemaJson ? JSON.parse(lodash_1.default.template(schemaJson)(substitutionsSchemaJson)) : {};
+        let schemaJsonObject = { ...schemaJsonFromActionTypeObject, ...schemaJsonFromActionObject };
+        const mergeValues = {
+            ...configJsonTemplateObject,
+            ...actionConfigJsonObject
+        };
+        const verifyIfValueFromFieldMap = (str) => {
+            if (/^{{/.test(str) && /}}$/.test(str)) {
+                return true;
+            }
+            return false;
+        };
+        const findFieldMapAndMetaData = (value) => {
+            const found = fieldMapData.find((fmd) => `{{ ${fmd.name} }}` === value) || {};
+            return {
+                initialValue: found.alias || value,
+                metadata: found
+            };
+        };
+        const findFieldMapUniqueByType = (fieldMappingType) => {
+            const filtered = fieldMapData.filter((fmd) => fmd.type === fieldMappingType);
+            if (filtered && filtered.length === 1) {
+                const [found] = filtered;
+                return {
+                    initialValue: found.alias,
+                    metadata: found
+                };
+            }
+            return undefined;
+        };
+        // this logic is for autocomplete for moment
+        const findFieldInConfigForComponent = async (json, value) => {
+            if (json.formComponent && json.formComponent.type === 'AutoComplete') {
+                const url = json.formComponent.store.axios.url;
+                const method = json.formComponent.store.axios.method;
+                const data = json.formComponent.store.axios.data;
+                const idDD = json.formComponent.store.idDD;
+                const descDD = json.formComponent.store.descDD;
+                const config = {
+                    method: method,
+                    url: url,
+                    headers: {
+                        'Authorization': '' + process.env.TOKEN_PXP_ND + '',
+                        'Content-Type': 'application/json'
+                    },
+                    data: {
+                        ...data,
+                        [idDD]: value
+                    }
+                };
+                // @ts-ignore
+                const resControllerAxios = await core_1.__(axios_1.default(config));
+                const desc = resControllerAxios.data.data[descDD];
+                return desc;
+            }
+            else if (json.formComponentTemplate && json.configGetDescValue) { // todo we need to see how works here
+                const { controller, storeId, descColumn } = json.configGetDescValue;
+                const config = {
+                    method: "get",
+                    url: `http://localhost:${process.env.PORT}/api/${controller}`,
+                    headers: {
+                        'Authorization': '' + process.env.TOKEN_PXP_ND + '',
+                        'Content-Type': 'application/json'
+                    },
+                    data: {
+                        [storeId]: value
+                    }
+                };
+                // @ts-ignore
+                const resControllerAxios = await core_1.__(axios_1.default(config));
+                const desc = resControllerAxios.data.data[descColumn];
+                return desc;
+            }
+            return undefined;
+        };
+        for (const [nameKey, value] of Object.entries(mergeValues)) {
+            if (schemaJsonObject[nameKey]) {
+                const descValue = await core_1.__(findFieldInConfigForComponent(schemaJsonObject[nameKey], value));
+                schemaJsonObject[nameKey] = {
+                    ...schemaJsonObject[nameKey],
+                    initialValue: value,
+                    ...(descValue && { descValue: descValue }),
+                    ...(verifyIfValueFromFieldMap(value) && { fromFieldMap: true, ...findFieldMapAndMetaData(value) }),
+                };
+            }
+        }
+        Object.entries(schemaJsonObject)
+            .filter(([, value]) => value.initialValue === undefined && value.fromFieldMap === undefined && value.fieldMappingType)
+            .forEach(([nameKey]) => {
+            const hasUniqueByTypeInMappingData = findFieldMapUniqueByType(schemaJsonObject[nameKey].fieldMappingType);
+            schemaJsonObject[nameKey] = {
+                ...schemaJsonObject[nameKey],
+                ...(hasUniqueByTypeInMappingData && { fromFieldMap: true, ...hasUniqueByTypeInMappingData }),
+            };
+        });
+        return {
+            actionConfigJsonObject,
+            configJsonTemplateObject,
+            mergeValues,
+            schemaJsonObject,
+            schemaJson,
+            node: nodeData,
+            fieldMapData,
+        };
+    }
+    async executeActionJson(params, manager) {
+        const { nodeId, originName, originKey, fromValues } = params;
+        // we need to get the value from merge values with originKey
+        const getParameterizedNodeData = await core_1.__(this.getParameterizedNode({ nodeId: nodeId }, manager));
+        const { mergeValues } = getParameterizedNodeData;
+        const findOriginValue = Object.entries(mergeValues).find(([nameValue]) => fromValues === nameValue);
+        const resValueObject = Object.fromEntries([findOriginValue]);
+        const originValue = resValueObject[fromValues];
+        const executeViewString = `select * from ${originName} where ${originKey} = ${originValue}`;
+        const resExecuteView = await typeorm_1.getManager().query(executeViewString);
+        /*const executeView = `select * from ${originName} where ${originKey} = ${newEvent.dataId}`;
+        const resExecuteView = await getManager().query(executeView);*/
+        return {
+            ...resExecuteView[0]
+        };
+    }
+};
+__decorate([
+    core_1.Post(),
+    core_1.DbSettings('Orm'),
+    core_1.ReadOnly(false),
+    core_1.Log(true),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
+    __metadata("design:returntype", Promise)
+], Node.prototype, "add", null);
+__decorate([
+    core_1.Post(),
+    core_1.DbSettings('Orm'),
+    core_1.ReadOnly(false),
+    core_1.Log(true),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
+    __metadata("design:returntype", Promise)
+], Node.prototype, "AddActionConfigJson", null);
+__decorate([
+    core_1.Post(),
+    core_1.DbSettings('Orm'),
+    core_1.ReadOnly(false),
+    core_1.Log(true),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
+    __metadata("design:returntype", Promise)
+], Node.prototype, "getParameterizedNode", null);
+__decorate([
+    core_1.Post(),
+    core_1.DbSettings('Orm'),
+    core_1.ReadOnly(false),
+    core_1.Log(true),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
+    __metadata("design:returntype", Promise)
+], Node.prototype, "executeActionJson", null);
+Node = __decorate([
+    core_1.Model('flow-nd/Node')
+], Node);
+exports.default = Node;

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/controllers/NodeInstance.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Kplian 2021
+ *
+ * MIT
+ *
+ * NodeInstance Controller
+ *
+ * @summary Member Controller
+ * @author Favio Figueroa
+ *         Jaime Rivera
+ *
+ * Created at     : 2021-07-08 12:55:38
+ * Last modified  :
+ */
+import { EntityManager } from 'typeorm';
+import { Controller } from '@pxp-nd/core';
+declare class NodeInstance extends Controller {
+    RecursiveInstance(params: Record<string, any>): Promise<unknown>;
+    ProcessDelay(params: Record<string, any>, manager: EntityManager): Promise<unknown>;
+}
+export default NodeInstance;

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/controllers/NodeInstance.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Kplian 2021
+ *
+ * MIT
+ *
+ * NodeInstance Controller
+ *
+ * @summary Member Controller
+ * @author Favio Figueroa
+ *         Jaime Rivera
+ *
+ * Created at     : 2021-07-08 12:55:38
+ * Last modified  :
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const moment_1 = __importDefault(require("moment"));
+const core_1 = require("@pxp-nd/core");
+const NodeConnection_1 = __importDefault(require("../entity/NodeConnection"));
+const NodeInstance_1 = __importDefault(require("../entity/NodeInstance"));
+const Node_1 = __importDefault(require("../entity/Node"));
+const axios_1 = __importDefault(require("axios"));
+const ActionType_1 = __importDefault(require("../entity/ActionType"));
+const Action_1 = __importDefault(require("../entity/Action"));
+const lodash_1 = __importDefault(require("lodash"));
+const FlowInstance_1 = __importDefault(require("../entity/FlowInstance"));
+//TODO replace this flow-nd need tobe independent library
+const common_1 = require("@pxp-nd/common");
+let NodeInstance = class NodeInstance extends core_1.Controller {
+    async RecursiveInstance(params) {
+        //https://lodash.com/docs/4.17.15#template
+        lodash_1.default.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
+        //todo after this we need to get the json variables and execute the view and conditions configured in the database
+        const { node, flowInstance, eventNode } = params;
+        const executeView = `select * from ${flowInstance.originName} where ${flowInstance.originKey} = ${flowInstance.dataId}`;
+        const resExecuteView = await core_1.__(typeorm_1.getManager().query(executeView));
+        const resultFromOrigin = resExecuteView[0];
+        let mergeJson = {};
+        const { actionConfigJson, action: { configJsonTemplate, actionType: { schemaJson } } } = node;
+        if (configJsonTemplate !== '' || actionConfigJson !== '') {
+            const actionConfigJsonObject = actionConfigJson && JSON.parse(lodash_1.default.template(actionConfigJson)(resultFromOrigin));
+            const configJsonTemplateObject = configJsonTemplate && JSON.parse(lodash_1.default.template(configJsonTemplate)(resultFromOrigin));
+            mergeJson = {
+                ...(configJsonTemplateObject || {}),
+                ...(actionConfigJsonObject || {}),
+                __resultFromOrigin: resultFromOrigin
+            };
+        }
+        let nodeInstance = new NodeInstance_1.default();
+        nodeInstance.flowInstanceId = flowInstance.flowInstanceId;
+        // @ts-ignore
+        nodeInstance.nodeId = node.nodeId;
+        nodeInstance.runTime = new Date();
+        if (node.action.actionType.isDelay === 'Y') {
+            const delay = node.delay;
+            const typeDelay = node.typeDelay;
+            nodeInstance.schedule = moment_1.default().add(delay, typeDelay).toDate();
+            nodeInstance.status = 'WAIT';
+            await typeorm_1.getManager().save(NodeInstance_1.default, nodeInstance);
+        }
+        else {
+            if (node.action.actionType.controller) {
+                const data = '';
+                const config = {
+                    method: 'post',
+                    url: `http://localhost:${process.env.PORT}/api/${node.action.actionType.controller}`,
+                    headers: {
+                        'Authorization': '' + process.env.TOKEN_PXP_ND + '',
+                        'Content-Type': 'application/json'
+                    },
+                    data: mergeJson
+                };
+                // @ts-ignore
+                const resControllerAxios = await core_1.__(axios_1.default(config));
+            }
+            await typeorm_1.getManager().save(NodeInstance_1.default, nodeInstance);
+            // @ts-ignore
+            const nodeConnectionList = await core_1.__(NodeConnection_1.default.find({ where: { nodeIdMaster: node.nodeId } }));
+            for (const nodeConnection of nodeConnectionList) {
+                const condition = lodash_1.default.template(nodeConnection.condition)(resultFromOrigin);
+                const evalCondition = eval(condition);
+                if (evalCondition) {
+                    const nodeRes = await core_1.__(Node_1.default.findOne(nodeConnection.nodeIdChild));
+                    await this.RecursiveInstance({ node: nodeRes, flowInstance, resultFromOrigin });
+                }
+            }
+        }
+        return {};
+    }
+    async ProcessDelay(params, manager) {
+        const flag = await common_1.GlobalData.findOne({ data: 'wf_processing_delay_nodes_flag' });
+        if (flag) {
+            if (flag.value == 'true') {
+                throw new core_1.PxpError(400, 'Already processing pending flows');
+            }
+            flag.value = 'true';
+            await typeorm_1.getManager().save(flag);
+            let nodeInstanceIdProcessing = -1;
+            try {
+                const maxNodes = await common_1.GlobalData.findOne({ data: 'wf_max_concurrent_delay_process' });
+                const nodeInstanceDelayData = await core_1.__(manager.createQueryBuilder(NodeInstance_1.default, 'ni')
+                    .innerJoin(Node_1.default, 'n', 'n.nodeId = ni.nodeId')
+                    .innerJoin(Action_1.default, 'a', 'a.actionId = n.actionId')
+                    .innerJoin(ActionType_1.default, 'at', 'at.actionTypeId = a.actionTypeId')
+                    .where("at.isDelay = 'Y' ")
+                    .andWhere('ni.schedule <= :start ', { start: new Date() })
+                    .andWhere("ni.status = 'WAIT' ")
+                    .limit((maxNodes && maxNodes.value))
+                    .getMany());
+                for (const nodeInstance of nodeInstanceDelayData) {
+                    //update status from wait to executing
+                    await core_1.__(manager.update(NodeInstance_1.default, nodeInstance.nodeInstanceId, {
+                        status: 'EXECUTING',
+                    }));
+                    const nodeConnectionList = await core_1.__(NodeConnection_1.default.find({ where: { nodeIdMaster: nodeInstance.nodeId } }));
+                    const flowInstance = await core_1.__(FlowInstance_1.default.findOne(nodeInstance.flowInstanceId));
+                    const resultFromOrigin = JSON.parse(flowInstance.resultFromOrigen);
+                    // todo if in some transaction there is an error we need to put in some log to error and not try only some times
+                    for (const nodeConnection of nodeConnectionList) { // todo create transaction for own node
+                        const nodeRes = await core_1.__(Node_1.default.findOne(nodeConnection.nodeIdChild));
+                        await this.RecursiveInstance({ node: nodeRes, flowInstance, resultFromOrigin });
+                    }
+                    //update status from wait to executed
+                    await core_1.__(manager.update(NodeInstance_1.default, nodeInstance.nodeInstanceId, {
+                        status: 'EXECUTED',
+                    }));
+                }
+            }
+            catch (error) {
+                flag.value = 'false';
+                await typeorm_1.getManager().save(flag);
+                throw new core_1.PxpError(400, 'Error processing node: ' + nodeInstanceIdProcessing);
+            }
+            flag.value = 'false';
+            await typeorm_1.getManager().save(flag);
+        }
+        return { success: true };
+    }
+};
+__decorate([
+    core_1.Post(),
+    core_1.DbSettings('Orm'),
+    core_1.ReadOnly(false),
+    core_1.Log(true),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, typeorm_1.EntityManager]),
+    __metadata("design:returntype", Promise)
+], NodeInstance.prototype, "ProcessDelay", null);
+NodeInstance = __decorate([
+    core_1.Model('flow-nd/NodeInstance')
+], NodeInstance);
+exports.default = NodeInstance;

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/controllers/OriginName.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Effex 2021
+ *
+ * MIT
+ *
+ * Member Controller
+ *
+ * @summary Member Controller
+ * @author Favio Figueroa
+ *
+ * Created at     : 2021-07-08 12:55:38
+ * Last modified  :
+ */
+import { Controller } from '@pxp-nd/core';
+declare class OriginName extends Controller {
+}
+export default OriginName;

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/controllers/OriginName.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Effex 2021
+ *
+ * MIT
+ *
+ * Member Controller
+ *
+ * @summary Member Controller
+ * @author Favio Figueroa
+ *
+ * Created at     : 2021-07-08 12:55:38
+ * Last modified  :
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@pxp-nd/core");
+let OriginName = class OriginName extends core_1.Controller {
+};
+OriginName = __decorate([
+    core_1.Model('flow-nd/OriginName')
+], OriginName);
+exports.default = OriginName;

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/controllers/index.d.ts

@@ -0,0 +1,11 @@
+import ActionController from './Action';
+import ActionTypeController from './ActionType';
+import EventController from './Event';
+import FieldMapController from './FieldMap';
+import FlowController from './Flow';
+import FlowInstanceController from './FlowInstance';
+import NodeController from './Node';
+import NodeInstanceController from './NodeInstance';
+import OriginNameController from './OriginName';
+export { ActionController, ActionTypeController, EventController, FieldMapController, FlowController, FlowInstanceController, NodeController, NodeInstanceController, OriginNameController };
+export declare const controllers: (typeof ActionTypeController)[];

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/controllers/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controllers = exports.OriginNameController = exports.NodeInstanceController = exports.NodeController = exports.FlowInstanceController = exports.FlowController = exports.FieldMapController = exports.EventController = exports.ActionTypeController = exports.ActionController = void 0;
+const Action_1 = __importDefault(require("./Action"));
+exports.ActionController = Action_1.default;
+const ActionType_1 = __importDefault(require("./ActionType"));
+exports.ActionTypeController = ActionType_1.default;
+const Event_1 = __importDefault(require("./Event"));
+exports.EventController = Event_1.default;
+const FieldMap_1 = __importDefault(require("./FieldMap"));
+exports.FieldMapController = FieldMap_1.default;
+const Flow_1 = __importDefault(require("./Flow"));
+exports.FlowController = Flow_1.default;
+const FlowInstance_1 = __importDefault(require("./FlowInstance"));
+exports.FlowInstanceController = FlowInstance_1.default;
+const Node_1 = __importDefault(require("./Node"));
+exports.NodeController = Node_1.default;
+const NodeInstance_1 = __importDefault(require("./NodeInstance"));
+exports.NodeInstanceController = NodeInstance_1.default;
+const OriginName_1 = __importDefault(require("./OriginName"));
+exports.OriginNameController = OriginName_1.default;
+exports.controllers = [Action_1.default, ActionType_1.default, Event_1.default, FieldMap_1.default, Flow_1.default, FlowInstance_1.default, Node_1.default, NodeInstance_1.default, OriginName_1.default];

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/entity/Action.d.ts

@@ -0,0 +1,20 @@
+import ActionType from './ActionType';
+import Node from './Node';
+import { PxpEntity } from '@pxp-nd/common';
+export default class Action extends PxpEntity {
+    actionId: number;
+    actionTypeId: number;
+    code: string;
+    name: string;
+    description: string;
+    originName: string;
+    originKey: string;
+    controllerFunction: string;
+    configJsonTemplate: string;
+    eventConfig: string;
+    hidden: string;
+    schemaJson: string;
+    actionType: ActionType;
+    nodes: Node[];
+    eventNodes: Node[];
+}

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/entity/Action.js

@@ -0,0 +1,85 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const ActionType_1 = __importDefault(require("./ActionType"));
+const Node_1 = __importDefault(require("./Node"));
+const common_1 = require("@pxp-nd/common");
+let Action = class Action extends common_1.PxpEntity {
+};
+__decorate([
+    typeorm_1.PrimaryGeneratedColumn({ name: 'action_id' }),
+    __metadata("design:type", Number)
+], Action.prototype, "actionId", void 0);
+__decorate([
+    typeorm_1.Column({ name: 'action_type_id', type: 'numeric', nullable: true }),
+    __metadata("design:type", Number)
+], Action.prototype, "actionTypeId", void 0);
+__decorate([
+    typeorm_1.Column({ type: 'varchar', nullable: false, length: 50 }),
+    __metadata("design:type", String)
+], Action.prototype, "code", void 0);
+__decorate([
+    typeorm_1.Column({ type: 'varchar', nullable: false, length: 100 }),
+    __metadata("design:type", String)
+], Action.prototype, "name", void 0);
+__decorate([
+    typeorm_1.Column({ type: 'text' }),
+    __metadata("design:type", String)
+], Action.prototype, "description", void 0);
+__decorate([
+    typeorm_1.Column({ name: 'origin_name', type: 'varchar', length: 100 }),
+    __metadata("design:type", String)
+], Action.prototype, "originName", void 0);
+__decorate([
+    typeorm_1.Column({ name: 'origin_key', type: 'varchar', length: 100 }),
+    __metadata("design:type", String)
+], Action.prototype, "originKey", void 0);
+__decorate([
+    typeorm_1.Column({ name: 'controller_function', type: 'varchar', length: 100 }),
+    __metadata("design:type", String)
+], Action.prototype, "controllerFunction", void 0);
+__decorate([
+    typeorm_1.Column({ name: 'config_json_template', type: 'text' }),
+    __metadata("design:type", String)
+], Action.prototype, "configJsonTemplate", void 0);
+__decorate([
+    typeorm_1.Column({ name: 'event_config', type: 'text' }),
+    __metadata("design:type", String)
+], Action.prototype, "eventConfig", void 0);
+__decorate([
+    typeorm_1.Column({ type: 'varchar', nullable: false, length: 1, default: 'N' }),
+    __metadata("design:type", String)
+], Action.prototype, "hidden", void 0);
+__decorate([
+    typeorm_1.Column({ name: 'schema_json', type: 'text' }),
+    __metadata("design:type", String)
+], Action.prototype, "schemaJson", void 0);
+__decorate([
+    typeorm_1.ManyToOne(() => ActionType_1.default, actionType => actionType.actions, { eager: true }),
+    typeorm_1.JoinColumn({ name: 'action_type_id' }),
+    __metadata("design:type", ActionType_1.default)
+], Action.prototype, "actionType", void 0);
+__decorate([
+    typeorm_1.OneToMany(() => Node_1.default, node => node.action),
+    __metadata("design:type", Array)
+], Action.prototype, "nodes", void 0);
+__decorate([
+    typeorm_1.OneToMany(() => Node_1.default, eventNode => eventNode.actionEvent),
+    __metadata("design:type", Array)
+], Action.prototype, "eventNodes", void 0);
+Action = __decorate([
+    typeorm_1.Entity({ name: 'twf_action' })
+], Action);
+exports.default = Action;

package/.yalc/@pxp-nd/flow/.yalc/@pxp-nd/flow/dist/entity/ActionType.d.ts

@@ -0,0 +1,16 @@
+import Action from './Action';
+import { PxpEntity } from '@pxp-nd/common';
+export default class ActionType extends PxpEntity {
+    actionTypeId: number;
+    name: string;
+    description: string;
+    schemaJson: string;
+    isStart: string;
+    isDelay: string;
+    haveCondition: string;
+    hidden: string;
+    controller: string;
+    extraSchemaJson: string;
+    actionsJson: string;
+    actions: Action[];
+}