Spaces:
Running
Running
| ; | |
| var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | |
| if (k2 === undefined) k2 = k; | |
| var desc = Object.getOwnPropertyDescriptor(m, k); | |
| if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { | |
| desc = { enumerable: true, get: function() { return m[k]; } }; | |
| } | |
| Object.defineProperty(o, k2, desc); | |
| }) : (function(o, m, k, k2) { | |
| if (k2 === undefined) k2 = k; | |
| o[k2] = m[k]; | |
| })); | |
| var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | |
| Object.defineProperty(o, "default", { enumerable: true, value: v }); | |
| }) : function(o, v) { | |
| o["default"] = v; | |
| }); | |
| var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { | |
| var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; | |
| if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); | |
| else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; | |
| return c > 3 && r && Object.defineProperty(target, key, r), r; | |
| }; | |
| var __importStar = (this && this.__importStar) || (function () { | |
| var ownKeys = function(o) { | |
| ownKeys = Object.getOwnPropertyNames || function (o) { | |
| var ar = []; | |
| for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; | |
| return ar; | |
| }; | |
| return ownKeys(o); | |
| }; | |
| return function (mod) { | |
| if (mod && mod.__esModule) return mod; | |
| var result = {}; | |
| if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); | |
| __setModuleDefault(result, mod); | |
| return result; | |
| }; | |
| })(); | |
| var __metadata = (this && this.__metadata) || function (k, v) { | |
| if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); | |
| }; | |
| var __param = (this && this.__param) || function (paramIndex, decorator) { | |
| return function (target, key) { decorator(target, key, paramIndex); } | |
| }; | |
| var IntegrationsWebhookController_1; | |
| Object.defineProperty(exports, "__esModule", { value: true }); | |
| exports.IntegrationsWebhookController = void 0; | |
| const common_1 = require("@nestjs/common"); | |
| const config_1 = require("@nestjs/config"); | |
| const prisma_service_1 = require("../prisma/prisma.service"); | |
| const crypto = __importStar(require("crypto")); | |
| const webhook_idempotency_service_1 = require("./webhook-idempotency.service"); | |
| const self_hosted_clients_service_1 = require("./clients/self-hosted-clients.service"); | |
| const chatwoot_sync_service_1 = require("../support/chatwoot-sync.service"); | |
| const events_gateway_1 = require("../websocket/events.gateway"); | |
| function timingSafeCompare(provided, expected) { | |
| if (!provided || !expected) | |
| return false; | |
| const bufProvided = Buffer.from(provided); | |
| const bufExpected = Buffer.from(expected); | |
| if (bufProvided.length !== bufExpected.length) | |
| return false; | |
| return crypto.timingSafeEqual(bufProvided, bufExpected); | |
| } | |
| function verifyRawBodyHmac(rawBody, signature, secret, timestamp, allowSha1 = false) { | |
| if (!rawBody || !signature || !secret) | |
| return false; | |
| const provided = signature.replace(/^sha256=/i, "").replace(/^sha1=/i, ""); | |
| const messages = [rawBody]; | |
| if (timestamp) { | |
| messages.push(Buffer.from(`${timestamp}.${rawBody.toString("utf8")}`, "utf8")); | |
| } | |
| const candidates = []; | |
| for (const msg of messages) { | |
| candidates.push(crypto.createHmac("sha256", secret).update(msg).digest("hex")); | |
| if (allowSha1) { | |
| candidates.push(crypto.createHmac("sha1", secret).update(msg).digest("hex")); | |
| } | |
| } | |
| return candidates.some((expected) => timingSafeCompare(provided, expected)); | |
| } | |
| function verifyStandardWebhooksSignature(rawBody, signatureHeader, idHeader, timestampHeader, secret) { | |
| if (!rawBody || !signatureHeader || !idHeader || !timestampHeader || !secret) { | |
| return false; | |
| } | |
| const nowSec = Math.floor(Date.now() / 1000); | |
| const ts = Number(timestampHeader); | |
| if (!Number.isFinite(ts) || Math.abs(nowSec - ts) > 300) | |
| return false; | |
| let secretBytes; | |
| const stripped = secret.replace(/^whsec_/i, ""); | |
| try { | |
| const decoded = Buffer.from(stripped, "base64"); | |
| if (decoded.toString("base64").replace(/=+$/, "") === stripped.replace(/=+$/, "")) { | |
| secretBytes = decoded; | |
| } | |
| else { | |
| secretBytes = Buffer.from(secret, "utf8"); | |
| } | |
| } | |
| catch { | |
| secretBytes = Buffer.from(secret, "utf8"); | |
| } | |
| const signedContent = `${idHeader}.${timestampHeader}.${rawBody.toString("utf8")}`; | |
| const expected = crypto | |
| .createHmac("sha256", secretBytes) | |
| .update(signedContent) | |
| .digest("base64"); | |
| return signatureHeader.split(/\s+/).some((entry) => { | |
| const [version, sig] = entry.split(",", 2); | |
| if (version !== "v1" || !sig) | |
| return false; | |
| return timingSafeCompare(sig, expected); | |
| }); | |
| } | |
| let IntegrationsWebhookController = IntegrationsWebhookController_1 = class IntegrationsWebhookController { | |
| configService; | |
| prisma; | |
| idempotency; | |
| selfHostedClients; | |
| chatwootSync; | |
| eventsGateway; | |
| logger = new common_1.Logger(IntegrationsWebhookController_1.name); | |
| constructor(configService, prisma, idempotency, selfHostedClients, chatwootSync, eventsGateway) { | |
| this.configService = configService; | |
| this.prisma = prisma; | |
| this.idempotency = idempotency; | |
| this.selfHostedClients = selfHostedClients; | |
| this.chatwootSync = chatwootSync; | |
| this.eventsGateway = eventsGateway; | |
| } | |
| requireSecret(envName, configured) { | |
| if (!configured && process.env.NODE_ENV === "production") { | |
| this.logger.error(`${envName} is not configured — rejecting webhook`); | |
| throw new common_1.UnauthorizedException(`${envName} is not configured`); | |
| } | |
| } | |
| async checkIdempotency(provider, body) { | |
| const eventKey = this.idempotency.generateEventKey(provider, body); | |
| const isDuplicate = await this.idempotency.checkAndMark(eventKey); | |
| if (isDuplicate) { | |
| this.logger.warn(`Duplicate webhook ignored: ${provider}:${eventKey}`); | |
| } | |
| return isDuplicate; | |
| } | |
| verifyLiveKitJwt(authorization, apiKey, apiSecret, rawBody) { | |
| if (!authorization?.startsWith("Bearer ")) | |
| return false; | |
| const token = authorization.slice("Bearer ".length).trim(); | |
| const parts = token.split("."); | |
| if (parts.length !== 3) | |
| return false; | |
| const [headerB64, payloadB64, signatureB64] = parts; | |
| try { | |
| const payload = JSON.parse(Buffer.from(payloadB64, "base64url").toString("utf8")); | |
| if (payload.iss !== apiKey) | |
| return false; | |
| const nowSec = Math.floor(Date.now() / 1000); | |
| if (typeof payload.exp === "number" && payload.exp < nowSec) | |
| return false; | |
| if (typeof payload.nbf === "number" && payload.nbf > nowSec + 60) | |
| return false; | |
| const signingInput = `${headerB64}.${payloadB64}`; | |
| const expected = crypto | |
| .createHmac("sha256", apiSecret) | |
| .update(signingInput) | |
| .digest("base64url"); | |
| if (!timingSafeCompare(expected, signatureB64)) | |
| return false; | |
| if (typeof payload.sha256 !== "string") | |
| return false; | |
| if (rawBody === undefined) { | |
| return process.env.NODE_ENV !== "production"; | |
| } | |
| const bodyBuf = typeof rawBody === "string" ? Buffer.from(rawBody, "utf8") : rawBody; | |
| const bodyHash = crypto | |
| .createHash("sha256") | |
| .update(bodyBuf) | |
| .digest("base64"); | |
| return timingSafeCompare(payload.sha256, bodyHash); | |
| } | |
| catch { | |
| return false; | |
| } | |
| } | |
| async handleCalComWebhook(body, secret) { | |
| const expected = this.configService.get("CALCOM_WEBHOOK_SECRET", ""); | |
| this.requireSecret("CALCOM_WEBHOOK_SECRET", expected); | |
| if (expected && !timingSafeCompare(secret, expected)) { | |
| throw new common_1.UnauthorizedException("Invalid Cal.com webhook secret"); | |
| } | |
| if (await this.checkIdempotency("calcom", body)) { | |
| return { received: true, duplicate: true }; | |
| } | |
| const eventType = String(body?.triggerEvent || body?.event || "unknown"); | |
| const payload = (body?.payload || body); | |
| this.logger.log(`Cal.com webhook received: ${eventType}`); | |
| await this.handleCalComEvent(eventType, payload); | |
| return { received: true, event: eventType }; | |
| } | |
| async handleCalComEvent(eventType, payload) { | |
| const uid = String(payload?.uid || payload?.bookingId || ""); | |
| if (!uid) | |
| return; | |
| const booking = await this.prisma.booking.findFirst({ | |
| where: { OR: [{ calendarEventId: uid }, { meetLink: { contains: uid } }] }, | |
| include: { | |
| episode: { | |
| include: { | |
| podcast: { | |
| select: { workspaceId: true }, | |
| }, | |
| }, | |
| }, | |
| }, | |
| }); | |
| if (!booking) { | |
| this.logger.warn(`No booking found for Cal.com UID: ${uid}`); | |
| return; | |
| } | |
| switch (eventType) { | |
| case "BOOKING_CREATED": | |
| case "BOOKING_CONFIRMED": | |
| await this.prisma.booking.update({ | |
| where: { id: booking.id }, | |
| data: { isConfirmed: true, updatedAt: new Date() }, | |
| }); | |
| this.logger.log(`Booking ${booking.id} confirmed via Cal.com`); | |
| if (booking.episode?.podcast?.workspaceId) { | |
| this.eventsGateway.notifyCalComBookingCreated(booking.episode.podcast.workspaceId, { id: booking.id, isConfirmed: true }); | |
| } | |
| break; | |
| case "BOOKING_CANCELLED": | |
| case "BOOKING_REJECTED": | |
| await this.prisma.booking.update({ | |
| where: { id: booking.id }, | |
| data: { isConfirmed: false, updatedAt: new Date() }, | |
| }); | |
| this.logger.log(`Booking ${booking.id} cancelled via Cal.com`); | |
| if (booking.episode?.podcast?.workspaceId) { | |
| this.eventsGateway.notifyCalComBookingCancelled(booking.episode.podcast.workspaceId, booking.id); | |
| } | |
| break; | |
| case "BOOKING_RESCHEDULED": | |
| const newStart = String(payload?.startTime || payload?.rescheduledStartTime || ""); | |
| const newEnd = String(payload?.endTime || payload?.rescheduledEndTime || ""); | |
| if (newStart && newEnd) { | |
| await this.prisma.booking.update({ | |
| where: { id: booking.id }, | |
| data: { | |
| startTime: new Date(newStart), | |
| endTime: new Date(newEnd), | |
| updatedAt: new Date(), | |
| }, | |
| }); | |
| this.logger.log(`Booking ${booking.id} rescheduled to ${newStart}`); | |
| if (booking.episode?.podcast?.workspaceId) { | |
| this.eventsGateway.notifyCalComBookingRescheduled(booking.episode.podcast.workspaceId, booking.id); | |
| } | |
| } | |
| break; | |
| case "BOOKING_NO_SHOW": | |
| this.logger.log(`Booking ${booking.id} no-show (no status field available)`); | |
| break; | |
| case "BOOKING_ATTENDEE_ADDED": | |
| case "BOOKING_ATTENDEE_REMOVED": | |
| this.logger.log(`Attendee change for booking ${booking.id}: ${eventType}`); | |
| break; | |
| default: | |
| this.logger.debug(`Unhandled Cal.com event type: ${eventType}`); | |
| } | |
| } | |
| async handleChatwootWebhook(accountId, req, body, signature, timestamp) { | |
| const expected = this.configService.get("CHATWOOT_WEBHOOK_SECRET", ""); | |
| this.requireSecret("CHATWOOT_WEBHOOK_SECRET", expected); | |
| if (expected && | |
| !verifyRawBodyHmac(req.rawBody, signature, expected, timestamp, true)) { | |
| throw new common_1.UnauthorizedException("Invalid Chatwoot webhook signature"); | |
| } | |
| if (await this.checkIdempotency("chatwoot", body)) { | |
| return { received: true, duplicate: true }; | |
| } | |
| const event = body?.event || "unknown"; | |
| this.logger.log(`Chatwoot webhook: ${event} for account ${accountId}`); | |
| await this.handleChatwootEvent(event, body, accountId); | |
| return { received: true, event, accountId }; | |
| } | |
| async handleChatwootEvent(event, body, accountId) { | |
| switch (event) { | |
| case "message_created": | |
| if (body?.message_type === "incoming" && body?.content) { | |
| const conversationId = body?.conversation?.id; | |
| const contactId = body?.conversation?.contact_inbox?.contact_id; | |
| const messageId = body?.message?.id; | |
| this.logger.log(`Incoming Chatwoot message in conversation ${conversationId} from contact ${contactId}`); | |
| if (contactId) { | |
| await this.syncChatwootContact(contactId, accountId); | |
| } | |
| if (conversationId && messageId && body.content) { | |
| await this.chatwootSync.syncIncomingMessage(accountId, conversationId, messageId, body.content, "incoming"); | |
| } | |
| } | |
| break; | |
| case "conversation_created": | |
| this.logger.log(`New Chatwoot conversation: ${body?.conversation?.id}`); | |
| break; | |
| case "conversation_status_changed": { | |
| const newStatus = body?.conversation?.status; | |
| const conversationId = body?.conversation?.id; | |
| this.logger.log(`Conversation ${conversationId} status changed to ${newStatus}`); | |
| if (conversationId && newStatus) { | |
| await this.chatwootSync.syncConversationStatus(accountId, conversationId, newStatus); | |
| } | |
| break; | |
| } | |
| case "conversation_assigned": { | |
| const conversationId = body?.conversation?.id; | |
| const assigneeId = body?.conversation?.assignee?.id; | |
| this.logger.log(`Conversation ${conversationId} assigned to ${assigneeId}`); | |
| if (conversationId) { | |
| await this.chatwootSync.syncConversationAssignment(accountId, conversationId, assigneeId); | |
| } | |
| break; | |
| } | |
| case "contact_created": | |
| case "contact_updated": | |
| const contactId = body?.contact?.id; | |
| if (contactId) { | |
| await this.syncChatwootContact(contactId, accountId); | |
| } | |
| break; | |
| default: | |
| this.logger.debug(`Unhandled Chatwoot event: ${event}`); | |
| } | |
| } | |
| async syncChatwootContact(contactId, accountId) { | |
| try { | |
| const integration = await this.prisma.workspaceIntegration.findFirst({ | |
| where: { | |
| provider: "chatwoot", | |
| status: "connected", | |
| metadata: { path: ["accountId"], equals: accountId }, | |
| }, | |
| }); | |
| if (!integration) { | |
| this.logger.warn(`No workspace integration found for Chatwoot account ${accountId}`); | |
| return; | |
| } | |
| const apiKey = integration.accessToken; | |
| if (!apiKey) { | |
| this.logger.warn(`No API key found for Chatwoot integration ${integration.id}`); | |
| return; | |
| } | |
| const contact = await this.selfHostedClients.getChatwootContact(apiKey, contactId); | |
| if (!contact?.email) { | |
| this.logger.warn(`Chatwoot contact ${contactId} has no email, skipping sync`); | |
| return; | |
| } | |
| const workspace = await this.prisma.workspace.findUnique({ | |
| where: { id: integration.workspaceId }, | |
| include: { podcasts: { take: 1 } }, | |
| }); | |
| const podcastId = workspace?.podcasts?.[0]?.id; | |
| if (!podcastId) { | |
| this.logger.warn(`No podcast found for workspace ${integration.workspaceId}, cannot create guest`); | |
| return; | |
| } | |
| const existingGuest = await this.prisma.guest.findFirst({ | |
| where: { podcastId, email: contact.email }, | |
| }); | |
| if (existingGuest) { | |
| const currentCustomFields = existingGuest.customFields || {}; | |
| await this.prisma.guest.update({ | |
| where: { id: existingGuest.id }, | |
| data: { | |
| fullName: contact.name || existingGuest.fullName, | |
| lastContactAt: new Date(), | |
| customFields: { | |
| ...currentCustomFields, | |
| chatwootContactId: contactId, | |
| chatwootAccountId: accountId, | |
| chatwootPhone: contact.phone_number, | |
| chatwootCustomAttributes: contact.custom_attributes, | |
| }, | |
| }, | |
| }); | |
| this.logger.log(`Updated guest ${existingGuest.id} from Chatwoot contact ${contactId}`); | |
| } | |
| else { | |
| await this.prisma.guest.create({ | |
| data: { | |
| podcastId, | |
| email: contact.email, | |
| fullName: contact.name || contact.email.split("@")[0], | |
| status: "prospect", | |
| customFields: { | |
| chatwootContactId: contactId, | |
| chatwootAccountId: accountId, | |
| chatwootPhone: contact.phone_number, | |
| chatwootCustomAttributes: contact.custom_attributes, | |
| source: "chatwoot", | |
| }, | |
| }, | |
| }); | |
| this.logger.log(`Created guest from Chatwoot contact ${contactId} (${contact.email})`); | |
| } | |
| } | |
| catch (error) { | |
| const message = error instanceof Error ? error.message : String(error); | |
| this.logger.error(`Failed to sync Chatwoot contact ${contactId}: ${message}`); | |
| } | |
| } | |
| async handleDocumensoWebhook(body, secret) { | |
| const expected = this.configService.get("DOCUMENSO_WEBHOOK_SECRET", ""); | |
| this.requireSecret("DOCUMENSO_WEBHOOK_SECRET", expected); | |
| if (expected && !timingSafeCompare(secret, expected)) { | |
| throw new common_1.UnauthorizedException("Invalid Documenso webhook secret"); | |
| } | |
| if (await this.checkIdempotency("documenso", body)) { | |
| return { received: true, duplicate: true }; | |
| } | |
| const event = body?.event || "unknown"; | |
| const documentId = body?.documentId || body?.data?.id; | |
| this.logger.log(`Documenso webhook: ${event} docId=${documentId ?? ""}`); | |
| if (documentId && (event === "document_completed" || event === "document_declined")) { | |
| this.logger.log(`Document ${documentId} status: ${event}`); | |
| } | |
| return { received: true, event, documentId }; | |
| } | |
| async handleFormbricksWebhook(req, body, signature, webhookId, webhookTimestamp) { | |
| const expected = this.configService.get("FORMBRICKS_WEBHOOK_SECRET", ""); | |
| this.requireSecret("FORMBRICKS_WEBHOOK_SECRET", expected); | |
| if (expected && | |
| !verifyStandardWebhooksSignature(req.rawBody, signature, webhookId, webhookTimestamp, expected)) { | |
| throw new common_1.UnauthorizedException("Invalid Formbricks webhook signature"); | |
| } | |
| if (await this.checkIdempotency("formbricks", body)) { | |
| return { received: true, duplicate: true }; | |
| } | |
| const event = body?.event || body?.type || "unknown"; | |
| const surveyId = body?.surveyId || body?.data?.surveyId; | |
| const responseId = body?.responseId || body?.data?.id; | |
| this.logger.log(`Formbricks webhook: ${event} surveyId=${surveyId ?? ""} responseId=${responseId ?? ""}`); | |
| if (body?.data?.userId) { | |
| const guest = await this.prisma.guest.findFirst({ | |
| where: { id: body.data.userId }, | |
| }); | |
| if (guest) { | |
| await this.prisma.guestJourneyEvent.create({ | |
| data: { | |
| guestId: guest.id, | |
| eventType: "follow_up", | |
| title: "Completed Survey", | |
| details: `Completed survey ${surveyId || ""}`, | |
| metadata: JSON.parse(JSON.stringify(body?.data || {})), | |
| }, | |
| }); | |
| this.logger.log(`Recorded survey completion journey event for guest ${guest.id}`); | |
| } | |
| } | |
| return { received: true, event, surveyId, responseId }; | |
| } | |
| async handleListmonkWebhook(body, secret) { | |
| const expected = this.configService.get("LISTMONK_WEBHOOK_SECRET", ""); | |
| this.requireSecret("LISTMONK_WEBHOOK_SECRET", expected); | |
| if (expected && !timingSafeCompare(secret, expected)) { | |
| throw new common_1.UnauthorizedException("Invalid Listmonk webhook secret"); | |
| } | |
| if (await this.checkIdempotency("listmonk", body)) { | |
| return { received: true, duplicate: true }; | |
| } | |
| const event = body?.event || "unknown"; | |
| const subscriberId = body?.data?.subscriber?.id || body?.subscriber_id; | |
| this.logger.log(`Listmonk webhook: ${event} subscriberId=${subscriberId ?? ""}`); | |
| await this.handleListmonkEvent(event, body); | |
| return { received: true, event, subscriberId }; | |
| } | |
| async handleListmonkEvent(event, body) { | |
| const subscriber = body?.data?.subscriber || body?.subscriber; | |
| if (!subscriber) | |
| return; | |
| const email = subscriber.email; | |
| const name = subscriber.name || ""; | |
| const status = subscriber.status || "enabled"; | |
| const lists = subscriber.lists || []; | |
| switch (event) { | |
| case "subscriber.created": | |
| case "subscriber.updated": | |
| await this.syncListmonkSubscriber(subscriber); | |
| break; | |
| case "subscriber.deleted": | |
| await this.unsubscribeListmonkSubscriber(email); | |
| break; | |
| case "subscriber.subscribed": | |
| case "subscriber.unsubscribed": | |
| await this.handleListmonkSubscriptionChange(email, lists, event); | |
| break; | |
| default: | |
| this.logger.debug(`Unhandled Listmonk event: ${event}`); | |
| } | |
| } | |
| async syncListmonkSubscriber(subscriber) { | |
| const email = subscriber.email; | |
| if (!email) | |
| return; | |
| try { | |
| const guest = await this.prisma.guest.findFirst({ | |
| where: { email }, | |
| }); | |
| if (guest) { | |
| await this.prisma.guest.update({ | |
| where: { id: guest.id }, | |
| data: { | |
| customFields: { | |
| listmonkSubscriberId: subscriber.id, | |
| listmonkStatus: subscriber.status, | |
| listmonkLists: subscriber.lists || [], | |
| }, | |
| }, | |
| }); | |
| this.logger.log(`Synced Listmonk subscriber ${subscriber.id} to guest ${guest.id}`); | |
| } | |
| else { | |
| this.logger.log(`Listmonk subscriber ${email} not found in guests, would create contact`); | |
| } | |
| } | |
| catch (error) { | |
| const message = error instanceof Error ? error.message : String(error); | |
| this.logger.error(`Failed to sync Listmonk subscriber ${subscriber.id}: ${message}`); | |
| } | |
| } | |
| async unsubscribeListmonkSubscriber(email) { | |
| try { | |
| const guest = await this.prisma.guest.findFirst({ where: { email } }); | |
| if (guest) { | |
| await this.prisma.guest.update({ | |
| where: { id: guest.id }, | |
| data: { | |
| customFields: { | |
| listmonkUnsubscribedAt: new Date().toISOString(), | |
| }, | |
| }, | |
| }); | |
| this.logger.log(`Marked guest ${guest.id} as unsubscribed via Listmonk webhook`); | |
| } | |
| } | |
| catch (error) { | |
| const message = error instanceof Error ? error.message : String(error); | |
| this.logger.error(`Failed to unsubscribe guest for email ${email}: ${message}`); | |
| } | |
| } | |
| async handleListmonkSubscriptionChange(email, lists, event) { | |
| this.logger.log(`Listmonk subscription change for ${email}: ${event} on lists ${lists.map(l => l.id).join(", ")}`); | |
| } | |
| async handleLiveKitWebhook(req, body, authorization) { | |
| const apiKey = this.configService.get("LIVEKIT_API_KEY", ""); | |
| const apiSecret = this.configService.get("LIVEKIT_API_SECRET", ""); | |
| const rawBody = req.rawBody; | |
| if (process.env.NODE_ENV === "production") { | |
| if (!apiKey || | |
| !apiSecret || | |
| !this.verifyLiveKitJwt(authorization, apiKey, apiSecret, rawBody)) { | |
| throw new common_1.UnauthorizedException("Invalid LiveKit webhook authorization"); | |
| } | |
| } | |
| else if (apiKey && apiSecret && !this.verifyLiveKitJwt(authorization, apiKey, apiSecret, rawBody)) { | |
| throw new common_1.UnauthorizedException("Invalid LiveKit webhook authorization"); | |
| } | |
| else if (!apiKey || !apiSecret) { | |
| this.logger.warn("LIVEKIT_API_KEY / LIVEKIT_API_SECRET not configured — LiveKit webhook verification skipped (dev)"); | |
| } | |
| if (await this.checkIdempotency("livekit", body)) { | |
| return { received: true, duplicate: true }; | |
| } | |
| const event = String(body?.event || "unknown"); | |
| const roomName = body?.room?.name || body?.egressInfo?.roomName || String(body?.roomName || ""); | |
| this.logger.log(`LiveKit webhook: ${event} room=${roomName ?? ""}`); | |
| if (event === "room_finished" && roomName) { | |
| const episodeId = this.extractEpisodeIdFromRoom(roomName); | |
| if (episodeId) { | |
| const session = await this.prisma.recordingSession.findUnique({ | |
| where: { episodeId }, | |
| }); | |
| if (session && session.status === "active") { | |
| await this.prisma.recordingSession.update({ | |
| where: { id: session.id }, | |
| data: { status: "completed", endedAt: new Date() }, | |
| }); | |
| this.logger.log(`Marked recording session ${session.id} as completed via LiveKit webhook`); | |
| } | |
| } | |
| else { | |
| this.logger.warn(`Could not extract episode ID from room name: ${roomName}`); | |
| } | |
| } | |
| if (event === "egress_ended" || | |
| event === "egress_completed" || | |
| event === "recording.completed" || | |
| event === "recording_completed") { | |
| await this.handleLiveKitRecordingFinished(body); | |
| } | |
| if (event === "participant_joined" || event === "participant_left") { | |
| const participant = body?.participant; | |
| this.logger.log(`Participant ${participant?.identity} ${event} in room ${roomName}`); | |
| } | |
| return { received: true, event, roomName }; | |
| } | |
| extractEpisodeIdFromRoom(roomName) { | |
| const match = roomName.match(/^episode-(.+)$/); | |
| return match ? match[1] : null; | |
| } | |
| async handleLiveKitRecordingFinished(body) { | |
| const egressInfo = body?.recording; | |
| const roomName = egressInfo?.name || body?.room?.name; | |
| if (!roomName) { | |
| this.logger.warn("LiveKit recording/egress event missing room name"); | |
| return; | |
| } | |
| const episodeId = this.extractEpisodeIdFromRoom(roomName); | |
| if (!episodeId) { | |
| this.logger.warn(`Could not extract episode ID from room name: ${roomName}`); | |
| return; | |
| } | |
| const session = await this.prisma.recordingSession.findUnique({ | |
| where: { episodeId }, | |
| }); | |
| if (!session) { | |
| this.logger.warn(`No recording session found for episode ${episodeId}`); | |
| return; | |
| } | |
| if (session.status === "completed" || session.status === "processing") { | |
| this.logger.log(`Session ${session.id} already ${session.status}, skipping`); | |
| return; | |
| } | |
| await this.prisma.recordingSession.update({ | |
| where: { id: session.id }, | |
| data: { status: "processing", endedAt: new Date() }, | |
| }); | |
| this.logger.log(`Session ${session.id} marked as processing after LiveKit recording finished (${egressInfo?.status ?? "unknown"})`); | |
| } | |
| }; | |
| exports.IntegrationsWebhookController = IntegrationsWebhookController; | |
| __decorate([ | |
| (0, common_1.Post)("calcom"), | |
| (0, common_1.HttpCode)(common_1.HttpStatus.OK), | |
| __param(0, (0, common_1.Body)()), | |
| __param(1, (0, common_1.Headers)("x-cal-secret-key")), | |
| __metadata("design:type", Function), | |
| __metadata("design:paramtypes", [Object, String]), | |
| __metadata("design:returntype", Promise) | |
| ], IntegrationsWebhookController.prototype, "handleCalComWebhook", null); | |
| __decorate([ | |
| (0, common_1.Post)("chatwoot/:accountId"), | |
| (0, common_1.HttpCode)(common_1.HttpStatus.OK), | |
| __param(0, (0, common_1.Param)("accountId")), | |
| __param(1, (0, common_1.Req)()), | |
| __param(2, (0, common_1.Body)()), | |
| __param(3, (0, common_1.Headers)("x-chatwoot-signature")), | |
| __param(4, (0, common_1.Headers)("x-chatwoot-timestamp")), | |
| __metadata("design:type", Function), | |
| __metadata("design:paramtypes", [String, Object, Object, String, String]), | |
| __metadata("design:returntype", Promise) | |
| ], IntegrationsWebhookController.prototype, "handleChatwootWebhook", null); | |
| __decorate([ | |
| (0, common_1.Post)("documenso"), | |
| (0, common_1.HttpCode)(common_1.HttpStatus.OK), | |
| __param(0, (0, common_1.Body)()), | |
| __param(1, (0, common_1.Headers)("x-documenso-secret")), | |
| __metadata("design:type", Function), | |
| __metadata("design:paramtypes", [Object, String]), | |
| __metadata("design:returntype", Promise) | |
| ], IntegrationsWebhookController.prototype, "handleDocumensoWebhook", null); | |
| __decorate([ | |
| (0, common_1.Post)("formbricks"), | |
| (0, common_1.HttpCode)(common_1.HttpStatus.OK), | |
| __param(0, (0, common_1.Req)()), | |
| __param(1, (0, common_1.Body)()), | |
| __param(2, (0, common_1.Headers)("webhook-signature")), | |
| __param(3, (0, common_1.Headers)("webhook-id")), | |
| __param(4, (0, common_1.Headers)("webhook-timestamp")), | |
| __metadata("design:type", Function), | |
| __metadata("design:paramtypes", [Object, Object, String, String, String]), | |
| __metadata("design:returntype", Promise) | |
| ], IntegrationsWebhookController.prototype, "handleFormbricksWebhook", null); | |
| __decorate([ | |
| (0, common_1.Post)("listmonk"), | |
| (0, common_1.HttpCode)(common_1.HttpStatus.OK), | |
| __param(0, (0, common_1.Body)()), | |
| __param(1, (0, common_1.Headers)("x-listmonk-secret")), | |
| __metadata("design:type", Function), | |
| __metadata("design:paramtypes", [Object, String]), | |
| __metadata("design:returntype", Promise) | |
| ], IntegrationsWebhookController.prototype, "handleListmonkWebhook", null); | |
| __decorate([ | |
| (0, common_1.Post)("livekit"), | |
| (0, common_1.HttpCode)(common_1.HttpStatus.OK), | |
| __param(0, (0, common_1.Req)()), | |
| __param(1, (0, common_1.Body)()), | |
| __param(2, (0, common_1.Headers)("authorization")), | |
| __metadata("design:type", Function), | |
| __metadata("design:paramtypes", [Object, Object, String]), | |
| __metadata("design:returntype", Promise) | |
| ], IntegrationsWebhookController.prototype, "handleLiveKitWebhook", null); | |
| exports.IntegrationsWebhookController = IntegrationsWebhookController = IntegrationsWebhookController_1 = __decorate([ | |
| (0, common_1.Controller)("integrations/webhooks"), | |
| __metadata("design:paramtypes", [config_1.ConfigService, | |
| prisma_service_1.PrismaService, | |
| webhook_idempotency_service_1.WebhookIdempotencyService, | |
| self_hosted_clients_service_1.SelfHostedClientsService, | |
| chatwoot_sync_service_1.ChatwootSyncService, | |
| events_gateway_1.EventsGateway]) | |
| ], IntegrationsWebhookController); | |
| //# sourceMappingURL=integrations-webhook.controller.js.map |