Supabase Removals Backend

backend/src/modules/helpdesk/helpdesk.contact.service.ts

@@ -1,5 +1,7 @@
 // modules/helpdesk/helpdesk.contact.service.ts
 import { FastifyInstance } from 'fastify'
+import { and, eq, or } from "drizzle-orm";
+import { helpdesk_contacts } from "../../../db/schema";
 
 export async function getOrCreateContact(
     server: FastifyInstance,
@@ -9,30 +11,35 @@ export async function getOrCreateContact(
     if (!email && !phone) throw new Error('Contact must have at least an email or phone')
 
     // Bestehenden Kontakt prüfen
-    const { data: existing, error: findError } = await server.supabase
-        .from('helpdesk_contacts')
-        .select('*')
-        .eq('tenant_id', tenant_id)
-        .or(`email.eq.${email || ''},phone.eq.${phone || ''}`)
-        .maybeSingle()
+    const matchConditions = []
+    if (email) matchConditions.push(eq(helpdesk_contacts.email, email))
+    if (phone) matchConditions.push(eq(helpdesk_contacts.phone, phone))
 
-    if (findError) throw findError
-    if (existing) return existing
+    const existing = await server.db
+        .select()
+        .from(helpdesk_contacts)
+        .where(
+            and(
+                eq(helpdesk_contacts.tenantId, tenant_id),
+                or(...matchConditions)
+            )
+        )
+        .limit(1)
+
+    if (existing[0]) return existing[0]
 
     // Anlegen
-    const { data: created, error: insertError } = await server.supabase
-        .from('helpdesk_contacts')
-        .insert({
-            tenant_id,
+    const created = await server.db
+        .insert(helpdesk_contacts)
+        .values({
+            tenantId: tenant_id,
             email,
             phone,
-            display_name,
-            customer_id,
-            contact_id
+            displayName: display_name,
+            customerId: customer_id,
+            contactId: contact_id
         })
-        .select()
-        .single()
+        .returning()
 
-    if (insertError) throw insertError
-    return created
+    return created[0]
 }

backend/src/modules/helpdesk/helpdesk.conversation.service.ts

@@ -2,6 +2,8 @@
 import { FastifyInstance } from 'fastify'
 import { getOrCreateContact } from './helpdesk.contact.service.js'
 import {useNextNumberRangeNumber} from "../../utils/functions";
+import { and, desc, eq } from "drizzle-orm";
+import { customers, helpdesk_contacts, helpdesk_conversations } from "../../../db/schema";
 
 export async function createConversation(
     server: FastifyInstance,
@@ -25,24 +27,34 @@ export async function createConversation(
 
     const {usedNumber } = await useNextNumberRangeNumber(server, tenant_id, "tickets")
 
-    const { data, error } = await server.supabase
-        .from('helpdesk_conversations')
-        .insert({
-            tenant_id,
-            contact_id: contactRecord.id,
-            channel_instance_id,
+    const inserted = await server.db
+        .insert(helpdesk_conversations)
+        .values({
+            tenantId: tenant_id,
+            contactId: contactRecord.id,
+            channelInstanceId: channel_instance_id,
             subject: subject || null,
             status: 'open',
-            created_at: new Date().toISOString(),
-            customer_id,
-            contact_person_id,
-            ticket_number: usedNumber
+            createdAt: new Date(),
+            customerId: customer_id,
+            contactPersonId: contact_person_id,
+            ticketNumber: usedNumber
         })
-        .select()
-        .single()
+        .returning()
 
-    if (error) throw error
-    return data
+    const data = inserted[0]
+
+    return {
+        ...data,
+        channel_instance_id: data.channelInstanceId,
+        contact_id: data.contactId,
+        contact_person_id: data.contactPersonId,
+        created_at: data.createdAt,
+        customer_id: data.customerId,
+        last_message_at: data.lastMessageAt,
+        tenant_id: data.tenantId,
+        ticket_number: data.ticketNumber,
+    }
 }
 
 export async function getConversations(
@@ -52,22 +64,34 @@ export async function getConversations(
 ) {
     const { status, limit = 50 } = opts || {}
 
-    let query = server.supabase.from('helpdesk_conversations').select('*, customer_id(*)').eq('tenant_id', tenant_id)
+    const filters = [eq(helpdesk_conversations.tenantId, tenant_id)]
+    if (status) filters.push(eq(helpdesk_conversations.status, status))
 
-    if (status) query = query.eq('status', status)
-    query = query.order('last_message_at', { ascending: false }).limit(limit)
+    const data = await server.db
+        .select({
+            conversation: helpdesk_conversations,
+            contact: helpdesk_contacts,
+            customer: customers,
+        })
+        .from(helpdesk_conversations)
+        .leftJoin(helpdesk_contacts, eq(helpdesk_contacts.id, helpdesk_conversations.contactId))
+        .leftJoin(customers, eq(customers.id, helpdesk_conversations.customerId))
+        .where(and(...filters))
+        .orderBy(desc(helpdesk_conversations.lastMessageAt))
+        .limit(limit)
 
-    const { data, error } = await query
-    if (error) throw error
-
-    const mappedData = data.map(entry => {
-        return {
-            ...entry,
-            customer: entry.customer_id
-        }
-    })
-
-    return mappedData
+    return data.map((entry) => ({
+        ...entry.conversation,
+        helpdesk_contacts: entry.contact,
+        channel_instance_id: entry.conversation.channelInstanceId,
+        contact_id: entry.conversation.contactId,
+        contact_person_id: entry.conversation.contactPersonId,
+        created_at: entry.conversation.createdAt,
+        customer_id: entry.customer,
+        last_message_at: entry.conversation.lastMessageAt,
+        tenant_id: entry.conversation.tenantId,
+        ticket_number: entry.conversation.ticketNumber,
+    }))
 }
 
 export async function updateConversationStatus(
@@ -78,13 +102,22 @@ export async function updateConversationStatus(
     const valid = ['open', 'in_progress', 'waiting_for_customer', 'answered', 'closed']
     if (!valid.includes(status)) throw new Error('Invalid status')
 
-    const { data, error } = await server.supabase
-        .from('helpdesk_conversations')
-        .update({ status })
-        .eq('id', conversation_id)
-        .select()
-        .single()
+    const updated = await server.db
+        .update(helpdesk_conversations)
+        .set({ status })
+        .where(eq(helpdesk_conversations.id, conversation_id))
+        .returning()
 
-    if (error) throw error
-    return data
+    const data = updated[0]
+    return {
+        ...data,
+        channel_instance_id: data.channelInstanceId,
+        contact_id: data.contactId,
+        contact_person_id: data.contactPersonId,
+        created_at: data.createdAt,
+        customer_id: data.customerId,
+        last_message_at: data.lastMessageAt,
+        tenant_id: data.tenantId,
+        ticket_number: data.ticketNumber,
+    }
 }

backend/src/modules/helpdesk/helpdesk.message.service.ts

@@ -1,5 +1,7 @@
 // modules/helpdesk/helpdesk.message.service.ts
 import { FastifyInstance } from 'fastify'
+import { asc, eq } from "drizzle-orm";
+import { helpdesk_conversations, helpdesk_messages } from "../../../db/schema";
 
 export async function addMessage(
     server: FastifyInstance,
@@ -23,38 +25,53 @@ export async function addMessage(
 ) {
     if (!payload?.text) throw new Error('Message payload requires text content')
 
-    const { data: message, error } = await server.supabase
-        .from('helpdesk_messages')
-        .insert({
-            tenant_id,
-            conversation_id,
-            author_user_id,
+    const inserted = await server.db
+        .insert(helpdesk_messages)
+        .values({
+            tenantId: tenant_id,
+            conversationId: conversation_id,
+            authorUserId: author_user_id,
             direction,
             payload,
-            raw_meta,
-            created_at: new Date().toISOString(),
+            rawMeta: raw_meta,
+            externalMessageId: external_message_id,
+            receivedAt: new Date(),
         })
-        .select()
-        .single()
+        .returning()
 
-    if (error) throw error
+    const message = inserted[0]
 
     // Letzte Nachricht aktualisieren
-    await server.supabase
-        .from('helpdesk_conversations')
-        .update({ last_message_at: new Date().toISOString() })
-        .eq('id', conversation_id)
+    await server.db
+        .update(helpdesk_conversations)
+        .set({ lastMessageAt: new Date() })
+        .where(eq(helpdesk_conversations.id, conversation_id))
 
-    return message
+    return {
+        ...message,
+        author_user_id: message.authorUserId,
+        conversation_id: message.conversationId,
+        created_at: message.createdAt,
+        external_message_id: message.externalMessageId,
+        raw_meta: message.rawMeta,
+        tenant_id: message.tenantId,
+    }
 }
 
 export async function getMessages(server: FastifyInstance, conversation_id: string) {
-    const { data, error } = await server.supabase
-        .from('helpdesk_messages')
-        .select('*')
-        .eq('conversation_id', conversation_id)
-        .order('created_at', { ascending: true })
+    const data = await server.db
+        .select()
+        .from(helpdesk_messages)
+        .where(eq(helpdesk_messages.conversationId, conversation_id))
+        .orderBy(asc(helpdesk_messages.createdAt))
 
-    if (error) throw error
-    return data
+    return data.map((message) => ({
+        ...message,
+        author_user_id: message.authorUserId,
+        conversation_id: message.conversationId,
+        created_at: message.createdAt,
+        external_message_id: message.externalMessageId,
+        raw_meta: message.rawMeta,
+        tenant_id: message.tenantId,
+    }))
 }

backend/src/modules/notification.service.ts

@@ -1,6 +1,8 @@
 // services/notification.service.ts
 import type { FastifyInstance } from 'fastify';
 import {secrets} from "../utils/secrets";
+import { eq } from "drizzle-orm";
+import { notificationsEventTypes, notificationsItems } from "../../db/schema";
 
 export type NotificationStatus = 'queued' | 'sent' | 'failed';
 
@@ -34,16 +36,16 @@ export class NotificationService {
      */
     async trigger(input: TriggerInput) {
         const { tenantId, userId, eventType, title, message, payload } = input;
-        const supabase = this.server.supabase;
 
         // 1) Event-Typ prüfen (aktiv?)
-        const { data: eventTypeRow, error: etErr } = await supabase
-            .from('notifications_event_types')
-            .select('event_key,is_active')
-            .eq('event_key', eventType)
-            .maybeSingle();
+        const eventTypeRows = await this.server.db
+            .select()
+            .from(notificationsEventTypes)
+            .where(eq(notificationsEventTypes.eventKey, eventType))
+            .limit(1)
+        const eventTypeRow = eventTypeRows[0]
 
-        if (etErr || !eventTypeRow || eventTypeRow.is_active !== true) {
+        if (!eventTypeRow || eventTypeRow.isActive !== true) {
             throw new Error(`Unbekannter oder inaktiver Event-Typ: ${eventType}`);
         }
 
@@ -54,40 +56,40 @@ export class NotificationService {
         }
 
         // 3) Notification anlegen (status: queued)
-        const { data: inserted, error: insErr } = await supabase
-            .from('notifications_items')
-            .insert({
-                tenant_id: tenantId,
-                user_id: userId,
-                event_type: eventType,
+        const insertedRows = await this.server.db
+            .insert(notificationsItems)
+            .values({
+                tenantId,
+                userId,
+                eventType,
                 title,
                 message,
                 payload: payload ?? null,
                 channel: 'email',
                 status: 'queued'
             })
-            .select('id')
-            .single();
+            .returning({ id: notificationsItems.id })
+        const inserted = insertedRows[0]
 
-        if (insErr || !inserted) {
-            throw new Error(`Fehler beim Einfügen der Notification: ${insErr?.message}`);
+        if (!inserted) {
+            throw new Error("Fehler beim Einfügen der Notification");
         }
 
         // 4) E-Mail versenden
         try {
             await this.sendEmail(user.email, title, message);
 
-            await supabase
-                .from('notifications_items')
-                .update({ status: 'sent', sent_at: new Date().toISOString() })
-                .eq('id', inserted.id);
+            await this.server.db
+                .update(notificationsItems)
+                .set({ status: 'sent', sentAt: new Date() })
+                .where(eq(notificationsItems.id, inserted.id));
 
             return { success: true, id: inserted.id };
         } catch (err: any) {
-            await supabase
-                .from('notifications_items')
-                .update({ status: 'failed', error: String(err?.message || err) })
-                .eq('id', inserted.id);
+            await this.server.db
+                .update(notificationsItems)
+                .set({ status: 'failed', error: String(err?.message || err) })
+                .where(eq(notificationsItems.id, inserted.id));
 
             this.server.log.error({ err, notificationId: inserted.id }, 'E-Mail Versand fehlgeschlagen');
             return { success: false, error: err?.message || 'E-Mail Versand fehlgeschlagen' };