realtimex-crm 0.9.10 → 0.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "realtimex-crm",
-  "version": "0.9.10",
+  "version": "0.11.2",
   "description": "RealTimeX CRM - A full-featured CRM built with React, shadcn-admin-kit, and Supabase. Fork of Atomic CRM with RealTimeX App SDK integration.",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/atomic-crm/companies/CompanyAside.tsx

@@ -13,6 +13,7 @@ import { AsideSection } from "../misc/AsideSection";
 import { SaleName } from "../sales/SaleName";
 import type { Company } from "../types";
 import { sizes } from "./sizes";
+import { CompanyMergeButton } from "./CompanyMergeButton";
 
 interface CompanyAsideProps {
   link?: string;
@@ -41,12 +42,17 @@ export const CompanyAside = ({ link = "edit" }: CompanyAsideProps) => {
       <AdditionalInfo record={record} />
 
       {link !== "edit" && (
-        <div className="mt-6 pt-6 border-t hidden sm:flex flex-col gap-2 items-start">
-          <DeleteButton
-            className="h-6 cursor-pointer hover:bg-destructive/10! text-destructive! border-destructive! focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40"
-            size="sm"
-          />
-        </div>
+        <>
+          <div className="mt-6 pt-6 border-t hidden sm:flex flex-col gap-2 items-start">
+            <CompanyMergeButton />
+          </div>
+          <div className="mt-6 pt-6 border-t hidden sm:flex flex-col gap-2 items-start">
+            <DeleteButton
+              className="h-6 cursor-pointer hover:bg-destructive/10! text-destructive! border-destructive! focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40"
+              size="sm"
+            />
+          </div>
+        </>
       )}
     </div>
   );

package/src/components/atomic-crm/companies/CompanyMergeButton.tsx

@@ -0,0 +1,237 @@
+import { useState, useEffect } from "react";
+import { Merge, CircleX, AlertTriangle, ArrowDown } from "lucide-react";
+import {
+  useDataProvider,
+  useRecordContext,
+  useGetList,
+  useGetManyReference,
+  required,
+  Form,
+  useNotify,
+  useRedirect,
+} from "ra-core";
+import type { Identifier } from "ra-core";
+import { useMutation } from "@tanstack/react-query";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogDescription,
+  DialogFooter,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { ReferenceInput } from "@/components/admin/reference-input";
+import { AutocompleteInput } from "@/components/admin/autocomplete-input";
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
+import type { Company } from "../types";
+
+export const CompanyMergeButton = () => {
+  const [mergeDialogOpen, setMergeDialogOpen] = useState(false);
+  return (
+    <>
+      <Button
+        variant="outline"
+        className="h-6 cursor-pointer"
+        size="sm"
+        onClick={() => setMergeDialogOpen(true)}
+      >
+        <Merge className="w-4 h-4" />
+        Merge with another company
+      </Button>
+      <CompanyMergeDialog
+        open={mergeDialogOpen}
+        onClose={() => setMergeDialogOpen(false)}
+      />
+    </>
+  );
+};
+
+interface CompanyMergeDialogProps {
+  open: boolean;
+  onClose: () => void;
+}
+
+const CompanyMergeDialog = ({ open, onClose }: CompanyMergeDialogProps) => {
+  const loserCompany = useRecordContext<Company>();
+  const notify = useNotify();
+  const redirect = useRedirect();
+  const dataProvider = useDataProvider();
+  const [winnerId, setWinnerId] = useState<Identifier | null>(null);
+  const [suggestedWinnerId, setSuggestedWinnerId] = useState<Identifier | null>(
+    null,
+  );
+  const [isMerging, setIsMerging] = useState(false);
+  const { mutateAsync } = useMutation({
+    mutationKey: ["companies", "merge", { loserId: loserCompany?.id, winnerId }],
+    mutationFn: async () => {
+      return dataProvider.mergeCompanies(loserCompany?.id, winnerId);
+    },
+  });
+
+  // Find potential companies with matching name
+  const { data: matchingCompanies } = useGetList(
+    "companies",
+    {
+      filter: {
+        name: loserCompany?.name,
+        "id@neq": `${loserCompany?.id}`, // Exclude current company
+      },
+      pagination: { page: 1, perPage: 10 },
+    },
+    { enabled: open && !!loserCompany },
+  );
+
+  // Get counts of items to be merged
+  const canFetchCounts = open && !!loserCompany && !!winnerId;
+  const { total: contactsCount } = useGetManyReference(
+    "contacts",
+    {
+      target: "company_id",
+      id: loserCompany?.id,
+      pagination: { page: 1, perPage: 1 },
+    },
+    { enabled: canFetchCounts },
+  );
+
+  const { total: dealsCount } = useGetManyReference(
+    "deals",
+    {
+      target: "company_id",
+      id: loserCompany?.id,
+      pagination: { page: 1, perPage: 1 },
+    },
+    { enabled: canFetchCounts },
+  );
+
+  useEffect(() => {
+    if (matchingCompanies && matchingCompanies.length > 0) {
+      const suggestedWinnerId = matchingCompanies[0].id;
+      setSuggestedWinnerId(suggestedWinnerId);
+      setWinnerId(suggestedWinnerId);
+    }
+  }, [matchingCompanies]);
+
+  const handleMerge = async () => {
+    if (!winnerId || !loserCompany) {
+      notify("Please select a company to merge with", { type: "warning" });
+      return;
+    }
+
+    try {
+      setIsMerging(true);
+      await mutateAsync();
+      setIsMerging(false);
+      notify("Companies merged successfully", { type: "success" });
+      redirect(`/companies/${winnerId}/show`);
+      onClose();
+    } catch (error) {
+      setIsMerging(false);
+      notify("Failed to merge companies", { type: "error" });
+      console.error("Merge failed:", error);
+    }
+  };
+
+  if (!loserCompany) return null;
+
+  return (
+    <Dialog open={open} onOpenChange={onClose}>
+      <DialogContent className="md:min-w-lg max-w-2xl">
+        <DialogHeader>
+          <DialogTitle>Merge Company</DialogTitle>
+          <DialogDescription>
+            Merge this company with another one.
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          <div className="p-4 bg-primary/5 rounded-lg border border-primary/20">
+            <p className="font-medium text-sm">
+              Current Company (will be deleted)
+            </p>
+            <div className="font-medium text-sm mt-4">{loserCompany.name}</div>
+
+            <div className="flex justify-center my-4">
+              <ArrowDown className="h-5 w-5 text-muted-foreground" />
+            </div>
+
+            <p className="font-medium text-sm mb-2">
+              Target Company (will be kept)
+            </p>
+            <Form>
+              <ReferenceInput
+                source="winner_id"
+                reference="companies"
+                filter={{ "id@neq": loserCompany.id }}
+              >
+                <AutocompleteInput
+                  label=""
+                  optionText="name"
+                  validate={required()}
+                  onChange={setWinnerId}
+                  defaultValue={suggestedWinnerId}
+                  helperText={false}
+                />
+              </ReferenceInput>
+            </Form>
+          </div>
+
+          {winnerId && (
+            <>
+              <div className="space-y-2">
+                <p className="font-medium text-sm">What will be merged:</p>
+                <ul className="text-sm text-muted-foreground space-y-1 ml-4">
+                  {contactsCount != null && contactsCount > 0 && (
+                    <li>
+                      • {contactsCount} contact
+                      {contactsCount !== 1 ? "s" : ""} will be reassigned
+                    </li>
+                  )}
+                  {dealsCount != null && dealsCount > 0 && (
+                    <li>
+                      • {dealsCount} deal
+                      {dealsCount !== 1 ? "s" : ""} will be reassigned
+                    </li>
+                  )}
+                  {loserCompany.context_links?.length > 0 && (
+                    <li>
+                      • {loserCompany.context_links.length} context link
+                      {loserCompany.context_links.length !== 1 ? "s" : ""} will
+                      be added
+                    </li>
+                  )}
+                  {!contactsCount &&
+                    !dealsCount &&
+                    !loserCompany.context_links?.length && (
+                      <li className="text-muted-foreground/60">
+                        No additional data to merge
+                      </li>
+                    )}
+                </ul>
+              </div>
+              <Alert variant="destructive">
+                <AlertTriangle className="h-4 w-4" />
+                <AlertTitle>Warning: Destructive Operation</AlertTitle>
+                <AlertDescription>
+                  All data will be transferred to the second company. This
+                  action cannot be undone.
+                </AlertDescription>
+              </Alert>
+            </>
+          )}
+        </div>
+
+        <DialogFooter>
+          <Button variant="ghost" onClick={onClose} disabled={isMerging}>
+            <CircleX />
+            Cancel
+          </Button>
+          <Button onClick={handleMerge} disabled={!winnerId || isMerging}>
+            <Merge />
+            {isMerging ? "Merging..." : "Merge Companies"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+};

package/src/components/atomic-crm/deals/stages.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import { getDealsByStage } from './stages';
+import type { Deal } from '../types';
+
+describe('getDealsByStage', () => {
+  const mockDealStages = [
+    { value: 'stage1', label: 'Stage 1' },
+    { value: 'stage2', label: 'Stage 2' },
+  ];
+
+  it('should group deals by stage', () => {
+    const deals = [
+      { id: 1, stage: 'stage1', index: 0, name: 'Deal 1' },
+      { id: 2, stage: 'stage2', index: 0, name: 'Deal 2' },
+      { id: 3, stage: 'stage1', index: 1, name: 'Deal 3' },
+    ] as unknown as Deal[];
+
+    const result = getDealsByStage(deals, mockDealStages);
+
+    expect(result['stage1']).toHaveLength(2);
+    expect(result['stage2']).toHaveLength(1);
+    expect(result['stage1'].map(d => d.name)).toEqual(['Deal 1', 'Deal 3']);
+  });
+
+  it('should ignore deals with unknown stages instead of crashing', () => {
+    const deals = [
+      { id: 1, stage: 'stage1', index: 0, name: 'Deal 1' },
+      { id: 4, stage: 'unknown_stage', index: 0, name: 'Deal 4' }, // Malformed data
+    ] as unknown as Deal[];
+
+    const result = getDealsByStage(deals, mockDealStages);
+
+    expect(result['stage1']).toHaveLength(1);
+    expect(result).not.toHaveProperty('unknown_stage');
+  });
+
+  it('should handle empty deal list', () => {
+    const deals: Deal[] = [];
+    const result = getDealsByStage(deals, mockDealStages);
+    expect(result['stage1']).toEqual([]);
+    expect(result['stage2']).toEqual([]);
+  });
+
+  it('should sort deals by index', () => {
+    const deals = [
+      { id: 1, stage: 'stage1', index: 2, name: 'Deal 1' },
+      { id: 3, stage: 'stage1', index: 1, name: 'Deal 3' },
+    ] as unknown as Deal[];
+
+    const result = getDealsByStage(deals, mockDealStages);
+    expect(result['stage1'][0].index).toBe(1);
+    expect(result['stage1'][1].index).toBe(2);
+  });
+});

package/src/components/atomic-crm/deals/stages.ts

@@ -10,7 +10,9 @@ export const getDealsByStage = (
   if (!dealStages) return {};
   const dealsByStage: Record<Deal["stage"], Deal[]> = unorderedDeals.reduce(
     (acc, deal) => {
-      acc[deal.stage].push(deal);
+      if (acc[deal.stage]) {
+        acc[deal.stage].push(deal);
+      }
       return acc;
     },
     dealStages.reduce(

package/src/components/atomic-crm/providers/commons/mergeCompanies.ts

@@ -0,0 +1,119 @@
+import type { Identifier, DataProvider } from "ra-core";
+
+import type { Company, Contact, Deal } from "../../types";
+
+/**
+ * Merge one company (loser) into another company (winner).
+ *
+ * This function copies properties from the loser to the winner company,
+ * transfers all associated data (contacts, deals) from the loser to the winner,
+ * and deletes the loser company.
+ */
+export const mergeCompanies = async (
+  loserId: Identifier,
+  winnerId: Identifier,
+  dataProvider: DataProvider,
+) => {
+  // Fetch both companies using dataProvider to get fresh data
+  const { data: winnerCompany } = await dataProvider.getOne<Company>(
+    "companies",
+    { id: winnerId },
+  );
+  const { data: loserCompany } = await dataProvider.getOne<Company>(
+    "companies",
+    { id: loserId },
+  );
+
+  if (!winnerCompany || !loserCompany) {
+    throw new Error("Could not fetch companies");
+  }
+
+  // 1. Reassign all contacts from loser to winner
+  const { data: loserContacts } = await dataProvider.getManyReference<Contact>(
+    "contacts",
+    {
+      target: "company_id",
+      id: loserId,
+      pagination: { page: 1, perPage: 1000 },
+      sort: { field: "id", order: "ASC" },
+      filter: {},
+    },
+  );
+
+  const contactUpdates =
+    loserContacts?.map((contact) =>
+      dataProvider.update("contacts", {
+        id: contact.id,
+        data: { company_id: winnerId },
+        previousData: contact,
+      }),
+    ) || [];
+
+  // 2. Reassign all deals from loser to winner
+  const { data: loserDeals } = await dataProvider.getManyReference<Deal>(
+    "deals",
+    {
+      target: "company_id",
+      id: loserId,
+      pagination: { page: 1, perPage: 1000 },
+      sort: { field: "id", order: "ASC" },
+      filter: {},
+    },
+  );
+
+  const dealUpdates =
+    loserDeals?.map((deal) =>
+      dataProvider.update<Deal>("deals", {
+        id: deal.id,
+        data: { company_id: winnerId },
+        previousData: deal,
+      }),
+    ) || [];
+
+  // 3. Update winner company with loser data
+  const mergedContextLinks = mergeArraysUnique(
+    winnerCompany.context_links || [],
+    loserCompany.context_links || [],
+  );
+
+  const winnerUpdate = dataProvider.update<Company>("companies", {
+    id: winnerId,
+    data: {
+      logo:
+        winnerCompany.logo && winnerCompany.logo.src
+          ? winnerCompany.logo
+          : loserCompany.logo,
+      sector: winnerCompany.sector ?? loserCompany.sector,
+      size: winnerCompany.size ?? loserCompany.size,
+      linkedin_url: winnerCompany.linkedin_url || loserCompany.linkedin_url,
+      website: winnerCompany.website || loserCompany.website,
+      phone_number: winnerCompany.phone_number ?? loserCompany.phone_number,
+      address: winnerCompany.address ?? loserCompany.address,
+      zipcode: winnerCompany.zipcode ?? loserCompany.zipcode,
+      city: winnerCompany.city ?? loserCompany.city,
+      stateAbbr: winnerCompany.stateAbbr ?? loserCompany.stateAbbr,
+      country: winnerCompany.country ?? loserCompany.country,
+      description: winnerCompany.description ?? loserCompany.description,
+      revenue: winnerCompany.revenue ?? loserCompany.revenue,
+      tax_identifier:
+        winnerCompany.tax_identifier ?? loserCompany.tax_identifier,
+      sales_id: winnerCompany.sales_id ?? loserCompany.sales_id,
+      context_links: mergedContextLinks,
+    },
+    previousData: winnerCompany,
+  });
+
+  // Execute all updates
+  await Promise.all([...contactUpdates, ...dealUpdates, winnerUpdate]);
+
+  // 4. Delete the loser company
+  await dataProvider.delete<Company>("companies", {
+    id: loserId,
+    previousData: loserCompany,
+  });
+};
+
+// Helper function to merge arrays and remove duplicates
+const mergeArraysUnique = <T>(arr1: T[], arr2: T[]): T[] => [
+  ...new Set([...arr1, ...arr2]),
+];

package/src/components/atomic-crm/providers/fakerest/dataProvider.ts

@@ -21,6 +21,7 @@ import { getActivityLog } from "../commons/activity";
 import { getCompanyAvatar } from "../commons/getCompanyAvatar";
 import { getContactAvatar } from "../commons/getContactAvatar";
 import { mergeContacts } from "../commons/mergeContacts";
+import { mergeCompanies } from "../commons/mergeCompanies";
 import type { CrmDataProvider } from "../types";
 import { authProvider, USER_STORAGE_KEY } from "./authProvider";
 import generateData from "./dataGenerator";
@@ -226,6 +227,9 @@ const dataProviderWithCustomMethod: CrmDataProvider = {
   mergeContacts: async (sourceId: Identifier, targetId: Identifier) => {
     return mergeContacts(sourceId, targetId, baseDataProvider);
   },
+  mergeCompanies: async (sourceId: Identifier, targetId: Identifier) => {
+    return mergeCompanies(sourceId, targetId, baseDataProvider);
+  },
 };
 
 async function updateCompany(

package/src/components/atomic-crm/providers/supabase/dataProvider.ts

@@ -265,6 +265,19 @@ const dataProviderWithCustomMethods = {
       throw new Error("Failed to merge contacts");
     }
 
+    return data;
+  },
+  async mergeCompanies(sourceId: Identifier, targetId: Identifier) {
+    const { data, error } = await supabase.functions.invoke("mergeCompanies", {
+      method: "POST",
+      body: { loserId: sourceId, winnerId: targetId },
+    });
+
+    if (error) {
+      console.error("mergeCompanies.error", error);
+      throw new Error("Failed to merge companies");
+    }
+
     return data;
   },
 } satisfies DataProvider;

package/supabase/functions/_shared/db.ts

@@ -74,8 +74,31 @@ interface DealsTable {
   index: number | null;
 }
 
+export interface CompaniesTable {
+  id: Generated<number>;
+  created_at: Date;
+  name: string;
+  sector: string | null;
+  size: number | null;
+  linkedin_url: string | null;
+  website: string | null;
+  phone_number: string | null;
+  address: string | null;
+  zipcode: string | null;
+  city: string | null;
+  stateAbbr: string | null;
+  sales_id: number | null;
+  context_links: unknown | null; // JSON array
+  country: string | null;
+  description: string | null;
+  revenue: string | null;
+  tax_identifier: string | null;
+  logo: unknown | null; // JSONB
+}
+
 interface Database {
   contacts: ContactsTable;
+  companies: CompaniesTable;
   tasks: TasksTable;
   contactNotes: ContactNotesTable;
   deals: DealsTable;

package/supabase/functions/api-v1-companies/index.ts

@@ -41,8 +41,12 @@ Deno.serve(async (req: Request) => {
 
     let response: Response;
 
-    if (req.method === "GET" && companyId) {
-      response = await getCompany(apiKey, companyId);
+    if (req.method === "GET") {
+      if (companyId) {
+        response = await getCompany(apiKey, companyId);
+      } else {
+        response = await listCompanies(apiKey, req);
+      }
     } else if (req.method === "POST") {
       response = await createCompany(apiKey, req);
     } else if (req.method === "PATCH" && companyId) {
@@ -79,6 +83,42 @@ Deno.serve(async (req: Request) => {
   }
 });
 
+async function listCompanies(apiKey: any, req: Request) {
+  if (!hasScope(apiKey, "companies:read")) {
+    return createErrorResponse(403, "Insufficient permissions");
+  }
+
+  const url = new URL(req.url);
+  const name = url.searchParams.get("name");
+  const website = url.searchParams.get("website");
+  const domain = url.searchParams.get("domain"); // Alias for website
+
+  let query = supabaseAdmin.from("companies").select("*");
+
+  if (name) {
+    query = query.ilike("name", `%${name}%`);
+  }
+
+  if (website || domain) {
+    // Exact match for website/domain
+    query = query.eq("website", website || domain);
+  }
+
+  if (!name && !website && !domain) {
+    query = query.limit(50);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return createErrorResponse(500, error.message);
+  }
+
+  return new Response(JSON.stringify({ data }), {
+    headers: { "Content-Type": "application/json", ...corsHeaders },
+  });
+}
+
 async function getCompany(apiKey: any, companyId: string) {
   if (!hasScope(apiKey, "companies:read")) {
     return createErrorResponse(403, "Insufficient permissions");

package/supabase/functions/api-v1-contacts/index.ts

@@ -45,8 +45,12 @@ Deno.serve(async (req: Request) => {
 
     let response: Response;
 
-    if (req.method === "GET" && contactId) {
-      response = await getContact(apiKey, contactId);
+    if (req.method === "GET") {
+      if (contactId) {
+        response = await getContact(apiKey, contactId);
+      } else {
+        response = await listContacts(apiKey, req);
+      }
     } else if (req.method === "POST") {
       response = await createContact(apiKey, req);
     } else if (req.method === "PATCH" && contactId) {
@@ -83,6 +87,38 @@ Deno.serve(async (req: Request) => {
   }
 });
 
+async function listContacts(apiKey: any, req: Request) {
+  if (!hasScope(apiKey, "contacts:read")) {
+    return createErrorResponse(403, "Insufficient permissions");
+  }
+
+  const url = new URL(req.url);
+  const email = url.searchParams.get("email");
+
+  let query = supabaseAdmin.from("contacts").select("*");
+
+  if (email) {
+    // Search within the email_jsonb array
+    // email_jsonb structure: [{ "email": "test@example.com", "type": "Work" }]
+    // We look for any object in the array that matches the email
+    query = query.contains("email_jsonb", JSON.stringify([{ email }]));
+  } else {
+    // If no specific search is provided, we default to a limit to prevent dumping the whole DB
+    // The apiKey owner can see all contacts, but let's limit it to 50 for safety if not searching
+    query = query.limit(50);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return createErrorResponse(500, error.message);
+  }
+
+  return new Response(JSON.stringify({ data }), {
+    headers: { "Content-Type": "application/json", ...corsHeaders },
+  });
+}
+
 async function getContact(apiKey: any, contactId: string) {
   if (!hasScope(apiKey, "contacts:read")) {
     return createErrorResponse(403, "Insufficient permissions");