realtimex-crm 0.1.2

package/src/components/atomic-crm/providers/fakerest/internal/supabaseAdapter.ts

@@ -0,0 +1,49 @@
+import type { DataProvider } from "ra-core";
+import { transformFilter } from "./transformFilter";
+
+function removeSummarySuffix(resource: string) {
+  return resource.endsWith("_summary")
+    ? resource.replace("_summary", "")
+    : resource;
+}
+
+export function withSupabaseFilterAdapter<T extends DataProvider>(
+  dataProvider: T,
+): T {
+  return {
+    ...dataProvider,
+    getOne(resource, params) {
+      return dataProvider.getOne(removeSummarySuffix(resource), params);
+    },
+    getList(resource, params) {
+      return dataProvider.getList(removeSummarySuffix(resource), {
+        ...params,
+        filter: transformFilter(params.filter),
+      });
+    },
+    getMany(resource, params) {
+      return dataProvider.getMany(removeSummarySuffix(resource), params);
+    },
+    getManyReference(resource, params) {
+      return dataProvider.getManyReference(removeSummarySuffix(resource), {
+        ...params,
+        filter: transformFilter(params.filter),
+      });
+    },
+    create(resource, params) {
+      return dataProvider.create(removeSummarySuffix(resource), params);
+    },
+    delete(resource, params) {
+      return dataProvider.delete(removeSummarySuffix(resource), params);
+    },
+    deleteMany(resource, params) {
+      return dataProvider.deleteMany(removeSummarySuffix(resource), params);
+    },
+    update(resource, params) {
+      return dataProvider.update(removeSummarySuffix(resource), params);
+    },
+    updateMany(resource, params) {
+      return dataProvider.updateMany(removeSummarySuffix(resource), params);
+    },
+  };
+}

package/src/components/atomic-crm/providers/fakerest/internal/transformContainsFilter.spec.ts

@@ -0,0 +1,35 @@
+import {
+  CONTAINS_FILTER_REGEX,
+  transformContainsFilter,
+} from "./transformContainsFilter";
+
+it("should throw an error if the filter is not a string", () => {
+  expect(() => transformContainsFilter(1)).toThrow(
+    `Invalid '@cs' filter value, expected a string matching '${CONTAINS_FILTER_REGEX.source}', got: 1`,
+  );
+});
+
+it("should throw an error if the filter does not match pattern", () => {
+  expect(() => transformContainsFilter("1,2")).toThrow(
+    `Invalid '@cs' filter value, expected a string matching '${CONTAINS_FILTER_REGEX.source}', got: 1,2`,
+  );
+});
+
+it("should support empty arrays", () => {
+  expect(transformContainsFilter("{}")).toEqual([]);
+});
+
+it("should return an array of numbers", () => {
+  expect(transformContainsFilter("{1}")).toEqual([1]);
+  expect(transformContainsFilter("{1,2,3}")).toEqual([1, 2, 3]);
+});
+
+it("should return an array of strings", () => {
+  expect(transformContainsFilter("{a}")).toEqual(["a"]);
+  expect(transformContainsFilter("{a,B,c-d}")).toEqual(["a", "B", "c-d"]);
+});
+
+it("should return an array of quoted strings", () => {
+  expect(transformContainsFilter('{"a"}')).toEqual(["a"]);
+  expect(transformContainsFilter('{"a","B, c"}')).toEqual(["a", "B, c"]);
+});

package/src/components/atomic-crm/providers/fakerest/internal/transformContainsFilter.ts

@@ -0,0 +1,17 @@
+import { LIST_REGEX_BASE, parseList } from "./listParser";
+
+export const CONTAINS_FILTER_REGEX = new RegExp(`^\\{${LIST_REGEX_BASE}\\}$`);
+
+export function transformContainsFilter(value: any) {
+  if (value === "{}") {
+    return [];
+  }
+
+  if (typeof value !== "string" || !value.match(CONTAINS_FILTER_REGEX)) {
+    throw new Error(
+      `Invalid '@cs' filter value, expected a string matching '${CONTAINS_FILTER_REGEX.source}', got: ${value}`,
+    );
+  }
+
+  return parseList(value.slice(1, -1));
+}

package/src/components/atomic-crm/providers/fakerest/internal/transformFilter.ts

