Spaces:
Running
Running
| import { Injectable } from "@nestjs/common"; | |
| import { z } from "zod"; | |
| import { | |
| router, | |
| protectedProcedure, | |
| workspaceProcedure, | |
| requireFeature, | |
| } from "../trpc/trpc.init"; | |
| import { SubscriptionFeature } from "../billing/subscription-features"; | |
| import { IntegrationsService, type IntegrationProviderName } from "./integrations.service"; | |
| import { IntegrationHealthService } from "./integration-health.service"; | |
| import { | |
| calComBookingSchema, type CalComBookingInput, | |
| documensoSendDocumentSchema, type DocumensoSendDocumentInput, | |
| documensoDocumentStatusSchema, type DocumensoDocumentStatusInput, | |
| } from "@micprotocol/shared-types"; | |
| const ALL_PROVIDERS = [ | |
| "google_calendar", | |
| "google_mail", | |
| "outlook", | |
| "riverside", | |
| "zoom", | |
| "cloudflare_r2", | |
| // Self-hosted open-source integration providers | |
| "calcom", | |
| "chatwoot", | |
| "documenso", | |
| "formbricks", | |
| "listmonk", | |
| "pretix", | |
| ] as const; | |
| const SELF_HOSTED_PROVIDERS = [ | |
| "calcom", | |
| "chatwoot", | |
| "documenso", | |
| "formbricks", | |
| "listmonk", | |
| "pretix", | |
| ] as const; | |
| const workspaceIdInput = z.object({ workspaceId: z.string().uuid() }); | |
| const providerInput = z.object({ | |
| workspaceId: z.string().uuid(), | |
| provider: z.enum(ALL_PROVIDERS), | |
| }); | |
| const selfHostedCredentialsSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| provider: z.enum(["calcom", "chatwoot", "documenso", "formbricks", "listmonk", "pretix"]), | |
| apiKey: z.string().min(1, "API key is required"), | |
| baseUrl: z.string().url().optional(), | |
| webhookSecret: z.string().optional(), | |
| }); | |
| const r2CredentialsSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| accessKeyId: z.string().min(1, "Access Key ID is required"), | |
| secretAccessKey: z.string().min(1, "Secret Access Key is required"), | |
| accountId: z.string().optional(), | |
| }); | |
| const syncCalendarSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| provider: z.enum(["google_calendar", "outlook"]), | |
| }); | |
| const calendarEventSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| provider: z.enum(["google_calendar", "outlook"]), | |
| eventData: z.object({ | |
| title: z.string().min(1).max(500), | |
| description: z.string().max(5000).optional(), | |
| startTime: z.string().datetime(), | |
| endTime: z.string().datetime(), | |
| timezone: z.string().optional(), | |
| location: z.string().max(500).optional(), | |
| meetLink: z.string().url().optional(), | |
| attendees: z | |
| .array( | |
| z.object({ | |
| email: z.string().email(), | |
| name: z.string().optional(), | |
| }), | |
| ) | |
| .optional(), | |
| }), | |
| }); | |
| const getEventsSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| provider: z.enum(["google_calendar", "outlook"]), | |
| timeMin: z.string().datetime().optional(), | |
| timeMax: z.string().datetime().optional(), | |
| }); | |
| const chatwootConversationSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| conversationId: z.number(), | |
| }); | |
| const chatwootMessageSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| conversationId: z.number(), | |
| content: z.string().min(1).max(5000), | |
| }); | |
| const chatwootCreateConversationSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| inboxId: z.number(), | |
| contactName: z.string().min(1), | |
| contactEmail: z.string().email(), | |
| contactPhone: z.string().optional(), | |
| message: z.string().min(1).max(5000), | |
| customAttributes: z.record(z.string(), z.any()).optional(), | |
| }); | |
| const webhookSecretSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| provider: z.enum(["calcom", "chatwoot", "documenso", "formbricks", "listmonk", "pretix"]), | |
| secret: z.string().min(1, "Webhook secret is required"), | |
| }); | |
| const pretixEventsSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| organizer: z.string().min(1, "Organizer slug is required"), | |
| }); | |
| const pretixItemsSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| organizer: z.string().min(1, "Organizer slug is required"), | |
| event: z.string().min(1, "Event slug is required"), | |
| }); | |
| const pretixOrdersSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| organizer: z.string().min(1, "Organizer slug is required"), | |
| event: z.string().min(1, "Event slug is required"), | |
| }); | |
| const pretixOrderPositionsSchema = z.object({ | |
| workspaceId: z.string().uuid(), | |
| organizer: z.string().min(1, "Organizer slug is required"), | |
| event: z.string().min(1, "Event slug is required"), | |
| order: z.string().min(1, "Order code is required"), | |
| }); | |
| () | |
| export class IntegrationsRouter { | |
| constructor( | |
| private readonly integrationsService: IntegrationsService, | |
| private readonly healthService: IntegrationHealthService, | |
| ) {} | |
| get router() { | |
| return router({ | |
| // ═══ Provider Metadata ════════════════════════ | |
| getAllProviders: protectedProcedure.query(async () => { | |
| return this.integrationsService.getAllProviders(); | |
| }), | |
| // ═══ Integration CRUD ═══════════════════════ | |
| list: workspaceProcedure | |
| .input(workspaceIdInput) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.listIntegrations( | |
| input.workspaceId, | |
| ctx.userId!, | |
| ); | |
| }), | |
| get: workspaceProcedure | |
| .input(providerInput) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.getIntegration( | |
| input.workspaceId, | |
| input.provider as IntegrationProviderName, | |
| ctx.userId!, | |
| ); | |
| }), | |
| disconnect: workspaceProcedure | |
| .input(providerInput) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.disconnectIntegration( | |
| input.workspaceId, | |
| input.provider as IntegrationProviderName, | |
| ctx.userId!, | |
| ); | |
| }), | |
| // ═══ OAuth Flow ═════════════════════════════ | |
| getAuthUrl: workspaceProcedure | |
| .input(providerInput) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.getAuthUrl( | |
| input.workspaceId, | |
| input.provider as IntegrationProviderName, | |
| ctx.userId!, | |
| ); | |
| }), | |
| handleCallback: protectedProcedure | |
| .input( | |
| z.object({ | |
| code: z.string(), | |
| state: z.string(), | |
| }), | |
| ) | |
| .mutation(async ({ input }) => { | |
| return this.integrationsService.handleOAuthCallback( | |
| input.code, | |
| input.state, | |
| ); | |
| }), | |
| // ═══ API Key Integrations ═════════════════════ | |
| // R2 API key — Studio plan feature | |
| updateR2Integration: requireFeature(SubscriptionFeature.API_WEBHOOKS) | |
| .input(r2CredentialsSchema) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.updateApiKeyIntegration( | |
| input.workspaceId, | |
| "cloudflare_r2", | |
| ctx.userId!, | |
| { | |
| accessKeyId: input.accessKeyId, | |
| secretAccessKey: input.secretAccessKey, | |
| accountId: input.accountId, | |
| }, | |
| ); | |
| }), | |
| // Self-hosted integrations (Cal.com, Chatwoot, Documenso, Formbricks, Listmonk) | |
| updateSelfHostedIntegration: requireFeature(SubscriptionFeature.SELF_HOSTED_INTEGRATIONS) | |
| .input(selfHostedCredentialsSchema) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.updateApiKeyIntegration( | |
| input.workspaceId, | |
| input.provider, | |
| ctx.userId!, | |
| { | |
| apiKey: input.apiKey, | |
| baseUrl: input.baseUrl, | |
| webhookSecret: input.webhookSecret, | |
| }, | |
| ); | |
| }), | |
| // Check health of a self-hosted integration by hitting its health endpoint | |
| checkHealth: workspaceProcedure | |
| .input(providerInput) | |
| .query(async ({ ctx, input }) => { | |
| const integration = await this.integrationsService.getIntegration( | |
| input.workspaceId, | |
| input.provider as IntegrationProviderName, | |
| ctx.userId!, | |
| ); | |
| if (!integration) { | |
| return { alive: false, error: "Not connected" }; | |
| } | |
| const selfHosted = (integration as any).metadata?.baseUrl; | |
| if (!selfHosted) { | |
| return { alive: false, error: "No endpoint configured" }; | |
| } | |
| try { | |
| const res = await fetch(`${selfHosted}/health`, { | |
| signal: AbortSignal.timeout(5000), | |
| }); | |
| return { alive: res.ok, status: res.status }; | |
| } catch (e: any) { | |
| return { alive: false, error: e.message }; | |
| } | |
| }), | |
| // ═══ Calendar Sync ═══════════════════════════ | |
| syncCalendar: workspaceProcedure | |
| .input(syncCalendarSchema) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.syncCalendarEvents( | |
| input.workspaceId, | |
| ctx.userId!, | |
| input.provider, | |
| ); | |
| }), | |
| getSyncedEvents: workspaceProcedure | |
| .input(getEventsSchema) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.getSyncedEvents( | |
| input.workspaceId, | |
| input.provider, | |
| ctx.userId!, | |
| input.timeMin, | |
| input.timeMax, | |
| ); | |
| }), | |
| createCalendarEvent: workspaceProcedure | |
| .input(calendarEventSchema) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.createCalendarEvent( | |
| input.workspaceId, | |
| ctx.userId!, | |
| input.provider, | |
| input.eventData, | |
| ); | |
| }), | |
| // ═══ Cal.com Scheduling ══════════════════════════════════════ | |
| listCalComEventTypes: workspaceProcedure | |
| .input(workspaceIdInput) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.listCalComEventTypes( | |
| input.workspaceId, | |
| ctx.userId!, | |
| ); | |
| }), | |
| createCalComBooking: workspaceProcedure | |
| .input(calComBookingSchema) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.createCalComBooking( | |
| input.workspaceId, | |
| ctx.userId!, | |
| { | |
| eventTypeId: input.eventTypeId, | |
| start: input.start, | |
| attendee: input.attendee, | |
| meetingUrl: input.meetingUrl, | |
| }, | |
| ); | |
| }), | |
| // ═══ Documenso E-Signatures ══════════════════════════════════════════════════ | |
| sendDocumensoDocument: workspaceProcedure | |
| .input(documensoSendDocumentSchema) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.sendDocument( | |
| input.workspaceId, | |
| { | |
| title: input.document.title, | |
| recipients: (input.document.recipients ?? []).map((r: { email: string; name?: string }) => ({ | |
| email: r.email, | |
| name: r.name ?? "", | |
| })), | |
| }, | |
| ); | |
| }), | |
| getDocumensoDocumentStatus: workspaceProcedure | |
| .input(documensoDocumentStatusSchema) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.getDocumensoDocumentStatus( | |
| input.workspaceId, | |
| Number(input.documentId), | |
| ); | |
| }), | |
| // ═══ Listmonk Newsletters ══════════════════════════════════════════════════════ | |
| listListmonkLists: workspaceProcedure | |
| .input(workspaceIdInput) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.listListmonkLists(input.workspaceId); | |
| }), | |
| createListmonkList: workspaceProcedure | |
| .input( | |
| z.object({ | |
| workspaceId: z.string().uuid(), | |
| name: z.string().min(1), | |
| type: z.enum(["public", "private", "optin"]).optional(), | |
| }), | |
| ) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.createListmonkList(input.workspaceId, { | |
| name: input.name, | |
| type: input.type ?? "public", | |
| }); | |
| }), | |
| subscribeListmonkSubscriber: workspaceProcedure | |
| .input( | |
| z.object({ | |
| workspaceId: z.string().uuid(), | |
| listId: z.number(), | |
| email: z.string().email(), | |
| name: z.string().optional(), | |
| attrs: z.record(z.string(), z.any()).optional(), | |
| }), | |
| ) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.subscribeListmonkSubscriber(input.workspaceId, { | |
| listId: input.listId, | |
| email: input.email, | |
| name: input.name, | |
| attrs: input.attrs, | |
| }); | |
| }), | |
| sendListmonkTransactional: workspaceProcedure | |
| .input( | |
| z.object({ | |
| workspaceId: z.string().uuid(), | |
| to: z.string().email(), | |
| subject: z.string().min(1), | |
| body: z.string().min(1), | |
| type: z.enum(["html", "plain"]).optional(), | |
| }), | |
| ) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.sendListmonkEmail(input.workspaceId, { | |
| to: input.to, | |
| subject: input.subject, | |
| body: input.body, | |
| type: input.type, | |
| }); | |
| }), | |
| // ═══ Chatwoot Customer Support ═════════════════════════════════════ | |
| getChatwootConversations: workspaceProcedure | |
| .input(workspaceIdInput) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.getChatwootConversations( | |
| input.workspaceId, | |
| ctx.userId!, | |
| ); | |
| }), | |
| getChatwootMessages: workspaceProcedure | |
| .input(chatwootConversationSchema) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.getChatwootMessages( | |
| input.workspaceId, | |
| ctx.userId!, | |
| input.conversationId, | |
| ); | |
| }), | |
| sendChatwootMessage: workspaceProcedure | |
| .input(chatwootMessageSchema) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.sendChatwootMessage( | |
| input.workspaceId, | |
| ctx.userId!, | |
| { | |
| conversationId: input.conversationId, | |
| content: input.content, | |
| }, | |
| ); | |
| }), | |
| createChatwootConversation: workspaceProcedure | |
| .input(chatwootCreateConversationSchema) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.createChatwootConversation( | |
| input.workspaceId, | |
| ctx.userId!, | |
| { | |
| inboxId: input.inboxId, | |
| contactName: input.contactName, | |
| contactEmail: input.contactEmail, | |
| contactPhone: input.contactPhone, | |
| message: input.message, | |
| customAttributes: input.customAttributes, | |
| }, | |
| ); | |
| }), | |
| // ═══ Pretix Ticketing ═══════════════════════════════════════════════════════════ | |
| listPretixEvents: workspaceProcedure | |
| .input(pretixEventsSchema) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.listPretixEvents( | |
| input.workspaceId, | |
| ctx.userId!, | |
| input.organizer, | |
| ); | |
| }), | |
| listPretixItems: workspaceProcedure | |
| .input(pretixItemsSchema) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.listPretixItems( | |
| input.workspaceId, | |
| ctx.userId!, | |
| input.organizer, | |
| input.event, | |
| ); | |
| }), | |
| listPretixOrders: workspaceProcedure | |
| .input(pretixOrdersSchema) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.listPretixOrders( | |
| input.workspaceId, | |
| ctx.userId!, | |
| input.organizer, | |
| input.event, | |
| ); | |
| }), | |
| listPretixOrderPositions: workspaceProcedure | |
| .input(pretixOrderPositionsSchema) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.listPretixOrderPositions( | |
| input.workspaceId, | |
| ctx.userId!, | |
| input.organizer, | |
| input.event, | |
| input.order, | |
| ); | |
| }), | |
| // ═══ Monitoring ═══════════════════════ | |
| getHealth: protectedProcedure.query(async () => { | |
| return this.healthService.getHealthResults(); | |
| }), | |
| getWebhookDeliveries: protectedProcedure | |
| .input(z.object({ limit: z.number().int().min(1).max(500).optional() })) | |
| .query(async ({ input }) => { | |
| return this.healthService.getWebhookDeliveries(input.limit ?? 50); | |
| }), | |
| // ═══ Self-Hosted Integration Management ═══ | |
| listSelfHosted: workspaceProcedure | |
| .input(workspaceIdInput) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.listSelfHostedIntegrations( | |
| input.workspaceId, | |
| ctx.userId!, | |
| ); | |
| }), | |
| updateWebhookSecret: workspaceProcedure | |
| .input(webhookSecretSchema) | |
| .mutation(async ({ ctx, input }) => { | |
| return this.integrationsService.updateWebhookSecret( | |
| input.workspaceId, | |
| input.provider, | |
| input.secret, | |
| ctx.userId!, | |
| ); | |
| }), | |
| // ═══ Provider Metrics ═══════════════════ | |
| getMetrics: protectedProcedure.query(async () => { | |
| return this.integrationsService.getProviderMetrics(); | |
| }), | |
| // ═══ Stats ═══════════════════════════════════ | |
| getStats: workspaceProcedure | |
| .input(workspaceIdInput) | |
| .query(async ({ ctx, input }) => { | |
| return this.integrationsService.getIntegrationStats( | |
| input.workspaceId, | |
| ctx.userId!, | |
| ); | |
| }), | |
| }); | |
| } | |
| } | |