@avakado.ai/schemas 1.1.4 → 1.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avakado.ai/schemas",
-  "version": "1.1.4",
+  "version": "1.1.7",
   "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/index.js

@@ -4,7 +4,7 @@ export { Subscription, SubscriptionSchema } from "./Subscriptions.js";
 export { UsageLog, UsageLogSchema } from "./UsageLogs.js";
 export { Conversation, ConversationSchema } from "./Conversations.js";
 export { Campaign, CampaignSchema, Task, TaskSchema } from "./Campaign.js";
-export { Trigger, TriggerSchema } from "./Triggers.js";
+export { TriggerTemplate } from "./TriggersTemplate.js";
 export { User, ScopesEnum, RoleScopes } from "./User.js";
 export { AgentModel } from "./Agent.js";
 export { Channel, ChannelCapabilityDefaults } from "./Channels.js";
@@ -20,13 +20,10 @@ export { ApiAuthenticators, ApiAuthenticationSchema } from "./apiAuthenticator.j
 export { DemonstrationModel } from "./Demonstarations.js";
 export { Action } from "./Action.js";
 export { Collection } from "./Collection.js";
-export { Node, NodeModel } from "./InbuiltNodes.js";
-export { Integration } from "./Integrations.js";
-export { Job } from "./Job.js";
 export { Notification } from "./notifications.js";
 export { Ticket } from "./Tickets.js";
 export { Document } from "./Document.js";
 export { Data } from "./Data.js";
-export { Workflow, WorkflowSchema } from "./Workflow.js";
+export { Workflow } from "./Workflow.js";
 export { WorkflowLogs } from "./WorkflowLogs.js";
 export { OAuthClient, OAuthAuthorizationCode, OAuthRefreshToken, OAuthRevokedJti } from "./OAuth.js";

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/Integrations.js

@@ -1,36 +0,0 @@
-import { Schema } from "mongoose";
-import { defineModel } from "../runtime.js";
-
-const IntegrationSchema = new Schema({
-    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
-    metaData: {
-        name: String,
-        description: String,
-        icon: String,
-        color: String,
-        purpose: Schema.Types.Mixed,
-        type: { type: String, enum: ['zoho', 'twilio', 'exotel','tataTele','whatsapp'], required: true },
-    },
-    secrets: {
-        tokenType: String,
-        accessToken: String,
-        refreshToken: String,
-        apiKey: String,
-        apiToken: String,
-    },
-    config: {
-        AccountSid: String,
-        state: String,
-        apiDomainUrl: String,
-        domain: String,
-        scope: String,
-        expiresAt: Date,
-        region:String
-    },
-    accountDetails: Schema.Types.Mixed,
-    isActive: { type: Boolean, default: true },
-    createdBy: { type: Schema.Types.ObjectId, ref: 'Users' },
-}, {
-    timestamps: true
-});
-export const Integration = defineModel('Integration', IntegrationSchema, "Integration");

package/src/models/Job.js

@@ -1,117 +0,0 @@
-import { Schema } from "mongoose";
-import { defineModel } from "../runtime.js";
-const jobStatusEnum = ["scheduled", "active", "completed", "failed", "canceled", "delayed", "waiting", "stalled"];
-const backoff = new Schema({
-    type: { type: String, enum: ["exponential", "fixed"], required: true },
-    delay_ms: { type: Number, required: true },
-    attempts: { max: Number, made: Number, reason: String },
-}, { _id: false })
-
-const logEntry = new Schema({
-    level: { type: String, enum: ["info", "warn", "error", "debug"], required: true },
-    message: String,
-    timestamp: { type: Date, default: Date.now },
-    data: Schema.Types.Mixed
-}, { _id: false });
-/* ───────────────────────────── Base Job ───────────────────────────── */
-const JobSchema = new Schema({
-    name: String,
-    campaign: { type: Schema.Types.ObjectId, ref: "Campaign" },
-    description: String,
-    status: { type: String, enum: jobStatusEnum, default: 'waiting' },
-    priority: Number,               // 1 (highest) .. 10 (lowest)
-    schedule: {
-        type: { type: String, enum: ["once", "cron"], default: "once" },
-        run_at: Date,                 // for one-off
-        cron: String,                 // for recurring
-        timezone: String,
-        backoff: { type: backoff, default: undefined },
-        cancel_requested: { type: Boolean, default: false },
-    },
-    jobType: { type: String, enum: ["outboundCall"], default: "outboundCall" },
-    result_ref: Schema.Types.Mixed,
-    error_ref: Schema.Types.Mixed,
-    log: [logEntry],
-    tags: [String],
-    createdBy: { type: Schema.Types.ObjectId, ref: 'Users' },
-    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
-}, {
-    discriminatorKey: 'jobType', timestamps: true, index: [
-        { status: 1, 'schedule.run_at': 1 },
-        { business: 1, status: 1 },
-        { 'schedule.type': 1, 'schedule.run_at': 1 }
-    ]
-});
-// Pre-save middleware for validation
-JobSchema.pre('save', function (next) {
-    // Validate schedule based on type
-    if (this.schedule.type === 'once' && !this.schedule.run_at) {
-        return next(new Error('run_at is required for one-time jobs'));
-    }
-
-    if (this.schedule.type === 'cron' && !this.schedule.cron) {
-        return next(new Error('cron expression is required for recurring jobs'));
-    }
-
-    // Validate priority
-    if (this.priority < 1 || this.priority > 10) {
-        return next(new Error('Priority must be between 1 and 10'));
-    }
-
-    next();
-});
-
-// Instance methods
-JobSchema.methods.addLog = function (level, message, data = {}) {
-    this.log.push({
-        level,
-        message,
-        data,
-        timestamp: new Date()
-    });
-    return this.save();
-};
-JobSchema.methods.markAsStarted = function () {
-    this.status = 'active';
-    this.lastExecutedAt = new Date();
-    this.executionCount += 1;
-    return this.save();
-};
-
-JobSchema.methods.markAsCompleted = function (result = null, duration = null) {
-    this.status = 'completed';
-    this.result_ref = result;
-    if (duration) this.actualDuration = duration;
-    return this.save();
-};
-
-JobSchema.methods.markAsFailed = function (error, duration = null) {
-    this.status = 'failed';
-    this.error_ref = {
-        message: error.message,
-        stack: error.stack,
-        timestamp: new Date()
-    };
-    if (duration) this.actualDuration = duration;
-    return this.save();
-};
-
-// if schedule is updated then trigger sync
-
-// channelId, to, agentId, PreContext 
-
-export const Job = defineModel('Job', JobSchema, 'Job');
-const outboundCallPayload = new Schema({
-    channel: { type: Schema.Types.ObjectId, ref: "Channel" },
-    agent: { type: Schema.Types.ObjectId, ref: "Agent" },
-    to: { type: String, required: true },
-    accessToken: { type: String, required: true },
-    PreContext: String,
-    expectedDuration: Number,
-    maxRetries: { type: Number, default: 3 },
-    callbackUrl: String,
-    cps: Number,
-    conversationId: { type: Schema.Types.ObjectId, ref: 'conversation' }
-}, { _id: false })
-/* ───────────────────────────── Outbound Call Job ──────────────────────────── */
-Job.discriminator('outboundCall', new Schema({ payload: outboundCallPayload }, { timestamps: true, discriminatorKey: 'jobType' }));

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;