@@ -0,0 +1,57 @@
+import { transformContainsFilter } from "./transformContainsFilter";
+import { transformInFilter } from "./transformInFilter";
+import { transformOrFilter } from "./transformOrFilter";
+
+export function transformFilter(filter: Record<string, any>) {
+  if (!filter) {
+    return undefined;
+  }
+  const transformedFilters: Record<string, any> = {};
+  for (const [key, value] of Object.entries(filter)) {
+    if (
+      key.endsWith("@eq") ||
+      key.endsWith("@neq") ||
+      key.endsWith("@lt") ||
+      key.endsWith("@lte") ||
+      key.endsWith("@gt") ||
+      key.endsWith("@gte")
+    ) {
+      const lastIndexOfAt = key.lastIndexOf("@");
+      transformedFilters[
+        `${key.substring(0, lastIndexOfAt)}_${key.substring(lastIndexOfAt + 1)}`
+      ] = value;
+      continue;
+    }
+
+    if (key.endsWith("@is")) {
+      transformedFilters[`${key.slice(0, -3)}_eq`] = value;
+      continue;
+    }
+
+    if (key.endsWith("@not.is")) {
+      transformedFilters[`${key.slice(0, -7)}_neq`] = value;
+      continue;
+    }
+
+    if (key.endsWith("@in")) {
+      transformedFilters[`${key.slice(0, -3)}_eq_any`] =
+        transformInFilter(value);
+      continue;
+    }
+
+    if (key.endsWith("@cs")) {
+      transformedFilters[`${key.slice(0, -3)}`] =
+        transformContainsFilter(value);
+      continue;
+    }
+
+    // Search query
+    if (key.endsWith("@or")) {
+      transformedFilters["q"] = transformOrFilter(value);
+      continue;
+    }
+
+    transformedFilters[key] = value;
+  }
+  return transformedFilters;
+}

package/src/components/atomic-crm/providers/fakerest/internal/transformInFilter.spec.ts

@@ -0,0 +1,32 @@
+import { IN_FILTER_REGEX, transformInFilter } from "./transformInFilter";
+
+it("should throw an error if the filter is not a string", () => {
+  expect(() => transformInFilter(1)).toThrow(
+    `Invalid '@in' filter value, expected a string matching '${IN_FILTER_REGEX.source}', got: 1`,
+  );
+});
+
+it("should throw an error if the filter does not match pattern", () => {
+  expect(() => transformInFilter("1,2")).toThrow(
+    `Invalid '@in' filter value, expected a string matching '${IN_FILTER_REGEX.source}', got: 1,2`,
+  );
+});
+
+it("should support empty arrays", () => {
+  expect(transformInFilter("()")).toEqual([]);
+});
+
+it("should return an array of numbers", () => {
+  expect(transformInFilter("(1)")).toEqual([1]);
+  expect(transformInFilter("(1,2,3)")).toEqual([1, 2, 3]);
+});
+
+it("should return an array of strings", () => {
+  expect(transformInFilter("(a)")).toEqual(["a"]);
+  expect(transformInFilter("(a,B,c-d)")).toEqual(["a", "B", "c-d"]);
+});
+
+it("should return an array of quoted strings", () => {
+  expect(transformInFilter('("a")')).toEqual(["a"]);
+  expect(transformInFilter('("a","B, c")')).toEqual(["a", "B, c"]);
+});

package/src/components/atomic-crm/providers/fakerest/internal/transformInFilter.ts

@@ -0,0 +1,17 @@
+import { LIST_REGEX_BASE, parseList } from "./listParser";
+
+export const IN_FILTER_REGEX = new RegExp(`^\\(${LIST_REGEX_BASE}\\)$`);
+
+export function transformInFilter(value: any) {
+  if (value === "()") {
+    return [];
+  }
+
+  if (typeof value !== "string" || !value.match(IN_FILTER_REGEX)) {
+    throw new Error(
+      `Invalid '@in' filter value, expected a string matching '${IN_FILTER_REGEX.source}', got: ${value}`,
+    );
+  }
+
+  return parseList(value.slice(1, -1));
+}

package/src/components/atomic-crm/providers/fakerest/internal/transformOrFilter.spec.ts

@@ -0,0 +1,23 @@
+import { transformOrFilter } from "./transformOrFilter";
+
+it("should throw an error if the value is not an object", () => {
+  expect(() => transformOrFilter([])).toThrow(
+    "Invalid '@or' filter, expected an object",
+  );
+});
+
+it("should throw an error if the object is empty", () => {
+  expect(() => transformOrFilter({})).toThrow(
+    "Invalid '@or' filter, object is empty",
+  );
+});
+
+it("should return the query value", () => {
+  expect(transformOrFilter({ "last_name@ilike": "one" })).toEqual("one");
+  expect(
+    transformOrFilter({
+      "last_name@ilike": "one",
+      "first_name@ilike": "one",
+    }),
+  ).toEqual("one");
+});

