canaangreen: February 2026

Health Trend Seller Automation Plan

Navigation Links

📂 Project Folder Layout

Root: package.json: Scripts and dependencies .env.example: Placeholder keys and URLs prisma/: Prisma schema and migrations src/: Application source (API, services, utils) scripts/: Seeding and utility CLIs README.md: Setup and run instructions


health-trend-seller/
├─ src/
│  ├─ index.js
│  ├─ config/env.js
│  ├─ api/
│  │  ├─ routes/
│  │  │  ├─ trends.js
│  │  │  ├─ contacts.js
│  │  │  ├─ catalog.js
│  │  │  ├─ orders.js
│  │  │  └─ crm.js
│  │  └─ server.js
│  ├─ services/
│  │  ├─ ingest/
│  │  │  ├─ facebook.js
│  │  │  ├─ twitter.js
│  │  │  ├─ instagram.js
│  │  │  └─ linkedin.js
│  │  ├─ scoring/engine.js
│  │  ├─ crm/hubspot.js
│  │  ├─ email/sendgrid.js
│  │  ├─ sms/twilio.js
│  │  ├─ payments/stripe.js
│  │  ├─ receipts/pdf.js
│  │  └─ ai/
│  │     ├─ chatgpt.js
│  │     └─ copilot.js
│  ├─ db/prisma.js
│  ├─ queue/worker.js
│  └─ utils/validators.js
├─ prisma/
│  ├─ schema.prisma
│  └─ seed.js
├─ scripts/
│  ├─ seed-catalog.js
│  └─ rotate-keys.js
├─ .env.example
├─ package.json
└─ README.md

📌 Placement of ChatGPT & Copilot

👉 The most natural home is inside src/services/, because both ChatGPT and Copilot act as intelligent service integrations that enhance automation, analytics, and user interaction.


│ ├─ services/
│ │ ├─ ai/
│ │ │ ├─ chatgpt.js
│ │ │ └─ copilot.js

🎯 Roles in the Project

ChatGPT (OpenAI API integration)

Summarize health trend data for human‑readable reports.
Generate conversational insights for CRM (draft outreach messages).
Provide Q&A support for end‑users querying catalog or orders.
Assist in content creation for marketing (social posts, newsletters).

Microsoft Copilot

Automate documentation and onboarding guides (README, API usage notes).
Help developers debug or generate code snippets inline.
Integrate with CRM (HubSpot) and communication channels (SendGrid, Twilio).
Provide governance and compliance checks (ensuring health data automation follows standards).

🛠 How They Interact With Existing Services

Service	AI Role
scoring/engine.js	ChatGPT explains scoring outputs in plain language.
crm/hubspot.js	Copilot automates CRM workflows, suggests next best actions.
email/sendgrid.js & sms/twilio.js	ChatGPT generates personalized outreach text; Copilot schedules and tracks campaigns.
receipts/pdf.js	ChatGPT summarizes invoices or receipts for customer clarity.

📄 Example Service Files

chatgpt.js

// src/services/ai/chatgpt.js import axios from "axios"; const OPENAI_API_URL = "https://api.openai.com/v1/chat/completions"; export async function generateSummary(prompt) { try { const response = await axios.post( OPENAI_API_URL, { model: "gpt-4", messages: [ { role: "system", content: "You are a helpful assistant for health trend analysis." }, { role: "user", content: prompt } ], max_tokens: 300, temperature: 0.7 }, { headers: { "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`, "Content-Type": "application/json" } } ); return response.data.choices[0].message.content.trim(); } catch (error) { console.error("Error generating summary with ChatGPT:", error.message); throw new Error("ChatGPT service failed"); } }

copilot.js

