realtimex-crm 0.1.2

package/supabase/config.toml

@@ -0,0 +1,157 @@
+# A string used to distinguish different Supabase projects on the same host. Defaults to the
+# working directory name when running `supabase init`.
+project_id = "atomic-crm-demo"
+
+[api]
+enabled = true
+# Port to use for the API URL.
+port = 54321
+# Schemas to expose in your API. Tables, views and stored procedures in this schema will get API
+# endpoints. public and storage are always included.
+schemas = ["public", "storage", "graphql_public"]
+# Extra schemas to add to the search_path of every request. public is always included.
+extra_search_path = ["public", "extensions"]
+# The maximum number of rows returns from a view, table, or stored procedure. Limits payload size
+# for accidental or malicious requests.
+max_rows = 1000
+
+[db]
+# Port to use for the local database URL.
+port = 54322
+# Port used by db diff command to initialize the shadow database.
+shadow_port = 54320
+# The database major version to use. This has to be the same as your remote database's. Run `SHOW
+# server_version;` on the remote database to check.
+major_version = 15
+
+[db.pooler]
+enabled = false
+# Port to use for the local connection pooler.
+port = 54329
+# Specifies when a server connection can be reused by other clients.
+# Configure one of the supported pooler modes: `transaction`, `session`.
+pool_mode = "transaction"
+# How many server connections to allow per user/database pair.
+default_pool_size = 20
+# Maximum number of client connections allowed.
+max_client_conn = 100
+
+[realtime]
+enabled = true
+# Bind realtime via either IPv4 or IPv6. (default: IPv6)
+# ip_version = "IPv6"
+# The maximum length in bytes of HTTP request headers. (default: 4096)
+# max_header_length = 4096
+
+[studio]
+enabled = true
+# Port to use for Supabase Studio.
+port = 54323
+# External URL of the API server that frontend connects to.
+api_url = "http://127.0.0.1"
+
+# Email testing server. Emails sent with the local dev setup are not actually sent - rather, they
+# are monitored, and you can view the emails that would have been sent from the web interface.
+[inbucket]
+enabled = true
+# Port to use for the email testing server web interface.
+port = 54324
+# Uncomment to expose additional ports for testing user applications that send emails.
+# smtp_port = 54325
+# pop3_port = 54326
+
+[storage]
+enabled = true
+# The maximum file size allowed (e.g. "5MB", "500KB").
+file_size_limit = "50MiB"
+
+[auth]
+enabled = true
+# The base URL of your website. Used as an allow-list for redirects and for constructing URLs used
+# in emails.
+site_url = "http://localhost:5173/"
+# A list of *exact* URLs that auth providers are permitted to redirect to post authentication.
+additional_redirect_urls = ["https://localhost:5173/auth-callback.html"]
+# How long tokens are valid for, in seconds. Defaults to 3600 (1 hour), maximum 604,800 (1 week).
+jwt_expiry = 3600
+# If disabled, the refresh token will never expire.
+enable_refresh_token_rotation = true
+# Allows refresh tokens to be reused after expiry, up to the specified interval in seconds.
+# Requires enable_refresh_token_rotation = true.
+refresh_token_reuse_interval = 10
+# Allow/disallow new user signups to your project.
+enable_signup = true
+
+[auth.email]
+# Allow/disallow new user signups via email to your project.
+enable_signup = true
+# If enabled, a user will be required to confirm any email change on both the old, and new email
+# addresses. If disabled, only the new email is required to confirm.
+double_confirm_changes = true
+# If enabled, users need to confirm their email address before signing in.
+enable_confirmations = false
+
+[auth.email.template.invite]
+subject = "You've been invited to Atomic CRM"
+content_path = "./supabase/templates/invite.html"
+
+[auth.email.template.recovery]
+subject = "Reset your Atomic CRM Password"
+content_path = "./supabase/templates/recovery.html"
+
+[auth.sms]
+# Allow/disallow new user signups via SMS to your project.
+enable_signup = true
+# If enabled, users need to confirm their phone number before signing in.
+enable_confirmations = false
+# Template for sending OTP to users
+template = "Your code is {{ .Code }} ."
+
+# Use pre-defined map of phone number to OTP for testing.
+[auth.sms.test_otp]
+# 4152127777 = "123456"
+
+# Configure one of the supported SMS providers: `twilio`, `twilio_verify`, `messagebird`, `textlocal`, `vonage`.
+[auth.sms.twilio]
+enabled = false
+account_sid = ""
+message_service_sid = ""
+# DO NOT commit your Twilio auth token to git. Use environment variable substitution instead:
+auth_token = "env(SUPABASE_AUTH_SMS_TWILIO_AUTH_TOKEN)"
+
+# Use an external OAuth provider. The full list of providers are: `apple`, `azure`, `bitbucket`,
+# `discord`, `facebook`, `github`, `gitlab`, `google`, `keycloak`, `linkedin`, `notion`, `twitch`,
+# `twitter`, `slack`, `spotify`, `workos`, `zoom`.
+[auth.external.apple]
+enabled = false
+client_id = ""
+# DO NOT commit your OAuth provider secret to git. Use environment variable substitution instead:
+secret = "env(SUPABASE_AUTH_EXTERNAL_APPLE_SECRET)"
+# Overrides the default auth redirectUrl.
+redirect_uri = ""
+# Overrides the default auth provider URL. Used to support self-hosted gitlab, single-tenant Azure,
+# or any other third-party OIDC providers.
+url = ""
+
+[analytics]
+enabled = false
+port = 54327
+vector_port = 54328
+# Configure one of the supported backends: `postgres`, `bigquery`.
+backend = "postgres"
+
+# Experimental features may be deprecated any time
+[experimental]
+# Configures Postgres storage engine to use OrioleDB (S3)
+orioledb_version = ""
+# Configures S3 bucket URL, eg. <bucket_name>.s3-<region>.amazonaws.com
+s3_host = "env(S3_HOST)"
+# Configures S3 bucket region, eg. us-east-1
+s3_region = "env(S3_REGION)"
+# Configures AWS_ACCESS_KEY_ID for S3 bucket
+s3_access_key = "env(S3_ACCESS_KEY)"
+# Configures AWS_SECRET_ACCESS_KEY for S3 bucket
+s3_secret_key = "env(S3_SECRET_KEY)"
+
+[functions.postmark]
+verify_jwt = false

