fix production issues

apps/api/src/index.ts

@@ -1,30 +1,22 @@
 import http from 'http'
 import { Server as SocketIOServer } from 'socket.io'
 import type { Socket } from 'socket.io'
-import cron from 'node-cron'
 import { redis } from './lib/redis'
 import { prisma } from './lib/prisma'
 import { assertStorageConfiguration } from './lib/storage'
 import { createApp, corsOrigins } from './app'
 import { verifyAnyActorToken } from './security/tokens'
 import { getSessionCookieName } from './security/sessionCookies'
-import { processNotificationOutbox, sendNotification } from './services/notificationService'
-import {
-  runTrialExpirationJob,
-  runPeriodEndCancellationJob,
-} from './modules/subscriptions/subscription.service'
-import { runCollectionsWorker } from './modules/subscriptions/subscription.collections.service'
+import { startOutboxWorker, startScheduledJobs } from './workers/jobs'
 
-const app    = createApp()
+const app = createApp()
 const server = http.createServer(app)
 assertStorageConfiguration()
 
-// ─── Socket.io ────────────────────────────────────────────────
 const io = new SocketIOServer(server, {
   cors: { origin: corsOrigins, credentials: true, methods: ['GET', 'POST'] },
 })
 
-
 function readCookieFromHeader(cookieHeader: string | undefined, name: string): string | null {
   if (!cookieHeader) return null
 
@@ -49,10 +41,9 @@ function getSocketSessionToken(socket: Socket): string | undefined {
   )
 }
 