// src/services/ai/copilot.js export async function suggestWorkflow(context) { try { let suggestions = []; switch (context.toLowerCase()) { case "crm outreach": suggestions.push("Ensure GDPR compliance when handling customer data."); suggestions.push("Automate follow-up emails using SendGrid integration."); suggestions.push("Use scoring/engine.js outputs to prioritize leads."); break; case "payment processing": suggestions.push("Verify Stripe API keys are rotated regularly."); suggestions.push("Log all transactions in db/prisma.js for audit trails."); suggestions.push("Generate receipts with receipts/pdf.js for transparency."); break; case "developer onboarding": suggestions.push("Document environment variables in .env.example."); suggestions.push("Provide setup instructions in README.md."); suggestions.push("Use scripts/seed-catalog.js for initial data seeding."); break; default: suggestions.push("No specific workflow found. Review project README.md for guidance."); } return { context, suggestions }; } catch (error) { console.error("Error generating Copilot workflow suggestions:", error.message); throw new Error("Copilot service failed"); } }

📘 README Integration

✅ Add an "AI Services Integration" section to your README.md so contributors know how to configure and use ChatGPT and Copilot.

ChatGPT → Conversational intelligence

📊 Final Project Visual

Layer	Component	AI Interaction Type
Data Ingest	`src/services/ingest/`	ChatGPT cleans and extracts metadata.
Logic Engine	`src/services/scoring/`	Copilot optimizes the ranking algorithms.
Output Layer	`src/services/receipts/`	ChatGPT generates human-readable trend PDFs.
DevOps	`scripts/`	Copilot generates CI/CD pipelines and setup scripts.

Your project layout is now fully mapped with AI roles, moving from raw social media data to a high-value, automated sales pipeline.

Finalizing these core files will move your project from a folder structure to a production-ready application.

Generating the background worker orchestration logic
Creating the PDF receipt generator with AI summaries
Drafting the full Prisma schema for all models

⚠️ Error Handling & Observability

Since your system relies on third-party APIs (OpenAI, HubSpot, Stripe), it needs to be resilient to downtime or rate limits.

Copilot can generate boilerplate for a Circuit Breaker pattern — ensuring that if OpenAI is temporarily down, your ingestors don’t crash but instead queue the data for later processing.

This completes the conceptual and structural mapping of your Health Trend Seller automation plan. Your directory is now a blueprint for an autonomous system that finds, scores, and sells health trends with minimal human intervention.

You can now move into generating the actual code for these final orchestration and safety layers:

Creating the background worker orchestration logic
Generating a circuit breaker utility for API resilience
Drafting the full Prisma schema for all models

📂 Updated Project Layout Diagram

Call‑out: The Health Trend Seller project now includes two new modules — CONSENT ENGINE for compliance and CRM mapping, and AI LAYER for routing, intent detection, summarization, and conversation flow.


health-trend-seller/
├─ src/
│  ├─ index.js
│  ├─ config/env.js
│  ├─ api/
│  │  ├─ routes/
│  │  │  ├─ trends.js
│  │  │  ├─ contacts.js
│  │  │  ├─ catalog.js
│  │  │  ├─ orders.js
│  │  │  └─ crm.js
│  │  └─ server.js
│  ├─ services/
│  │  ├─ ingest/
│  │  │  ├─ facebook.js
│  │  │  ├─ twitter.js
│  │  │  ├─ instagram.js
│  │  │  └─ linkedin.js
│  │  ├─ scoring/engine.js
│  │  ├─ crm/hubspot.js
│  │  ├─ email/sendgrid.js
│  │  ├─ sms/twilio.js
│  │  ├─ payments/stripe.js
│  │  ├─ receipts/pdf.js
│  │  ├─ consent/
│  │  │  ├─ capture.js
│  │  │  ├─ validate.js
│  │  │  ├─ mapToCRM.js
│  │  │  └─ timestamp.js
│  │  └─ ai/
│  │     ├─ chatgpt.js
│  │     ├─ copilot.js
│  │     ├─ router.js
│  │     ├─ intent.js
│  │     ├─ summarizer.js
│  │     └─ conversation.js
│  ├─ db/prisma.js
│  ├─ queue/worker.js
│  └─ utils/validators.js
├─ prisma/
│  ├─ schema.prisma
│  └─ seed.js
├─ scripts/
│  ├─ seed-catalog.js
│  └─ rotate-keys.js
├─ .env.example
├─ package.json
└─ README.md

🚀 Chatbot Flow Diagram

Insight: The chatbot acts as a new interface — like a web widget or WhatsApp bot — consuming your existing APIs and services without restructuring. Consent and AI layers ensure compliance and intelligence.