package/supabase/functions/.env.development

@@ -0,0 +1,7 @@
+POSTMARK_WEBHOOK_USER=testuser
+POSTMARK_WEBHOOK_PASSWORD=testpwd
+
+# IPs can be found at https://postmarkapp.com/support/article/800-ips-for-firewalls#webhooks
+# 172.18.0.1 and 172.19.0.1 are for local dev only
+# 192.168.65.1 is for Docker Desktop on Mac
+POSTMARK_WEBHOOK_AUTHORIZED_IPS=3.134.147.250,50.31.156.6,50.31.156.77,18.217.206.57,172.18.0.1,172.19.0.1,192.168.65.1

package/supabase/functions/_shared/db.ts

@@ -0,0 +1,187 @@
+import type {
+  DatabaseConnection,
+  Driver,
+  QueryResult,
+} from "https://esm.sh/kysely@0.27.2";
+import {
+  CompiledQuery,
+  Kysely,
+  PostgresAdapter,
+  PostgresIntrospector,
+  PostgresQueryCompiler,
+  type Generated,
+} from "https://esm.sh/kysely@0.27.2";
+
+export { CompiledQuery };
+import type { PoolClient } from "https://deno.land/x/postgres@v0.17.0/mod.ts";
+import { Pool } from "https://deno.land/x/postgres@v0.17.0/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(),
+  },
+});

package/supabase/functions/_shared/supabaseAdmin.ts

@@ -0,0 +1,13 @@
+import type { SupabaseClient } from "jsr:@supabase/supabase-js@2";
+import { createClient } from "jsr:@supabase/supabase-js@2";
+
+export const supabaseAdmin: SupabaseClient = createClient(
+  Deno.env.get("SUPABASE_URL") ?? "",
+  Deno.env.get("SUPABASE_SERVICE_ROLE_KEY") ?? "",
+  {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false,
+    },
+  },
+);

package/supabase/functions/_shared/utils.ts

@@ -0,0 +1,13 @@
+export const corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Headers":
+    "authorization, x-client-info, apikey, content-type",
+  "Access-Control-Allow-Methods": "POST, PATCH, DELETE",
+};
+
+export function createErrorResponse(status: number, message: string) {
+  return new Response(JSON.stringify({ status, message }), {
+    headers: { "Content-Type": "application/json", ...corsHeaders },
+    status,
+  });
+}

package/supabase/functions/mergeContacts/index.ts

@@ -0,0 +1,215 @@
+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/kysely@0.27.2";
+import { db, type ContactsTable, CompiledQuery } 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,
+  userId: string,
+) {
+  try {
+    return await db.transaction().execute(async (trx) => {
+      // Enable RLS by switching to authenticated role and setting user context
+      await trx.executeQuery(CompiledQuery.raw("SET LOCAL ROLE authenticated"));
+      await trx.executeQuery(
+        CompiledQuery.raw(
+          `SELECT set_config('request.jwt.claim.sub', '${userId}', true)`,
+        ),
+      );
+
+      // 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, user.id);
+
+      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");
+});