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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.sqlnew file mode 100644index 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);