package/src/components/atomic-crm/providers/fakerest/internal/transformOrFilter.ts

@@ -0,0 +1,17 @@
+import isObject from "lodash/isObject";
+
+// @or filter is an equivaluent of fakerest `q=`
+export function transformOrFilter(values: any) {
+  if (!isObject(values) || Array.isArray(values)) {
+    throw new Error(
+      "Invalid '@or' filter, expected an object as first element",
+    );
+  }
+
+  const queries = Object.values(values);
+  if (queries.length === 0) {
+    throw new Error("Invalid '@or' filter, object is empty");
+  }
+
+  return queries[0];
+}

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

@@ -0,0 +1,121 @@
+/* eslint-disable no-var */
+/* eslint-disable @typescript-eslint/no-namespace */
+import type { AuthProvider } from "ra-core";
+import { supabaseAuthProvider } from "ra-supabase-core";
+
+import { canAccess } from "../commons/canAccess";
+import { supabase } from "./supabase";
+
+const baseAuthProvider = supabaseAuthProvider(supabase, {
+  getIdentity: async () => {
+    const sale = await getSaleFromCache();
+
+    if (sale == null) {
+      throw new Error();
+    }
+
+    return {
+      id: sale.id,
+      fullName: `${sale.first_name} ${sale.last_name}`,
+      avatar: sale.avatar?.src,
+    };
+  },
+});
+
+export async function getIsInitialized() {
+  if (getIsInitialized._is_initialized_cache == null) {
+    const { data } = await supabase.from("init_state").select("is_initialized");
+
+    getIsInitialized._is_initialized_cache = data?.at(0)?.is_initialized > 0;
+  }
+
+  return getIsInitialized._is_initialized_cache;
+}
+
+export namespace getIsInitialized {
+  export var _is_initialized_cache: boolean | null = null;
+}
+
+export const authProvider: AuthProvider = {
+  ...baseAuthProvider,
+  login: async (params) => {
+    const result = await baseAuthProvider.login(params);
+    // clear cached sale
+    cachedSale = undefined;
+    return result;
+  },
+  checkAuth: async (params) => {
+    // Users are on the set-password page, nothing to do
+    if (
+      window.location.pathname === "/set-password" ||
+      window.location.hash.includes("#/set-password")
+    ) {
+      return;
+    }
+    // Users are on the forgot-password page, nothing to do
+    if (
+      window.location.pathname === "/forgot-password" ||
+      window.location.hash.includes("#/forgot-password")
+    ) {
+      return;
+    }
+    // Users are on the sign-up page, nothing to do
+    if (
+      window.location.pathname === "/sign-up" ||
+      window.location.hash.includes("#/sign-up")
+    ) {
+      return;
+    }
+
+    const isInitialized = await getIsInitialized();
+
+    if (!isInitialized) {
+      await supabase.auth.signOut();
+      throw {
+        redirectTo: "/sign-up",
+        message: false,
+      };
+    }
+
+    return baseAuthProvider.checkAuth(params);
+  },
+  canAccess: async (params) => {
+    const isInitialized = await getIsInitialized();
+    if (!isInitialized) return false;
+
+    // Get the current user
+    const sale = await getSaleFromCache();
+    if (sale == null) return false;
+
+    // Compute access rights from the sale role
+    const role = sale.administrator ? "admin" : "user";
+    return canAccess(role, params);
+  },
+};
+
+let cachedSale: any;
+const getSaleFromCache = async () => {
+  if (cachedSale != null) return cachedSale;
+
+  const { data: dataSession, error: errorSession } =
+    await supabase.auth.getSession();
+
+  // Shouldn't happen after login but just in case
+  if (dataSession?.session?.user == null || errorSession) {
+    return undefined;
+  }
+
+  const { data: dataSale, error: errorSale } = await supabase
+    .from("sales")
+    .select("id, first_name, last_name, avatar, administrator")
+    .match({ user_id: dataSession?.session?.user.id })
+    .single();
+
+  // Shouldn't happen either as all users are sales but just in case
+  if (dataSale == null || errorSale) {
+    return undefined;
+  }
+
+  cachedSale = dataSale;
+  return dataSale;
+};