realtimex-crm 0.1.2

package/supabase/functions/postmark/addNoteToContact.ts

@@ -0,0 +1,129 @@
+import { supabaseAdmin } from "../_shared/supabaseAdmin.ts";
+
+export const addNoteToContact = async ({
+  salesEmail,
+  email,
+  domain,
+  firstName,
+  lastName,
+  noteContent,
+}: {
+  salesEmail: string;
+  email: string;
+  domain: string;
+  firstName: string;
+  lastName: string;
+  noteContent: string;
+}) => {
+  const { data: sales, error: fetchSalesError } = await supabaseAdmin
+    .from("sales")
+    .select("*")
+    .eq("email", salesEmail)
+    .neq("disabled", true)
+    .maybeSingle();
+  if (fetchSalesError)
+    return new Response(
+      `Could not fetch sales from database, email: ${salesEmail}`,
+      { status: 500 },
+    );
+  if (!sales) {
+    // Return a 403 to let Postmark know that it's no use to retry this request
+    // https://postmarkapp.com/developer/webhooks/inbound-webhook#errors-and-retries
+    return new Response(
+      `Unable to find (active) sales in database, email: ${salesEmail}`,
+      { status: 403 },
+    );
+  }
+
+  // Check if the contact already exists
+  const { data: existingContact, error: fetchContactError } =
+    await supabaseAdmin
+      .from("contacts")
+      .select("*")
+      .contains("email_jsonb", JSON.stringify([{ email }]))
+      .maybeSingle();
+  if (fetchContactError)
+    return new Response(
+      `Could not fetch contact from database, email: ${email}`,
+      { status: 500 },
+    );
+
+  // deno-lint-ignore no-explicit-any
+  let contact: any = undefined;
+  if (existingContact) {
+    contact = existingContact;
+  } else {
+    // If the contact does not exist, we need to create it, along with the company if needed
+
+    // Check if the company already exists
+    const { data: existingCompany, error: fetchCompanyError } =
+      await supabaseAdmin
+        .from("companies")
+        .select("*")
+        .eq("name", domain)
+        .maybeSingle();
+    if (fetchCompanyError)
+      return new Response(
+        `Could not fetch companies from database, name: ${domain}`,
+        { status: 500 },
+      );
+
+    // deno-lint-ignore no-explicit-any
+    let company: any = undefined;
+    if (existingCompany) {
+      company = existingCompany;
+    } else {
+      const { data: newCompanies, error: createCompanyError } =
+        await supabaseAdmin
+          .from("companies")
+          .insert({ name: domain, sales_id: sales.id })
+          .select();
+      if (createCompanyError)
+        return new Response(
+          `Could not create company in database, name: ${domain}`,
+          { status: 500 },
+        );
+      company = newCompanies[0];
+    }
+
+    // Create the contact
+    const { data: newContacts, error: createContactError } = await supabaseAdmin
+      .from("contacts")
+      .insert({
+        first_name: firstName,
+        last_name: lastName,
+        email_jsonb: [{ email, type: "Work" }],
+        company_id: company.id,
+        sales_id: sales.id,
+        first_seen: new Date(),
+        last_seen: new Date(),
+        tags: [],
+      })
+      .select();
+    if (createContactError || !newContacts[0])
+      return new Response(
+        `Could not create contact in database, email: ${email}`,
+        { status: 500 },
+      );
+    contact = newContacts[0];
+  }
+
+  // Add note to contact
+  const { error: createNoteError } = await supabaseAdmin
+    .from("contactNotes")
+    .insert({
+      contact_id: contact.id,
+      text: noteContent,
+      sales_id: sales.id,
+    });
+  if (createNoteError)
+    return new Response(
+      `Could not add note to contact ${email}, sales ${salesEmail}`,
+      { status: 500 },
+    );
+
+  await supabaseAdmin
+    .from("contacts")
+    .update({ last_seen: new Date() })
+    .eq("id", contact.id);
+};

package/supabase/functions/postmark/extractMailContactData.ts

