Skip to content

A full-featured CRM built with React, shadcn/ui, and Supabase.

Convert mergeContacts to edge functions for better DX

fzaninotto7191fd652564
diff --git a/src/components/atomic-crm/providers/supabase/dataProvider.ts b/src/components/atomic-crm/providers/supabase/dataProvider.ts
index 1bf45a9d..406eab0d 100644
--- a/src/components/atomic-crm/providers/supabase/dataProvider.ts
+++ b/src/components/atomic-crm/providers/supabase/dataProvider.ts
@@ -219,9 +219,9 @@ const dataProviderWithCustomMethods = {
return getIsInitialized();
},
async mergeContacts(sourceId: Identifier, targetId: Identifier) {
- const { data, error } = await supabase.rpc("merge_contacts", {
- loser_id: sourceId,
- winner_id: targetId,
+ const { data, error } = await supabase.functions.invoke("mergeContacts", {
+ method: "POST",
+ body: { loserId: sourceId, winnerId: targetId },
});
if (error) {
@@ -229,7 +229,7 @@ const dataProviderWithCustomMethods = {
throw new Error("Failed to merge contacts");
}
- return { success: true, winnerId: data };
+ return data;
},
} satisfies DataProvider;
diff --git a/supabase/functions/_shared/db.ts b/supabase/functions/_shared/db.ts
new file mode 100644
index 00000000..51dd8294
--- /dev/null
+++ b/supabase/functions/_shared/db.ts
@@ -0,0 +1,184 @@
+import type {
+ DatabaseConnection,
+ Driver,
+ QueryResult,
+} from "https://esm.sh/[email protected]";
+import {
+ CompiledQuery,
+ Kysely,
+ PostgresAdapter,
+ PostgresIntrospector,
+ PostgresQueryCompiler,
+ type Generated,
+} from "https://esm.sh/[email protected]";
+import type { PoolClient } from "https://deno.land/x/[email protected]/mod.ts";
+import { Pool } from "https://deno.land/x/[email protected]/mod.ts";
+
+// Database schema types
+export interface ContactsTable {
+ id: Generated<number>;
+ first_name: string | null;
+ last_name: string | null;
+ gender: string | null;
+ title: string | null;
+ email_jsonb: unknown | null; // JSONB array
+ phone_jsonb: unknown | null; // JSONB array
+ background: string | null;
+ avatar: unknown | null; // JSONB
+ first_seen: Date | null;
+ last_seen: Date | null;
+ has_newsletter: boolean | null;
+ status: string | null;
+ tags: number[] | null;
+ company_id: number | null;
+ sales_id: number | null;
+ linkedin_url: string | null;
+}
+
+interface TasksTable {
+ id: Generated<number>;
+ contact_id: number;
+ type: string | null;
+ text: string | null;
+ due_date: Date;
+ done_date: Date | null;
+ sales_id: number | null;
+}
+
+interface ContactNotesTable {
+ id: Generated<number>;
+ contact_id: number;
+ text: string | null;
+ date: Date | null;
+ sales_id: number | null;
+ status: string | null;
+ attachments: unknown[] | null; // JSONB array
+}
+
+interface DealsTable {
+ id: Generated<number>;
+ name: string;
+ company_id: number | null;
+ contact_ids: number[];
+ category: string | null;
+ stage: string;
+ description: string | null;
+ amount: number | null;
+ created_at: Date;
+ updated_at: Date;
+ archived_at: Date | null;
+ expected_closing_date: Date | null;
+ sales_id: number | null;
+ index: number | null;
+}
+
+interface Database {
+ contacts: ContactsTable;
+ tasks: TasksTable;
+ contactNotes: ContactNotesTable;
+ deals: DealsTable;
+}
+
+// Deno Postgres Driver for Kysely
+class DenoPostgresDriver implements Driver {
+ private pool: Pool;
+ private connections = new WeakMap<PoolClient, DatabaseConnection>();
+
+ constructor(pool: Pool) {
+ this.pool = pool;
+ }
+
+ async init(): Promise<void> {
+ // Connection pool is already initialized
+ }
+
+ async acquireConnection(): Promise<DatabaseConnection> {
+ const client = await this.pool.connect();
+ let connection = this.connections.get(client);
+
+ if (!connection) {
+ connection = new DenoPostgresConnection(client);
+ this.connections.set(client, connection);
+ }
+
+ return connection;
+ }
+
+ async beginTransaction(connection: DatabaseConnection): Promise<void> {
+ await connection.executeQuery(CompiledQuery.raw("begin"));
+ }
+
+ async commitTransaction(connection: DatabaseConnection): Promise<void> {
+ await connection.executeQuery(CompiledQuery.raw("commit"));
+ }
+
+ async rollbackTransaction(connection: DatabaseConnection): Promise<void> {
+ await connection.executeQuery(CompiledQuery.raw("rollback"));
+ }
+
+ async releaseConnection(connection: DatabaseConnection): Promise<void> {
+ (connection as DenoPostgresConnection).release();
+ }
+
+ async destroy(): Promise<void> {
+ await this.pool.end();
+ }
+}
+
+class DenoPostgresConnection implements DatabaseConnection {
+ private client: PoolClient;
+
+ constructor(client: PoolClient) {
+ this.client = client;
+ }
+
+ async executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>> {
+ const result = await this.client.queryObject<O>({
+ text: compiledQuery.sql,
+ args: compiledQuery.parameters as unknown[],
+ });
+
+ if (
+ result.command === "INSERT" ||
+ result.command === "UPDATE" ||
+ result.command === "DELETE"
+ ) {
+ return {
+ numAffectedRows: BigInt(result.rowCount ?? 0),
+ rows: result.rows ?? [],
+ };
+ }
+
+ return {
+ rows: result.rows ?? [],
+ };
+ }
+
+ streamQuery<O>(
+ _compiledQuery: CompiledQuery,
+ _chunkSize?: number,
+ ): AsyncIterableIterator<QueryResult<O>> {
+ throw new Error("Deno Postgres driver does not support streaming");
+ }
+
+ release() {
+ this.client.release();
+ }
+}
+
+// Create connection pool
+// Use SUPABASE_DB_URL if available (production), otherwise fall back to local dev connection string
+const connectionString = Deno.env.get("SUPABASE_DB_URL") ||
+ "postgresql://postgres:postgres@db:5432/postgres";
+
+const pool = new Pool(connectionString, 1); // Single connection for edge functions
+
+// Create and export Kysely instance
+export const db = new Kysely<Database>({
+ dialect: {
+ createAdapter: () => new PostgresAdapter(),
+ createDriver: () => new DenoPostgresDriver(pool),
+ createIntrospector: (db: Kysely<any>) => new PostgresIntrospector(db),
+ createQueryCompiler: () => new PostgresQueryCompiler(),
+ },
+});
diff --git a/supabase/functions/mergeContacts/index.ts b/supabase/functions/mergeContacts/index.ts
new file mode 100644
index 00000000..8a09fa9f
--- /dev/null
+++ b/supabase/functions/mergeContacts/index.ts
@@ -0,0 +1,203 @@
+import "jsr:@supabase/functions-js/edge-runtime.d.ts";
+import { createClient } from "jsr:@supabase/supabase-js@2";
+import { sql, type Selectable } from "https://esm.sh/[email protected]";
+import { db, type ContactsTable } from "../_shared/db.ts";
+import { corsHeaders, createErrorResponse } from "../_shared/utils.ts";
+
+type Contact = Selectable<ContactsTable>;
+
+// Helper functions to merge arrays
+function mergeArraysUnique<T>(arr1: T[], arr2: T[]): T[] {
+ return [...new Set([...arr1, ...arr2])];
+}
+
+function mergeObjectArraysUnique<T>(
+ arr1: T[],
+ arr2: T[],
+ getKey: (item: T) => string,
+): T[] {
+ const map = new Map<string, T>();
+
+ arr1.forEach((item) => {
+ const key = getKey(item);
+ if (key) map.set(key, item);
+ });
+
+ arr2.forEach((item) => {
+ const key = getKey(item);
+ if (key && !map.has(key)) {
+ map.set(key, item);
+ }
+ });
+
+ return Array.from(map.values());
+}
+
+function mergeContactData(winner: Contact, loser: Contact) {
+ // Merge emails
+ const mergedEmails = mergeObjectArraysUnique(
+ winner.email_jsonb || [],
+ loser.email_jsonb || [],
+ (email: any) => email.email,
+ );
+
+ // Merge phones
+ const mergedPhones = mergeObjectArraysUnique(
+ winner.phone_jsonb || [],
+ loser.phone_jsonb || [],
+ (phone: any) => phone.number,
+ );
+
+ const selectedAvatar =
+ winner.avatar && winner.avatar.src ? winner.avatar : loser.avatar;
+
+ return {
+ avatar: selectedAvatar ? (JSON.stringify(selectedAvatar) as any) : null,
+ gender: winner.gender ?? loser.gender,
+ first_name: winner.first_name ?? loser.first_name,
+ last_name: winner.last_name ?? loser.last_name,
+ title: winner.title ?? loser.title,
+ company_id: winner.company_id ?? loser.company_id,
+ email_jsonb: JSON.stringify(mergedEmails) as any,
+ phone_jsonb: JSON.stringify(mergedPhones) as any,
+ linkedin_url: winner.linkedin_url || loser.linkedin_url,
+ background: winner.background ?? loser.background,
+ has_newsletter: winner.has_newsletter ?? loser.has_newsletter,
+ first_seen: winner.first_seen ?? loser.first_seen,
+ last_seen:
+ winner.last_seen && loser.last_seen
+ ? winner.last_seen > loser.last_seen
+ ? winner.last_seen
+ : loser.last_seen
+ : (winner.last_seen ?? loser.last_seen),
+ sales_id: winner.sales_id ?? loser.sales_id,
+ tags: mergeArraysUnique(winner.tags || [], loser.tags || []),
+ };
+}
+
+async function mergeContacts(loserId: number, winnerId: number) {
+ try {
+ return await db.transaction().execute(async (trx) => {
+ // 1. Fetch both contacts
+ const [winner, loser] = await Promise.all([
+ trx
+ .selectFrom("contacts")
+ .selectAll()
+ .where("id", "=", winnerId)
+ .executeTakeFirstOrThrow(),
+ trx
+ .selectFrom("contacts")
+ .selectAll()
+ .where("id", "=", loserId)
+ .executeTakeFirstOrThrow(),
+ ]);
+
+ // 2. Reassign tasks from loser to winner
+ await trx
+ .updateTable("tasks")
+ .set({ contact_id: winnerId })
+ .where("contact_id", "=", loserId)
+ .execute();
+
+ // 3. Reassign notes from loser to winner
+ await trx
+ .updateTable("contactNotes")
+ .set({ contact_id: winnerId })
+ .where("contact_id", "=", loserId)
+ .execute();
+
+ // 4. Update deals - replace loserId with winnerId in contact_ids array
+ const deals = await trx
+ .selectFrom("deals")
+ .selectAll()
+ .where(sql`contact_ids @> ARRAY[${loserId}]::bigint[]`)
+ .execute();
+
+ for (const deal of deals) {
+ const newContactIds = [
+ ...new Set(
+ deal.contact_ids.filter((id) => id !== loserId).concat(winnerId),
+ ),
+ ];
+ await trx
+ .updateTable("deals")
+ .set({ contact_ids: newContactIds })
+ .where("id", "=", deal.id)
+ .execute();
+ }
+
+ // 5. Merge and update winner contact
+ const mergedData = mergeContactData(winner as Contact, loser as Contact);
+ await trx
+ .updateTable("contacts")
+ .set(mergedData)
+ .where("id", "=", winnerId)
+ .execute();
+
+ // 6. Delete loser contact
+ await trx.deleteFrom("contacts").where("id", "=", loserId).execute();
+
+ return { success: true, winnerId };
+ });
+ } catch (error) {
+ console.error("Transaction failed:", error);
+ throw error;
+ }
+}
+
+Deno.serve(async (req: Request) => {
+ // Handle CORS preflight
+ if (req.method === "OPTIONS") {
+ return new Response(null, {
+ status: 204,
+ headers: corsHeaders,
+ });
+ }
+
+ // Authenticate user via Supabase client (bypasses RLS, so we need explicit auth check)
+ const authHeader = req.headers.get("Authorization");
+ if (!authHeader) {
+ return createErrorResponse(401, "Missing Authorization header");
+ }
+
+ const supabaseClient = createClient(
+ Deno.env.get("SUPABASE_URL") ?? "",
+ Deno.env.get("SUPABASE_ANON_KEY") ?? "",
+ { global: { headers: { Authorization: authHeader } } },
+ );
+
+ const {
+ data: { user },
+ error: authError,
+ } = await supabaseClient.auth.getUser();
+ if (!user || authError) {
+ return createErrorResponse(401, "Unauthorized");
+ }
+
+ // Handle POST request
+ if (req.method === "POST") {
+ try {
+ const { loserId, winnerId } = await req.json();
+
+ if (!loserId || !winnerId) {
+ return createErrorResponse(400, "Missing loserId or winnerId");
+ }
+
+ const result = await mergeContacts(loserId, winnerId);
+
+ return new Response(JSON.stringify(result), {
+ headers: { "Content-Type": "application/json", ...corsHeaders },
+ });
+ } catch (error) {
+ console.error("Merge failed:", error);
+ return createErrorResponse(
+ 500,
+ `Failed to merge contacts: ${
+ error instanceof Error ? error.message : "Unknown error"
+ }`,
+ );
+ }
+ }
+
+ return createErrorResponse(405, "Method Not Allowed");
+});
diff --git a/supabase/migrations/20251204201317_drop_merge_contacts_function.sql b/supabase/migrations/20251204201317_drop_merge_contacts_function.sql
new file mode 100644
index 00000000..80da0658
--- /dev/null
+++ b/supabase/migrations/20251204201317_drop_merge_contacts_function.sql
@@ -0,0 +1,2 @@
+-- Drop the merge_contacts function (reverting to edge function approach)
+DROP FUNCTION IF EXISTS merge_contacts(bigint, bigint);