-// Authenticate socket connections via JWT before joining user rooms
 io.use((socket, next) => {
   const token = getSocketSessionToken(socket)
-  if (!token) return next() // unauthenticated connections allowed; they just don't join rooms
+  if (!token) return next()
   try {
     const payload = verifyAnyActorToken(token)
     ;(socket as any).authenticatedUserId = payload.sub
@@ -64,12 +55,9 @@ io.use((socket, next) => {
 
 io.on('connection', (socket) => {
   const userId = (socket as any).authenticatedUserId as string | undefined
-  if (userId) {
-    socket.join(`user:${userId}`)
-  }
+  if (userId) socket.join(`user:${userId}`)
 })
 
-// Redis pub/sub → broadcast to connected clients
 const subscriber = redis.duplicate()
 subscriber.psubscribe('notifications:*', (err) => {
   if (err) console.error('[Redis] Subscribe error:', err)
@@ -84,168 +72,14 @@ subscriber.on('pmessage', (_pattern, channel, message) => {
   }
 })
 
-// ─── Scheduled jobs ───────────────────────────────────────────
+// Embedded jobs only when explicitly enabled (single-process local/dev).
+// Production should run `npm run worker` / Compose `api-worker` instead.
+if (process.env.ENABLE_EMBEDDED_JOBS === 'true') {
+  console.warn('[API] ENABLE_EMBEDDED_JOBS=true — running outbox/cron inside the API process')
+  startOutboxWorker()
+  startScheduledJobs()
+}
 
-// Daily: flag expiring/expired licenses
-cron.schedule('0 8 * * *', async () => {
-  const customers = await prisma.customer.findMany({ where: { licenseExpiry: { not: null } } })
-  for (const c of customers) {
-    if (!c.licenseExpiry) continue
-    const daysLeft = Math.ceil((c.licenseExpiry.getTime() - Date.now()) / (1000 * 60 * 60 * 24))
-    const expired = c.licenseExpiry <= new Date()
-    const expiring = !expired && daysLeft < 90
-    if (expired !== c.licenseExpired || expiring !== c.licenseExpiringSoon) {
-      await prisma.customer.update({ where: { id: c.id }, data: { licenseExpired: expired, licenseExpiringSoon: expiring, licenseValidationStatus: expired ? 'EXPIRED' : expiring ? 'EXPIRING' : 'VALID' } })
-    }
-  }
-})
-
-// Hourly: expire trials that ended without payment
-cron.schedule('0 * * * *', async () => {
-  const n = await runTrialExpirationJob()
-  if (n > 0) console.log(`[subscription] trial_expiration: ${n} expired`)
-})
-
-// Daily: explicit period-end cancellations. Subscription collections use the
-// timezone-aware 30-day grace worker below, so the old fixed 7-day chain is
-// intentionally not scheduled.
-cron.schedule('0 1 * * *', async () => {
-  const nPeriod  = await runPeriodEndCancellationJob()
-  if (nPeriod > 0)  console.log(`[subscription] period_end_cancel: ${nPeriod} cancelled`)
-})
-
-cron.schedule('*/15 * * * *', async () => {
-  const n = await runCollectionsWorker()
-  if (n > 0) console.log(`[subscription] collections: ${n} cases processed`)
-})
-
-cron.schedule('* * * * *', async () => {
-  const n = await processNotificationOutbox()
-  if (n > 0) console.log(`[notifications] outbox: ${n} events completed`)
-})
-
-// Daily: send trial-ending reminders (3 days before trial end)
-cron.schedule('0 9 * * *', async () => {
-  const soon = new Date(Date.now() + 3 * 24 * 60 * 60 * 1000)
-  const subscriptions = await prisma.subscription.findMany({
-    where: { status: 'TRIALING', trialEndAt: { lte: soon, gte: new Date() } },
-    include: { company: { include: { employees: { where: { role: 'OWNER' } } } } },
-  })
-  for (const sub of subscriptions) {
-    const owner = sub.company.employees[0]
-    if (owner) {
-      await sendNotification({
-        type: 'SUBSCRIPTION_TRIAL_ENDING',
-        companyId: sub.companyId,
-        employeeId: owner.id,
-        channels: ['IN_APP'],
-        templateKey: 'subscription.trial_ending',
-        templateVariables: {
-          trialEndDate: sub.trialEndAt ?? new Date(Date.now() + 3 * 24 * 60 * 60 * 1000),
-        },
-      }).catch((err) => {
-        console.error('[Notifications] Failed to create trial ending reminder:', err?.message ?? String(err))
-      })
-    }
-  }
-})
-
-// Daily: notify companies about upcoming and overdue vehicle maintenance (date- and odometer-based).
-// Repeats every day until the owner logs a new service entry that pushes the due date/mileage into the future.
-cron.schedule('0 8 * * *', async () => {
-  const now = new Date()
-  const in30Days = new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000)
-
-  // Fetch all candidate logs (date-due or has an odometer target), ordered newest-first per vehicle+type.
-  // We keep only the LATEST log per vehicle+type so that once the owner logs a new service the
-  // old overdue log is superseded and notifications stop automatically.
-  const allCandidates = await prisma.maintenanceLog.findMany({
-    where: {
-      OR: [
-        { nextDueAt: { lte: in30Days } },
-        { nextDueMileage: { not: null } },
-      ],
-    },
-    include: { vehicle: { include: { company: { include: { employees: { where: { role: { in: ['OWNER', 'MANAGER'] }, isActive: true }, take: 1 } } } } } },
-    orderBy: { performedAt: 'desc' },
-  })
-
-  // Keep only the most-recent log per vehicle+type combination
-  const latestByKey = new Map<string, typeof allCandidates[number]>()
-  for (const log of allCandidates) {
-    const key = `${log.vehicleId}:${log.type}`
-    if (!latestByKey.has(key)) latestByKey.set(key, log)
-  }
-
-  for (const log of latestByKey.values()) {
-    const vehicle = log.vehicle
-    const company = vehicle.company
-    const recipient = company.employees[0]
-    if (!recipient) continue
-
-    // Determine date-based urgency
-    let isOverdueByDate = false
-    let daysLeft: number | null = null
-    let dueSoonByDate = false
-    if (log.nextDueAt) {
-      daysLeft = Math.ceil((log.nextDueAt.getTime() - now.getTime()) / (1000 * 60 * 60 * 24))
-      isOverdueByDate = log.nextDueAt <= now
-      dueSoonByDate = !isOverdueByDate && daysLeft <= 30
-    }
-
-    // Determine odometer-based urgency
-    let isOverdueByOdometer = false
-    let kmLeft: number | null = null
-    let dueSoonByOdometer = false
-    if (log.nextDueMileage != null && vehicle.mileage != null) {
-      kmLeft = log.nextDueMileage - vehicle.mileage
-      isOverdueByOdometer = kmLeft <= 0
-      dueSoonByOdometer = !isOverdueByOdometer && kmLeft <= 500
-    }
-
-    // Skip if the latest log is no longer due (owner has updated it)
-    const isOverdue = isOverdueByDate || isOverdueByOdometer
-    const isDueSoon = !isOverdue && (dueSoonByDate || dueSoonByOdometer)
-    if (!isOverdue && !isDueSoon) continue
-
-    // Build human-readable description
-    const dueParts: string[] = []
-    if (isOverdueByDate) dueParts.push(`overdue since ${log.nextDueAt!.toLocaleDateString()}`)
-    else if (dueSoonByDate && daysLeft != null) dueParts.push(`due in ${daysLeft} day${daysLeft === 1 ? '' : 's'}`)
-    if (isOverdueByOdometer) dueParts.push(`overdue by odometer (${Math.abs(kmLeft!).toLocaleString()} km ago)`)
-    else if (dueSoonByOdometer && kmLeft != null) dueParts.push(`${kmLeft.toLocaleString()} km remaining`)
-
-    const title = isOverdue
-      ? `Overdue: ${log.type} — ${vehicle.make} ${vehicle.model}`
-      : `${log.type} due soon — ${vehicle.make} ${vehicle.model}`
-    const body = `${log.type} for ${vehicle.make} ${vehicle.model} (${vehicle.licensePlate}): ${dueParts.join('; ')}. Please log the service to dismiss this reminder.`
-
-    const reminderDate = now.toISOString().slice(0, 10)
-    await sendNotification({
-      type: 'VEHICLE_MAINTENANCE_DUE',
-      title,
-      body,
-      data: {
-        vehicleId: vehicle.id,
-        maintenanceLogId: log.id,
-        maintenanceType: log.type,
-        isOverdue,
-        daysLeft,
-        kmLeft,
-        isOverdueByDate,
-        isOverdueByOdometer,
-      },
-      companyId: company.id,
-      employeeId: recipient.id,
-      channels: ['IN_APP'],
-      sourceType: 'maintenance_log',
-      sourceId: log.id,
-      idempotencyKey: `maintenance:${log.id}:${recipient.id}:${reminderDate}`,
-    })
-  }
-})
-
-// ─── Start ────────────────────────────────────────────────────
 const PORT = Number(process.env.API_PORT ?? 4000)
 const HOST = process.env.API_HOST ?? '0.0.0.0'
 
@@ -253,4 +87,44 @@ server.listen(PORT, HOST, () => {
   console.log(`[API] Server running on ${HOST}:${PORT}`)
 })
 
+let shuttingDown = false
+async function shutdown(signal: string) {
+  if (shuttingDown) return
+  shuttingDown = true
+  console.log(`[API] ${signal} received, draining`)
+
+  server.close((err) => {
+    if (err) console.error('[API] HTTP close error:', err.message)
+  })
+
+  try {
+    io.close()
+  } catch (err: any) {
+    console.error('[API] Socket.IO close error:', err?.message ?? err)
+  }
+
+  try {
+    await subscriber.quit()
+  } catch {
+    subscriber.disconnect()
+  }
+
+  try {
+    await redis.quit()
+  } catch {
+    redis.disconnect()
+  }
+
+  try {
+    await prisma.$disconnect()
+  } catch (err: any) {
+    console.error('[API] Prisma disconnect error:', err?.message ?? err)
+  }
+
+  process.exit(0)
+}
+
+process.on('SIGTERM', () => void shutdown('SIGTERM'))
+process.on('SIGINT', () => void shutdown('SIGINT'))
+
 export { app, io }