@@ -0,0 +1,41 @@
+/**
+ * Extracts the first name, last name, email, and domain from a mail contact.
+ *
+ * Example:
+ *   "ToFull": [
+ *     {
+ *       "Email": "firstname.lastname@marmelab.com",
+ *       "Name": "Firstname Lastname"
+ *     }
+ *   ]
+ *
+ * Return Value:
+ *  {
+ *    firstName: "Firstname",
+ *    lastName: "Lastname",
+ *    email: "firstname.lastname@marmelab.com",
+ *    domain: "marmelab.com"
+ * }
+ *
+ */
+export const extractMailContactData = (
+  ToFull: {
+    Email: string;
+    Name: string;
+  }[],
+) => {
+  return ToFull.map((contact) => {
+    const domain = contact.Email.split("@").at(-1)!;
+    const fullName =
+      contact.Name ||
+      contact.Email.split("@").slice(0, -1).join(" ").split(".").join(" ");
+    let firstName = "";
+    let lastName = fullName;
+    if (fullName && fullName.includes(" ")) {
+      const parts = fullName.split(" ");
+      firstName = parts[0];
+      lastName = parts.slice(1).join(" ");
+    }
+    return { firstName, lastName, email: contact.Email, domain };
+  });
+};

package/supabase/functions/postmark/getExpectedAuthorization.ts

@@ -0,0 +1,4 @@
+export const getExpectedAuthorization = (
+  webhookUser: string,
+  webhookPassword: string,
+) => `Basic ${btoa(`${webhookUser}:${webhookPassword}`)}`;

package/supabase/functions/postmark/getNoteContent.ts

@@ -0,0 +1,6 @@
+export const getNoteContent = (
+  subject: string,
+  strippedText: string,
+) => `${subject}
+
+${strippedText}`;

package/supabase/functions/postmark/index.ts

