@avakado.ai/schemas 1.0.0 → 1.1.0

package/src/models/Integrations.js

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,119 @@
+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,
+    bullMQJobId: String, // bullmq job id    
+    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 },
+        { bullMQJobId: 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/Leads.js

@@ -0,0 +1,84 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+const leadStatusEnum = ["new", "contacted", "qualified", "converted", "lost"];
+const platformEntrySchema = new Schema({
+    platform: { type: String, required: true },   // Phone,'Twitter', 'Instagram', 'Whatsapp', etc.
+    handle: { type: String, trim: true },
+    label: { type: String, trim: true },        // 'work', 'personal', 'brand'
+    isPrimary: { type: Boolean, default: false },
+    metadata: { type: Schema.Types.Mixed, default: {} }
+}, { _id: false });
+const contactDetailsSchema = new Schema({
+    whatsapp: [platformEntrySchema],
+    telegram: [platformEntrySchema],
+    email: [platformEntrySchema],   // multiple emails (work, personal)
+    phone: [platformEntrySchema],
+    twitter: [platformEntrySchema],
+    instagram: [platformEntrySchema],
+    facebook: [platformEntrySchema],
+    // tiktok: [platformEntrySchema],
+    // youtube: [platformEntrySchema],
+    // snapchat: [platformEntrySchema],
+    // pinterest: [platformEntrySchema],
+    // reddit: [platformEntrySchema],
+    // threads: [platformEntrySchema],
+    // bluesky: [platformEntrySchema],
+    // signal: [platformEntrySchema],
+    // wechat: [platformEntrySchema],
+    // line: [platformEntrySchema],
+    // viber: [platformEntrySchema],
+    // discord: [platformEntrySchema],
+    // slack: [platformEntrySchema],
+    // linkedin: [platformEntrySchema],
+    // github: [platformEntrySchema],
+    // behance: [platformEntrySchema],
+    // dribbble: [platformEntrySchema],
+    // medium: [platformEntrySchema],
+    // substack: [platformEntrySchema],
+    // producthunt: [platformEntrySchema]
+}, { _id: false });
+/* ───────────────────────────── Lead ───────────────────────────── */
+const LeadSchema = new Schema({
+    template: { type: Schema.Types.ObjectId, ref: 'LeadTemplate' },
+    business: { type: Schema.Types.ObjectId, ref: 'Businesses', required: true },
+    createdBy: { type: Schema.Types.ObjectId, ref: 'Users' },
+    //identity   
+    name: { type: String, trim: true },
+    contactDetails: { type: contactDetailsSchema, default: () => ({}) },
+    source: String, // Whatsapp-Inbound
+    tags: [String],
+    //evaluation
+    leadScore: { type: Number, default: 0 },
+    status: { type: String, enum: leadStatusEnum, default: 'new' },
+    notes: { type: [String], trim: true },
+    // operations
+    lastInteractedAt: Date,
+    nextFollowUpAt: Date,
+    pendingTasks: Schema.Types.Mixed,
+    data: { type: Schema.Types.Mixed, default: () => ({}) },
+}, { timestamps: true });
+
+/* ───────────────────────────── Lead Template ───────────────────────────── */
+// const leadTemplateFieldTypeEnum = ["string", "number", "email", "phone", "date", "boolean", "url", "text"];
+// const fieldSchema = new Schema({
+//     name: { type: String, required: true, trim: true },
+//     type: { type: String, enum: leadTemplateFieldTypeEnum, required: true },
+//     required: { type: Boolean, default: false },
+//     defaultValue: { type: Schema.Types.Mixed, default: null },
+//     validation: { minLength: Number, maxLength: Number, min: Number, max: Number, pattern: String },
+//     label: { type: String, required: true },
+//     placeholder: { type: String, trim: true },
+//     description: { type: String, trim: true }
+// }, { _id: false });
+
+const LeadTemplateSchema = new Schema({
+    business: { type: Schema.Types.ObjectId, ref: 'Businesses', required: true },
+    createdBy: { type: Schema.Types.ObjectId, ref: 'Users', required: true },
+    name: { type: String, required: true, trim: true, unique: true },
+    description: { type: String, trim: true },
+    fields: Schema.Types.Mixed,
+    isActive: { type: Boolean, default: true }
+}, { timestamps: true });
+
+export const Lead = defineModel('Lead', LeadSchema, 'Leads');
+export const LeadTemplate = defineModel('LeadTemplate', LeadTemplateSchema, 'LeadTemplates');

package/src/models/Log.js

@@ -0,0 +1,32 @@
+// mongodb schema for all types of logs
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+const LogSchema = new Schema({
+    user: { type: Schema.Types.ObjectId, ref: 'User' },
+    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
+    level: { type: String, enum: ['warn', 'error', 'info', 'debug'] },
+    event: { type: String },
+    category: { type: String, enum: ['AUTHENTICATION', 'PAYMENT', 'CREDIT', 'SUBSCRIPTION', 'API_ACCESS', 'WEBHOOK', 'ERROR', 'OTHER',] },
+    status: { type: String, enum: ['SUCCESS', 'FAILURE', 'PENDING'], default: 'SUCCESS', },
+    message: String,
+    service: { type: String }, // Identifies which microservice or backend component produced the log
+    environment: { type: String, enum: ['dev', 'staging', 'prod'] },
+    requestId: String,
+    meta: Schema.Types.Mixed, // ipAddress, userAgent, etc.
+    data: Schema.Types.Mixed,
+    error: Schema.Types.Mixed,
+    response: Schema.Types.Mixed,
+}, {
+    timestamps: true
+});
+// add index to the log schema
+LogSchema.index({ user: 1, createdAt: -1 });
+LogSchema.index({ event: 1, createdAt: -1 });
+LogSchema.index({ category: 1, createdAt: -1 });
+LogSchema.index({ status: 1, createdAt: -1 });
+LogSchema.index({ service: 1, createdAt: -1 });
+LogSchema.index({ environment: 1, createdAt: -1 });
+LogSchema.index({ requestId: 1, createdAt: -1 });
+LogSchema.index({ createdAt: 1 }, { expireAfterSeconds: 60 * 60 * 24 * 30 }); // 30 days
+LogSchema.index({ 'data.platformMessageId': 1 }, { unique: true, sparse: true });
+export const Log = defineModel('Log', LogSchema, 'Logs');

package/src/models/Messages.js

@@ -0,0 +1,46 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+const MessageSessionSchema = new Schema({
+    campaign: { type: Schema.Types.ObjectId, ref: 'Campaign' },
+    firstMessage: { type: Schema.Types.ObjectId, ref: 'Message' },
+    lastMessage: { type: Schema.Types.ObjectId, ref: 'Message' },
+    conversation: { type: Schema.Types.ObjectId, ref: 'Conversation' },
+    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
+})
+const MessagesSchema = new Schema({
+    conversation: { type: Schema.Types.ObjectId, ref: 'Conversation' },
+    campaign: { type: Schema.Types.ObjectId, ref: 'Campaign' },
+    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
+    externalMessageId: String,
+    direction: String,
+    sender: {
+        type: { type: String, enum: ["Lead", "agent", "user", "system", "unknown"], default: "Lead" },
+        id: String,
+        name: String,
+        ref: { type: Schema.Types.ObjectId, refPath: "sender.refModel" },
+        refModel: { type: String, enum: ["Lead", "Agent", "Users"] },
+    },
+    type: {
+        type: String,
+        enum: ["text", "image", "audio", "voice", "video", "document", "file", "sticker",
+            "location", "contacts", "interactive", "button", "order", "unknown", "template"],
+        default: "text",
+    },
+    kind: { type: String, enum: ["message", "postback", "system"], default: "message" },
+    content: { type: Schema.Types.Mixed, default: {} }, // { body } | location | interactive | …
+    repliedTo: { type: Schema.Types.ObjectId, ref: "Message" },
+    reactions: { type: [{ emoji: String, by: String, at: Date }], default: [], _id: false },
+    statusTimeline: {
+        scheduled: Date, initiated: Date, sent: Date, delivered: Date, read: Date, failed: Date, stopped: Date
+    },
+    usage: { type: Schema.Types.Mixed, default: {} },
+    misc: { type: Schema.Types.Mixed, default: {} },
+    errors: [{ type: Schema.Types.Mixed, default: [] }],
+    isInternalNote: { type: Boolean, default: false },
+    isSummarized: { type: Boolean, default: false },
+    // readByContact: { type: Boolean, default: We false }
+}, {
+    timestamps: true
+});
+export const Message = defineModel('Message', MessagesSchema, "Messages");
+export const MessageSession = defineModel('MessageSession', MessageSessionSchema, "MessageSessions");

package/src/models/Plans.js

@@ -0,0 +1,37 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+// const CreditSchema = new Schema(
+//     {
+//         llm: { type: , min: 0, default: 0 },
+//         knowledge: { type: Number, min: 0, default: 0 },
+//         miscellaneous: { type: Number, min: 0, default: 0 },
+//     },
+//     { _id: false }
+// );
+const AmountSchema = new Schema({
+    value: { type: Number, required: true }, // eg: 22000
+    currency: { type: String, default: "INR" }
+}, { _id: false });
+const PlanSchema = new Schema({
+    business: { type: Schema.Types.ObjectId, ref: "Businesses" },
+    code: { type: String, unique: true }, // ['FREE', 'BASE', 'GROWTH', 'BASE_TOPUP', 'GROWTH_TOPUP'],
+    public: { type: Boolean, default: false },
+    name: { type: String, required: true },
+    description: String,
+    amount: AmountSchema,
+    type: { type: String, enum: ['FREE', 'BASE', 'TOPUP', 'ENTERPRISE', 'TEST'], required: true, index: true, },
+    validity: { type: Number, default: 30 },// in days
+    credits: Number,
+    spendRatio: { type: Number, enum: [1080, 1666, 1583], default: 1583 },
+    status: { type: String, enum: ['active', 'inactive'], default: 'active' },
+    features: [String],
+    allowedTopUps: [{ type: Schema.Types.ObjectId, ref: 'Plans' }],
+    autoRenew: { type: Boolean, default: false },
+    paymentGateWay: {
+        razorpay: {
+            plan_id: String,
+        }
+    },
+}, { timestamps: true });
+export const Plan = defineModel('Plans', PlanSchema, "Plans");
+

package/src/models/Tickets.js

@@ -0,0 +1,50 @@
+import { Schema, Types } from "mongoose";
+import { defineModel } from "../runtime.js";
+import { Notification } from "./notifications.js";
+
+const TicketSchema = new Schema(
+    {
+        business: { type: Types.ObjectId, ref: 'Businesses' },
+        issueSummary: { type: String, required: true },
+        channel: { type: String, enum: ['telegram', 'whatsapp', 'web', 'phone', 'instagram', 'sms', 'email'], required: true, },
+        priority: { type: String, enum: ['low', 'medium', 'high'], default: 'medium', },
+        status: { type: String, enum: ['pending', 'responded', 'resolved'], default: 'pending' },
+        contactDetails: {
+            email: { type: String },
+            phone: { type: String },
+            telegramId: { type: String },
+            whatsappId: { type: String },
+            instagramId: { type: String },
+        },
+        notifierEmail: { type: String, required: true },
+        response: {
+            channelId: { type: Schema.Types.ObjectId, ref: "Channel" },
+            from: { type: String },
+            to: { type: String },
+            cc: { type: String },
+            subject: { type: String },
+            bcc: { type: String },
+            text: { type: String },
+            html: { type: String },
+            updatedAt: { type: Date },
+            sentAt: { type: Date },
+            resolvedAt: { type: Date },
+        },
+    },
+    { timestamps: true }
+);
+TicketSchema.methods.markSent = function (response) {
+    this.status = 'responded';
+    this.response = response;
+    return this.save();
+};
+TicketSchema.methods.markResolved = function () {
+    this.status = 'resolved';
+    this.response.resolvedAt = new Date();
+    return this.save();
+};
+// on ticket creation, create a notification
+TicketSchema.post('save', async function (doc) {
+    if (this.isNew) await Notification.create({ business: doc.business, head: `${doc.priority} Priority Ticket Created on ${doc.channel}`, body: doc.issueSummary, type: "ticket", attachments: { ticketId: doc._id } });
+});
+export const Ticket = defineModel('Ticket', TicketSchema, 'Ticket');