@avakado.ai/schemas 1.1.4 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avakado.ai/schemas",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Canonical Mongo schemas, models, enums and index declarations shared by the Avakado services.",
   "license": "UNLICENSED",
   "type": "module",

package/src/models/Action.js

@@ -1,5 +1,41 @@
 import { Schema } from "mongoose";
 import { defineModel } from "../runtime.js";
+const taskNodeCoreExecutionSchema = new Schema({
+    template: {
+        id: String,
+        data: Schema.Types.Mixed,
+    },
+    compiledInstructions: String,
+});
+const taskNodeCoreSchema = new Schema({
+    type: { type: String, required: true, enum: ['task', 'conditional'] },
+    input: {
+        schema: Schema.Types.Mixed,
+        mapper: Schema.Types.Mixed,
+        preset: Schema.Types.Mixed,
+    },
+    output: {
+        schema: Schema.Types.Mixed,
+        mapper: Schema.Types.Mixed,
+    },
+    coreExecution: taskNodeCoreExecutionSchema,
+    meta: { label: String, apiId: String }
+});
+const taskNodeChildrenSchema = new Schema({
+    id: String,
+    key: String,
+});
+const taskNodesSchema = new Schema({
+    id: String,
+    meta: { label: String },
+    core: taskNodeCoreSchema,
+    children: [taskNodeChildrenSchema],
+});
+export const Task_Tree = new Schema({
+    rootId: String,
+    rootKey: String,
+    nodes: [taskNodesSchema],
+});
 const ActionSchema = new Schema({
     name: String,
     business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
@@ -11,7 +47,7 @@ const ActionSchema = new Schema({
     functionString: String,
     errorFunction: String,
     UI: Schema.Types.Mixed,
-    isPublic: { type: Boolean, default: false },
+    task: Task_Tree
 }, {
     timestamps: true
 });

package/src/models/TriggersTemplate.js

@@ -0,0 +1,13 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+const TriggerTemplateSchema = new Schema({
+    name: { type: String, required: true, unique: true }, // convers
+    description: String,
+    type: String,
+    payload: Schema.Types.Mixed,
+}, {
+    timestamps: true,
+});
+TriggerTemplateSchema.index({ name: 1 });
+export const TriggerTemplate = defineModel("TriggerTemplate", TriggerTemplateSchema, "TriggerTemplate");

package/src/models/Workflow.js

@@ -1,44 +1,44 @@
 import { Schema } from "mongoose";
 import { defineModel } from "../runtime.js";
-
+import { Task_Tree } from "./Action.js";
 const WorkflowSchema = new Schema({
     name: { type: String, default: "Untitled Workflow" },
-    status: { type: String, enum: ["draft", "active", "disabled"], default: "draft" },
-    nodes: Object,
-    connections: Object,
+    trigger: { type: String, required: true },
     business: { type: Schema.Types.ObjectId, ref: "Businesses" },
+    status: { type: String, enum: ["active", "disabled"], default: "active" },
+    task: Task_Tree,
     createdBy: { type: Schema.Types.ObjectId, ref: "Users" },
 }, {
     timestamps: true,
 });
-WorkflowSchema.index({ createdBy: 1 });
+WorkflowSchema.index({ trigger: 1, business: 1, status: 1 });
 WorkflowSchema.index({ status: 1 });
 WorkflowSchema.methods.updateStatus = function (status) {
     this.status = status;
     return this.save();
 };
-WorkflowSchema.methods.getNextNode = function ({ currentNode = "", outputPortsOfCurentNode = [] } = {}) {
-    const nextNodes = [];
-    if (!currentNode) return [Object.keys(this.nodes).find((ele) => this.nodes[ele].type === "trigger")];
-    const { type } = this.nodes[currentNode];
-    Object.values(this.connections).forEach((ele) => {
-        if (!ele?.from || !ele?.to) {
-            console.log("errored no from or to");
-            return;
-        }
-        const [fromNodeId, , portId] = ele.from.split("/");
-        if (fromNodeId !== currentNode) {
-            return;
-        }
-        const [toNodeId] = ele.to.split("/");
-        if (type === "conditionalNode") {
-            if (outputPortsOfCurentNode.includes(portId)) nextNodes.push(toNodeId);
-            return;
-        }
-        nextNodes.push(toNodeId);
-    });
-    return nextNodes;
-};
+// WorkflowSchema.methods.getNextNode = function ({ currentNode = "", outputPortsOfCurentNode = [] } = {}) {
+//     const nextNodes = [];
+//     if (!currentNode) return [Object.keys(this.nodes).find((ele) => this.nodes[ele].type === "trigger")];
+//     const { type } = this.nodes[currentNode];
+//     Object.values(this.connections).forEach((ele) => {
+//         if (!ele?.from || !ele?.to) {
+//             console.log("errored no from or to");
+//             return;
+//         }
+//         const [fromNodeId, , portId] = ele.from.split("/");
+//         if (fromNodeId !== currentNode) {
+//             return;
+//         }
+//         const [toNodeId] = ele.to.split("/");
+//         if (type === "conditionalNode") {
+//             if (outputPortsOfCurentNode.includes(portId)) nextNodes.push(toNodeId);
+//             return;
+//         }
+//         nextNodes.push(toNodeId);
+//     });
+//     return nextNodes;
+// };
 
 export { WorkflowSchema };
 export const Workflow = defineModel("Workflow", WorkflowSchema, "Workflow");

package/src/models/InbuiltNodes.js

@@ -1,19 +0,0 @@
-import { Schema } from "mongoose";
-import { defineModel } from "../runtime.js";
-const NodeSchema = new Schema(
-    {
-        type: { type: String, required: true, enum: ['trigger', 'task', 'conditional'] },
-        core: {
-            inputMapper: String,
-            inputSchema: Schema.Types.Mixed,
-            outputSchema: Schema.Types.Mixed,
-            configSchema: Schema.Types.Mixed,
-            handlerFunction: { type: String, required: true },
-            errorFunction: { type: String }
-        },
-        meta: { label: String }
-    },
-    { timestamps: true }
-);
-export const NodeModel = defineModel('Node', NodeSchema, 'Nodes');
-export const Node = NodeModel;

package/src/models/Triggers.js

@@ -1,17 +0,0 @@
-import { Schema } from "mongoose";
-import { defineModel } from "../runtime.js";
-
-const TriggerSchema = new Schema({
-    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
-    name: String, // conversationStatusUpdated, leadStatusUpdated, 
-    description: String,
-    type: String, // [open, pending, snoozed, completed, closed, archived, spam] || [new, contacted, qualified, converted, lost]
-    workflows: [{ type: Schema.Types.ObjectId, ref: "Workflow" }],
-}, {
-    timestamps: true,
-});
-
-export { TriggerSchema };
-// No explicit collection name, matching the services: mongoose pluralises this to `triggers`.
-export const Trigger = defineModel('Trigger', TriggerSchema);
-export default Trigger;