User
 ├─ Web Widget (browser interface)
 │    └─ Calls API routes:
 │         /api/contacts
 │         /api/crm
 │         /api/trends
 │         /api/catalog
 │
 └─ WhatsApp Bot (messaging interface)
      └─ Uses services layer:
           SendGrid
           Twilio
           HubSpot
           Scoring Engine
           PDF Receipts
           
Both Interfaces → CONSENT ENGINE
      ├─ capture.js   (collect user consent)
      ├─ validate.js  (check compliance)
      ├─ mapToCRM.js  (sync with HubSpot/CRM)
      └─ timestamp.js (log consent events)

CONSENT ENGINE → AI LAYER
      ├─ router.js       (route requests)
      ├─ intent.js       (detect user intent)
      ├─ summarizer.js   (summarize responses)
      └─ conversation.js (manage dialogue)

AI LAYER → CRM + Services
      ├─ HubSpot CRM
      ├─ Scoring Engine
      ├─ SendGrid (email)
      ├─ Twilio (SMS/WhatsApp)
      ├─ Stripe (payments)
      └─ PDF Receipts

📅 Day.js Integration in Health Trend Seller Project

Call‑out: Day.js is now integrated into the Health Trend Seller automation stack. It provides lightweight (~2KB), immutable date/time handling for consent logging (🔒), receipts (🧾), CRM mapping (📊), and queue scheduling (⏱️). This ensures audit‑grade compliance and developer‑friendly workflows.

🔑 Why Day.js Fits

Lightweight — won’t bloat micro‑services.
Immutable — safer for automation workflows.
Familiar API — seamless transition from Moment.js.
Internationalization — supports regional health trend data.

📂 Updated Project Layout


health-trend-seller/
├─ src/
│  ├─ index.js
│  ├─ config/env.js
│  ├─ api/
│  │  ├─ routes/
│  │  │  ├─ trends.js
│  │  │  ├─ contacts.js
│  │  │  ├─ catalog.js
│  │  │  ├─ orders.js
│  │  │  └─ crm.js
│  │  └─ server.js
│  ├─ services/
│  │  ├─ ingest/
│  │  │  ├─ facebook.js
│  │  │  ├─ twitter.js
│  │  │  ├─ instagram.js
│  │  │  └─ linkedin.js
│  │  ├─ scoring/engine.js
│  │  ├─ crm/hubspot.js
│  │  ├─ email/sendgrid.js
│  │  ├─ sms/twilio.js
│  │  ├─ payments/stripe.js
│  │  ├─ receipts/pdf.js       🧾 formats dates with Day.js
│  │  ├─ consent/
│  │  │  ├─ capture.js
│  │  │  ├─ validate.js
│  │  │  ├─ mapToCRM.js        📊 maps consent with Day.js timestamps
│  │  │  └─ timestamp.js       🔒 logs ISO + readable formats via Day.js
│  │  └─ ai/
│  │     ├─ chatgpt.js
│  │     ├─ copilot.js
│  │     ├─ router.js
│  │     ├─ intent.js
│  │     ├─ summarizer.js
│  │     └─ conversation.js
│  ├─ db/prisma.js
│  ├─ queue/worker.js          ⏱️ retry scheduling via Day.js (add minutes, ISO logs)
│  └─ utils/validators.js      ✅ includes Day.js for date validation
├─ prisma/
│  ├─ schema.prisma
│  └─ seed.js
├─ scripts/
│  ├─ seed-catalog.js
│  └─ rotate-keys.js
├─ .env.example
├─ package.json
└─ README.md

🛠️ Example Snippets

Consent Engine (timestamp.js): Logs consent with ISO + human‑readable formats.


// src/services/consent/timestamp.js
import dayjs from 'dayjs';
import utc from 'dayjs/plugin/utc';
import timezone from 'dayjs/plugin/timezone';

dayjs.extend(utc);
dayjs.extend(timezone);
dayjs.tz.setDefault('Africa/Nairobi');