@@ -0,0 +1,210 @@
+// Follow this setup guide to integrate the Deno language server with your editor:
+// https://deno.land/manual/getting_started/setup_your_environment
+// This enables autocomplete, go to definition, etc.
+
+// Setup type definitions for built-in Supabase Runtime APIs
+import "jsr:@supabase/functions-js/edge-runtime.d.ts";
+import { addNoteToContact } from "./addNoteToContact.ts";
+import { extractMailContactData } from "./extractMailContactData.ts";
+import { getExpectedAuthorization } from "./getExpectedAuthorization.ts";
+import { getNoteContent } from "./getNoteContent.ts";
+
+const webhookUser = Deno.env.get("POSTMARK_WEBHOOK_USER");
+const webhookPassword = Deno.env.get("POSTMARK_WEBHOOK_PASSWORD");
+if (!webhookUser || !webhookPassword) {
+  throw new Error(
+    "Missing POSTMARK_WEBHOOK_USER or POSTMARK_WEBHOOK_PASSWORD env variable",
+  );
+}
+
+const rawAuthorizedIPs = Deno.env.get("POSTMARK_WEBHOOK_AUTHORIZED_IPS");
+if (!rawAuthorizedIPs) {
+  throw new Error("Missing POSTMARK_WEBHOOK_AUTHORIZED_IPS env variable");
+}
+
+Deno.serve(async (req) => {
+  let response: Response | undefined;
+
+  response = checkRequestTypeAndHeaders(req);
+  if (response) return response;
+
+  const json = await req.json();
+  response = checkBody(json);
+  if (response) return response;
+
+  const { ToFull, FromFull, Subject, TextBody } = json;
+
+  const noteContent = getNoteContent(Subject, TextBody);
+
+  const { Email: salesEmail } = FromFull;
+  if (!salesEmail) {
+    // Return a 403 to let Postmark know that it's no use to retry this request
+    // https://postmarkapp.com/developer/webhooks/inbound-webhook#errors-and-retries
+    return new Response(
+      `Could not extract sales email from FromFull: ${FromFull}`,
+      { status: 403 },
+    );
+  }
+
+  const contacts = extractMailContactData(ToFull);
+
+  for (const { firstName, lastName, email, domain } of contacts) {
+    if (!email) {
+      // Return a 403 to let Postmark know that it's no use to retry this request
+      // https://postmarkapp.com/developer/webhooks/inbound-webhook#errors-and-retries
+      return new Response(`Could not extract email from ToFull: ${ToFull}`, {
+        status: 403,
+      });
+    }
+
+    await addNoteToContact({
+      salesEmail,
+      email,
+      domain,
+      firstName,
+      lastName,
+      noteContent,
+    });
+  }
+
+  return new Response("OK");
+});
+
+const checkRequestTypeAndHeaders = (req: Request) => {
+  // Only allow known IP addresses
+  // We can use the x-forwarded-for header as it is populated by Supabase
+  // https://supabase.com/docs/guides/api/securing-your-api#accessing-request-information
+  const forwardedFor = req.headers.get("x-forwarded-for");
+  if (!forwardedFor) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+  const ips = forwardedFor.split(",").map((ip) => ip.trim());
+  const authorizedIPs = rawAuthorizedIPs.split(",").map((ip) => ip.trim());
+  if (!ips.some((ip) => authorizedIPs.includes(ip))) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+
+  // Only allow POST requests
+  if (req.method !== "POST") {
+    return new Response(null, { status: 405 });
+  }
+
+  // Check the Authorization header
+  const expectedAuthorization = getExpectedAuthorization(
+    webhookUser,
+    webhookPassword,
+  );
+  const authorization = req.headers.get("Authorization");
+  if (authorization !== expectedAuthorization) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+};
+
+// deno-lint-ignore no-explicit-any
+const checkBody = (json: any) => {
+  const { ToFull, FromFull, Subject, TextBody } = json;
+
+  // In case of incorrect request data, we
+  // return a 403 to let Postmark know that it's no use to retry this request
+  // https://postmarkapp.com/developer/webhooks/inbound-webhook#errors-and-retries
+  if (!ToFull || !ToFull.length)
+    return new Response("Missing parameter: ToFull", { status: 403 });
+  if (!FromFull)
+    return new Response("Missing parameter: FromFull", { status: 403 });
+  if (!Subject)
+    return new Response("Missing parameter: Subject", { status: 403 });
+  if (!TextBody)
+    return new Response("Missing parameter: TextBody", {
+      status: 403,
+    });
+};
+
+/* To invoke locally:
+  1. Run `make start`
+  2. Make sure to have a Sales with email "support@postmarkapp.com" (create it if needed)
+  3. OPTIONAL: Create a Contact with email "firstname.lastname@marmelab.com"
+  4. In another terminal, run `make start-supabase-functions`
+  5. In another terminal, make an HTTP request:
+  curl -i --location --request POST 'http://127.0.0.1:54321/functions/v1/postmark' \
+    --header 'Content-Type: application/json' \
+    --header 'Authorization: Basic dGVzdHVzZXI6dGVzdHB3ZA==' \
+    --data '{
+        "FromName": "Postmarkapp Support",
+        "From": "support@postmarkapp.com",
+        "FromFull": {
+            "Email": "support@postmarkapp.com",
+            "Name": "Postmarkapp Support",
+            "MailboxHash": ""
+        },
+        "To": "\"Firstname Lastname\" <firstname.lastname@marmelab.com>",
+        "ToFull": [
+            {
+            "Email": "firstname.lastname@marmelab.com",
+            "Name": "Firstname Lastname",
+            "MailboxHash": "SampleHash"
+            }
+        ],
+        "Cc": "\"First Cc\" <firstcc@postmarkapp.com>, secondCc@postmarkapp.com",
+        "CcFull": [
+            {
+            "Email": "firstcc@postmarkapp.com",
+            "Name": "First Cc",
+            "MailboxHash": ""
+            },
+            {
+            "Email": "secondCc@postmarkapp.com",
+            "Name": "",
+            "MailboxHash": ""
+            }
+        ],
+        "Bcc": "\"First Bcc\" <firstbcc@postmarkapp.com>, secondbcc@postmarkapp.com",
+        "BccFull": [
+            {
+            "Email": "firstbcc@postmarkapp.com",
+            "Name": "First Bcc",
+            "MailboxHash": ""
+            },
+            {
+            "Email": "secondbcc@postmarkapp.com",
+            "Name": "",
+            "MailboxHash": ""
+            }
+        ],
+        "OriginalRecipient": "firstname.lastname@marmelab.com",
+        "Subject": "Test subject",
+        "MessageID": "73e6d360-66eb-11e1-8e72-a8904824019b",
+        "ReplyTo": "replyto@postmarkapp.com",
+        "MailboxHash": "SampleHash",
+        "Date": "Fri, 1 Aug 2014 16:45:32 -04:00",
+        "TextBody": "This is a test text body.",
+        "HtmlBody": "<html><body><p>This is a test html body.</p></body></html>",
+        "StrippedTextReply": "This is the reply text",
+        "Tag": "TestTag",
+        "Headers": [
+            {
+            "Name": "X-Header-Test",
+            "Value": ""
+            },
+            {
+            "Name": "X-Spam-Status",
+            "Value": "No"
+            },
+            {
+            "Name": "X-Spam-Score",
+            "Value": "-0.1"
+            },
+            {
+            "Name": "X-Spam-Tests",
+            "Value": "DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,SPF_PASS"
+            }
+        ],
+        "Attachments": [
+            {
+            "Name": "test.txt",
+            "Content": "VGhpcyBpcyBhdHRhY2htZW50IGNvbnRlbnRzLCBiYXNlLTY0IGVuY29kZWQu",
+            "ContentType": "text/plain",
+            "ContentLength": 45
+            }
+        ]
+      }'
+*/