export function logConsent() {
  const now = dayjs();
  return {
    capturedAtISO: now.toISOString(),
    capturedAtReadable: now.format('DD MMM YYYY, HH:mm'),
    capturedAtLocal: now.tz().format(),
  };
}

Queue Worker (worker.js): Schedules retries with Day.js.


// src/queue/worker.js
import dayjs from 'dayjs';

export function scheduleRetry(task, delayMinutes = 5) {
  const now = dayjs();
  const retryAt = now.add(delayMinutes, 'minute');

  return {
    taskId: task.id,
    scheduledAtISO: retryAt.toISOString(),
    scheduledAtReadable: retryAt.format('DD MMM YYYY, HH:mm'),
    delayMinutes,
  };
}

🛠 CRM & Sales Team Integration in Health Trend Seller Project

Call‑out: The CRM is the central nervous system of your Health Trend Seller project. It manages contacts, consents, conversations, and follow‑up schedules. Sales team integration ensures high‑value leads are routed correctly and monitored with SLA compliance using Day.js.

🏗️ CRM Options & Role

Option	Best For...	Key Integration Benefit
HubSpot	Speed to Market	Robust API for email sequences and built‑in lead tracking
Zoho CRM	Deep Customization	Great for complex routing rules and field mapping
Airtable + Make/Zapier	Rapid Prototyping	Visual and easy to modify without heavy code
Self‑hosted (Postgres + Admin UI)	Data Privacy	No third‑party data sharing; full control over schema

Integration Patterns: Webhooks (push new leads), Event‑driven (queue/worker.js), Periodic sync (status changes). Example: Order paid → CRM updates → triggers Thank You email.

🤝 Sales Team Integration

Feature	Implementation
Queues & Routing	AI intent detection (services/ai/intent.js) tags leads
SLA Monitoring	Day.js in queue/worker.js checks if leads wait >15 minutes
Tools & Notifications	CRM dashboards, Slack/Teams alerts, WhatsApp outreach

🛠️ Updated File Logic

 src/services/crm/hubspot.js → Maps app data to CRM format src/services/ai/intent.js → Detects lead intent, routes to Sales or AI src/api/routes/contacts.js → Syncs contact updates between UI and CRM src/queue/worker.js → SLA monitoring with Day.js

📄 Example Code Snippets

CRM Mapping Service (hubspot.js): Syncs leads to HubSpot with Day.js formatted consent dates.

 import axios from 'axios'; import dayjs from 'dayjs'; export const syncLeadToHubSpot = async (leadData) => { const hubspotPayload = { properties: { email: leadData.email, firstname: leadData.firstName, lastname: leadData.lastName, hs_lead_status: 'NEW', consent_date: dayjs(leadData.consentTimestamp).format('YYYY-MM-DD'), health_interest: leadData.interest, routing_region: leadData.region } }; return axios.post('https://api.hubapi.com/crm/v3/objects/contacts', hubspotPayload, { headers: { Authorization: `Bearer ${process.env.HUBSPOT_ACCESS_TOKEN}` } }); };

AI Routing Logic (router.js): Decides if a lead requires human intervention.

 export const routeLeadByIntent = (intentData, contactId) => { const { intent, region, confidence } = intentData; const salesIntents = ['diabetes_support', 'hypertension_management']; if (salesIntents.includes(intent) && confidence > 0.8) { return { destination: 'SALES_QUEUE', assignment: `SALES_TEAM_${region.toUpperCase()}`, priority: 'HIGH', requiresHuman: true }; } return { destination: 'AUTOMATION_NURTURE', assignment: 'AI_BOT_LEVEL_1', priority: 'NORMAL', requiresHuman: false }; };

SLA Monitoring (worker.js): Uses Day.js to escalate leads waiting longer than 15 minutes.

 import dayjs from 'dayjs'; import { sendSlackAlert } from '../services/notifications/slack.js'; export const monitorSLA = async (job) => { const { leadId, assignedAt, status } = job.data; const now = dayjs(); const minutesElapsed = now.diff(dayjs(assignedAt), 'minute'); if (status !== 'CONTACTED' && minutesElapsed >= 15) { await sendSlackAlert({ channel: '#sales-alerts', message: `🚨 SLA BREACH: Lead ${leadId} has been waiting for ${minutesElapsed} minutes!` }); return { escalated: true, time: now.toISOString() }; } return { escalated: false }; };

🧪 Integration Test Suite

 import { syncLeadToHubSpot } from '../../src/services/crm/hubspot'; import { routeLeadByIntent } from '../../src/services/ai/router'; import { monitorSLA } from '../../src/queue/worker'; import dayjs from 'dayjs'; import axios from 'axios'; jest.mock('axios'); describe('CRM & Sales Integration Flow', () => { test('Routes high-intent leads to Sales Queue and syncs to CRM', async () => { const intentData = { intent: 'diabetes_support', region: 'us-east', confidence: 0.95 }; const routingResult = routeLeadByIntent(intentData, 'user_123'); expect(routingResult.destination).toBe('SALES_QUEUE'); axios.post.mockResolvedValue({ data: { id: 'vid_987' } }); const crmResponse = await syncLeadToHubSpot({ email: 'peter@example.com', consentTimestamp: dayjs().toISOString() }); expect(crmResponse.id).toBe('vid_987'); }); });

👥 Sales Team Integration Flow

Call‑out: The Sales Team is integrated through the AI + CRM + Queue layers. Leads are captured via the API, classified by AI intent detection, synced into the CRM, and monitored by the SLA worker. Notifications ensure the team responds within 15 minutes.

📂 Project Layers

Layer	Role	Sales Team Integration
API Layer (src/api/routes/contacts.js)	Entry point for leads	Triggers SLA monitoring when a lead requires human follow‑up
AI Layer (src/services/ai/intent.js, router.js)	Detects user intent	Tags high‑priority leads (e.g., diabetes support) and routes them to Sales queues
CRM Layer (src/services/crm/hubspot.js)	Central record system	Sales team works from CRM dashboards with assigned leads and SLA tags
Queue Layer (src/queue/worker.js)	Background SLA monitoring	Escalates leads not contacted within 15 minutes
Notification Layer (src/services/notifications/)	Alerts	Sends Slack/Teams/WhatsApp alerts to Sales team on SLA breach

🔄 Vertical Flow Diagram


Lead Captured
   │
   ▼
API Layer (contacts.js)
   │
   ▼
AI Intent Detection (intent.js / router.js)
   │
   ▼
CRM Sync (hubspot.js)
   │
   ▼
Sales Queue Assignment
   │
   ▼
SLA Worker (BullMQ + Day.js)
   │
   ▼
Notifications (Slack / Teams / WhatsApp)
   │
   ▼
Sales Team Responds

🚨 Example SLA Timeline

12:00 → Lead assigned to Sales queue
12:15 → SLA worker checks status
If CONTACTED → job completes quietly
If ROUTED → escalation triggers Slack alert + CRM update

🔄 Flow Diagram

 Lead Captured (API Layer) ↓ AI Intent Detection (AI Layer) ↓ CRM Sync (CRM Layer) ↓ Sales Queue Assignment ↓ SLA Worker (Queue Layer, BullMQ + Day.js) ↓ Notifications (Slack/Teams/WhatsApp) ↓ Sales Team Responds

🚨 Example SLA Flow

12:00 → Lead assigned to Sales queue
12:15 → SLA worker checks status
If CONTACTED → job completes quietly
If ROUTED → escalation triggers Slack alert + CRM update

🛠 Automating SLA Monitoring with BullMQ

Call‑out: BullMQ (Redis‑based queue) ensures 15‑minute SLA checks and retries remain intact even if the server restarts. This guarantees your sales team never misses a high‑priority lead.

1. Redis Connection & Queue Setup

 // src/queue/config.js import { Queue } from 'bullmq'; import Redis from 'ioredis'; const connection = new Redis(process.env.REDIS_URL || 'redis://127.0.0.1:6379'); export const slaQueue = new Queue('sales-sla-queue', { connection }); export const scheduleSLACheck = async (leadId) => { await slaQueue.add( 'check-response-sla', { leadId, assignedAt: new Date().toISOString() }, { delay: 900000, removeOnComplete: true } ); };