package/supabase/functions/updatePassword/index.ts

@@ -0,0 +1,50 @@
+import "jsr:@supabase/functions-js/edge-runtime.d.ts";
+import { createClient } from "jsr:@supabase/supabase-js@2";
+import { corsHeaders, createErrorResponse } from "../_shared/utils.ts";
+import { supabaseAdmin } from "../_shared/supabaseAdmin.ts";
+
+async function updatePassword(user: any) {
+  const { data, error } = await supabaseAdmin.auth.resetPasswordForEmail(
+    user.email,
+  );
+
+  if (!data || error) {
+    return createErrorResponse(500, "Internal Server Error");
+  }
+
+  return new Response(
+    JSON.stringify({
+      data,
+    }),
+    {
+      headers: { "Content-Type": "application/json", ...corsHeaders },
+    },
+  );
+}
+
+Deno.serve(async (req: Request) => {
+  if (req.method === "OPTIONS") {
+    return new Response(null, {
+      status: 204,
+      headers: corsHeaders,
+    });
+  }
+
+  const authHeader = req.headers.get("Authorization")!;
+  const localClient = createClient(
+    Deno.env.get("SUPABASE_URL") ?? "",
+    Deno.env.get("SUPABASE_ANON_KEY") ?? "",
+    { global: { headers: { Authorization: authHeader } } },
+  );
+
+  const { data } = await localClient.auth.getUser();
+  if (!data?.user) {
+    return createErrorResponse(401, "Unauthorized");
+  }
+
+  if (req.method === "PATCH") {
+    return updatePassword(data.user);
+  }
+
+  return createErrorResponse(405, "Method Not Allowed");
+});

package/supabase/functions/users/index.ts