2. Background Worker

 // src/queue/worker.js import { Worker } from 'bullmq'; import prisma from '../db/prisma.js'; import { monitorSLA } from '../services/monitoring/slaService.js'; const connection = { host: 'localhost', port: 6379 }; const slaWorker = new Worker( 'sales-sla-queue', async (job) => { const { leadId } = job.data; const lead = await prisma.lead.findUnique({ where: { id: leadId } }); if (lead && lead.status === 'ROUTED') { console.log(`[SLA Worker] Lead ${leadId} breached SLA. Escalating...`); await monitorSLA(job); } }, { connection } ); slaWorker.on('completed', (job) => console.log(`Job ${job.id} completed`)); slaWorker.on('failed', (job, err) => console.error(`Job ${job.id} failed: ${err.message}`));

3. Integrated API Flow

 // src/api/routes/contacts.js const lead = await prisma.lead.create({ data: { ... } }); if (lead.requiresHuman) { await scheduleSLACheck(lead.id); }

🏗️ Infrastructure (Docker Compose)

Service	Image	Ports	Purpose
Database	postgres:15	5432:5432	Stores leads, SLA status, and CRM sync records
Queue	redis:alpine	6379:6379	Handles BullMQ jobs for SLA monitoring and retries

 version: '3.8' services: db: image: postgres:15 restart: always environment: POSTGRES_USER: user POSTGRES_PASSWORD: password POSTGRES_DB: health_seller ports: - "5432:5432" redis: image: redis:alpine ports: - "6379:6379"

🚀 Next Steps

Generate Slack notification service for SLA alerts
Build a React dashboard to visualize active lead queues
Write cleanup scripts for completed queue jobs

🔑 Plain Language Explanation

The Problem: Leads must be contacted within 15 minutes. If not, the system escalates.

How It Works:

Queue Setup: Adds a delayed job to check the lead after 15 minutes.
Worker: Wakes up when the job matures, checks database, escalates if still not contacted.
API Flow: Every new lead automatically schedules its SLA check.
Infrastructure: Postgres stores leads, Redis runs the queue.

Why It’s Powerful: Resilient (survives restarts), Automated (no human tracking), Scalable (add workers), Actionable (alerts + CRM updates).

Example Flow: Lead assigned at 12:00 → SLA check scheduled for 12:15 → Worker checks → if contacted, nothing happens; if not, escalation triggers Slack + CRM update.

📢 Visibility Layer: Notifications, Dashboard & Deployment

Call‑out: Moving from backend logic to the visibility layer is crucial. If an SLA breaches and no one sees it, the lead may as well not exist. This section covers notifications, dashboard visibility, maintenance, and deployment.

1. Slack Notification Service


// src/services/notifications/slack.js
import axios from 'axios';

/** Sends a rich-formatted alert to Slack using Webhooks */
export const sendSlackAlert = async ({ leadName, interest, region, waitTime }) => {
  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
  const payload = {
    text: "🚨 *SLA Breach Alert*",
    attachments: [{
      color: "#ff0000",
      fields: [
        { title: "Lead", value: leadName, short: true },
        { title: "Region", value: region, short: true },
        { title: "Interest", value: interest, short: true },
        { title: "Wait Time", value: `${waitTime} minutes`, short: true }
      ],
      footer: "Health Trend Seller Automation",
      ts: Math.floor(Date.now() / 1000)
    }]
  };
  try {
    await axios.post(webhookUrl, payload);
  } catch (err) {
    console.error('Slack Notification Failed:', err.message);
  }
};

2. Sales Dashboard Component (React)

import React, { useEffect, useState } from 'react';
import dayjs from 'dayjs';
import relativeTime from 'dayjs/plugin/relativeTime';
dayjs.extend(relativeTime);

const LeadDashboard = () => {
  const [leads, setLeads] = useState([]);

  useEffect(() => {
    const fetchLeads = async () => {
      const response = await fetch('/api/contacts/active');
      const data = await response.json();
      setLeads(data);
    };
    fetchLeads();
  }, []);

  return (
    
      🔥 Active Lead Queue
      
          {leads.map(lead => (
            
          ))}
        
        
          
            Name
            Interest
            Assigned
            Status
          
        
        
              {lead.firstName} {lead.lastName}
              {lead.healthInterest}
              {dayjs(lead.assignedAt).fromNow()}
              {lead.status}
            
      
    
  );
};