@@ -0,0 +1,206 @@
+import "jsr:@supabase/functions-js/edge-runtime.d.ts";
+import { createClient } from "jsr:@supabase/supabase-js@2";
+import { supabaseAdmin } from "../_shared/supabaseAdmin.ts";
+import { corsHeaders, createErrorResponse } from "../_shared/utils.ts";
+
+async function updateSaleDisabled(user_id: string, disabled: boolean) {
+  return await supabaseAdmin
+    .from("sales")
+    .update({ disabled: disabled ?? false })
+    .eq("user_id", user_id);
+}
+
+async function updateSaleAdministrator(
+  user_id: string,
+  administrator: boolean,
+) {
+  const { data: sales, error: salesError } = await supabaseAdmin
+    .from("sales")
+    .update({ administrator })
+    .eq("user_id", user_id)
+    .select("*");
+
+  if (!sales?.length || salesError) {
+    console.error("Error updating user:", salesError);
+    throw salesError ?? new Error("Failed to update sale");
+  }
+  return sales.at(0);
+}
+
+async function updateSaleAvatar(user_id: string, avatar: string) {
+  const { data: sales, error: salesError } = await supabaseAdmin
+    .from("sales")
+    .update({ avatar })
+    .eq("user_id", user_id)
+    .select("*");
+
+  if (!sales?.length || salesError) {
+    console.error("Error updating user:", salesError);
+    throw salesError ?? new Error("Failed to update sale");
+  }
+  return sales.at(0);
+}
+
+async function inviteUser(req: Request, currentUserSale: any) {
+  const { email, password, first_name, last_name, disabled, administrator } =
+    await req.json();
+
+  if (!currentUserSale.administrator) {
+    return createErrorResponse(401, "Not Authorized");
+  }
+
+  const { data, error: userError } = await supabaseAdmin.auth.admin.createUser({
+    email,
+    password,
+    user_metadata: { first_name, last_name },
+  });
+
+  const { error: emailError } =
+    await supabaseAdmin.auth.admin.inviteUserByEmail(email);
+
+  if (!data?.user || userError) {
+    console.error(`Error inviting user: user_error=${userError}`);
+    return createErrorResponse(500, "Internal Server Error");
+  }
+
+  if (!data?.user || userError || emailError) {
+    console.error(`Error inviting user, email_error=${emailError}`);
+    return createErrorResponse(500, "Failed to send invitation mail");
+  }
+
+  try {
+    await updateSaleDisabled(data.user.id, disabled);
+    const sale = await updateSaleAdministrator(data.user.id, administrator);
+
+    return new Response(
+      JSON.stringify({
+        data: sale,
+      }),
+      {
+        headers: { "Content-Type": "application/json", ...corsHeaders },
+      },
+    );
+  } catch (e) {
+    console.error("Error patching sale:", e);
+    return createErrorResponse(500, "Internal Server Error");
+  }
+}
+
+async function patchUser(req: Request, currentUserSale: any) {
+  const {
+    sales_id,
+    email,
+    first_name,
+    last_name,
+    avatar,
+    administrator,
+    disabled,
+  } = await req.json();
+  const { data: sale } = await supabaseAdmin
+    .from("sales")
+    .select("*")
+    .eq("id", sales_id)
+    .single();
+
+  if (!sale) {
+    return createErrorResponse(404, "Not Found");
+  }
+
+  // Users can only update their own profile unless they are an administrator
+  if (!currentUserSale.administrator && currentUserSale.id !== sale.id) {
+    return createErrorResponse(401, "Not Authorized");
+  }
+
+  const { data, error: userError } =
+    await supabaseAdmin.auth.admin.updateUserById(sale.user_id, {
+      email,
+      ban_duration: disabled ? "87600h" : "none",
+      user_metadata: { first_name, last_name },
+    });
+
+  if (!data?.user || userError) {
+    console.error("Error patching user:", userError);
+    return createErrorResponse(500, "Internal Server Error");
+  }
+
+  if (avatar) {
+    await updateSaleAvatar(data.user.id, avatar);
+  }
+
+  // Only administrators can update the administrator and disabled status
+  if (!currentUserSale.administrator) {
+    const { data: new_sale } = await supabaseAdmin
+      .from("sales")
+      .select("*")
+      .eq("id", sales_id)
+      .single();
+    return new Response(
+      JSON.stringify({
+        data: new_sale,
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      },
+    );
+  }
+
+  try {
+    await updateSaleDisabled(data.user.id, disabled);
+    const sale = await updateSaleAdministrator(data.user.id, administrator);
+    return new Response(
+      JSON.stringify({
+        data: sale,
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...corsHeaders,
+        },
+      },
+    );
+  } catch (e) {
+    console.error("Error patching sale:", e);
+    return createErrorResponse(500, "Internal Server Error");
+  }
+}
+
+Deno.serve(async (req: Request) => {
+  if (req.method === "OPTIONS") {
+    return new Response(null, {
+      status: 204,
+      headers: corsHeaders,
+    });
+  }
+
+  const authHeader = req.headers.get("Authorization")!;
+  const localClient = createClient(
+    Deno.env.get("SUPABASE_URL") ?? "",
+    Deno.env.get("SUPABASE_ANON_KEY") ?? "",
+    { global: { headers: { Authorization: authHeader } } },
+  );
+  const { data } = await localClient.auth.getUser();
+  if (!data?.user) {
+    return createErrorResponse(401, "Unauthorized");
+  }
+  const currentUserSale = await supabaseAdmin
+    .from("sales")
+    .select("*")
+    .eq("user_id", data.user.id)
+    .single();
+
+  if (!currentUserSale?.data) {
+    return createErrorResponse(401, "Unauthorized");
+  }
+  if (req.method === "POST") {
+    return inviteUser(req, currentUserSale.data);
+  }
+
+  if (req.method === "PATCH") {
+    return patchUser(req, currentUserSale.data);
+  }
+
+  return createErrorResponse(405, "Method Not Allowed");
+});