export default LeadDashboard;

Name	Interest	Assigned	Status
{lead.firstName} {lead.lastName}	{lead.healthInterest}	{dayjs(lead.assignedAt).fromNow()}	{lead.status}

3. Maintenance Script


// scripts/cleanup-jobs.js
import { slaQueue } from '../src/queue/config.js';

/** Removes completed and failed jobs older than 24 hours */
const cleanUpOldJobs = async () => {
  const gracePeriod = 24 * 60 * 60 * 1000;
  try {
    const completed = await slaQueue.clean(gracePeriod, 1000, 'completed');
    const failed = await slaQueue.clean(gracePeriod, 1000, 'failed');
    console.log(`🧹 Cleaned ${completed.length} completed and ${failed.length} failed jobs.`);
    process.exit(0);
  } catch (error) {
    console.error('Cleanup failed:', error);
    process.exit(1);
  }
};
cleanUpOldJobs();

🗺️ Final Logic Chain


Lead Captured → AI Routing → BullMQ Timer (15 min)
Persistence → Postgres + HubSpot
Monitoring → SLA Worker checks status
Notification → Slack Service fires
Visibility → React Dashboard shows ESCALATED badge

4. Deployment Configuration

Dockerfile


# Build stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npx prisma generate

# Production stage
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package*.json ./
COPY --from=builder /app/src ./src
COPY --from=builder /app/prisma ./prisma
EXPOSE 3000
CMD ["node", "src/index.js"]

docker-compose.prod.yml


version: '3.8'
services:
  api:
    build: .
    restart: always
    ports: ["3000:3000"]
    env_file: .env
    depends_on: [db, redis]

  worker:
    build: .
    restart: always
    command: ["node", "src/queue/worker.js"]
    env_file: .env
    depends_on: [redis, db]

  db:
    image: postgres:15-alpine
    volumes: [postgres_data:/var/lib/postgresql/data]
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}

  redis:
    image: redis:7-alpine
    volumes: [redis_data:/data]

volumes:
  postgres_data:
  redis_data:

PM2 Ecosystem Config


module.exports = {
  apps: [
    {
      name: 'health-api',
      script: './src/index.js',
      instances: 'max',
      exec_mode: 'cluster',
      env: { NODE_ENV: 'production' }
    },
    {
      name: 'sla-worker',
      script: './src/queue/worker.js',
      instances: 1,
      autorestart: true
    }
  ]
};

🚀 Launching the Project

Push code to server (GitHub/GitLab)
Set .env values (HubSpot API key, Slack Webhook, DB credentials)
Run containers: docker-compose -f docker-compose.prod.yml up -d --build
Initialize DB: docker-compose exec api npx prisma migrate deploy

✅ Project Complete

CRM Integration: Automatic lead syncing to HubSpot
AI Routing: Leads sorted by health intent and region
SLA Protection: 15-minute timers with Slack alerts
Visual Dashboard: Real-time lead tracking
Deployment: Containerized scaling

📂 Health Trend Seller Automation Documentation


health-trend-seller/
├─ src/
│  ├─ api/        # Express routes
│  ├─ services/   # Business logic (AI, CRM, notifications)
│  ├─ queue/      # BullMQ workers and SLA logic
│  └─ db/         # Prisma client
├─ prisma/        # Database schema and migrations
├─ tests/         # Integration and unit tests
└─ docker-compose.yml

🚦 Getting Started


DATABASE_URL="postgresql://user:password@localhost:5432/health_seller"
REDIS_URL="redis://localhost:6379"
HUBSPOT_ACCESS_TOKEN="your_token"
SLACK_WEBHOOK_URL="your_webhook"

npm install
npx prisma migrate dev --name init
npm run dev
docker-compose up -d --build

📈 Sales SLA Workflow


Lead Captured → Queue Scheduled → CRM Sync
SLA Check → Escalation → Slack Alert + Dashboard Badge

🧪 Testing


npm test