Merge pull request #16 from psteinroe/feat/mutation-improvements

psteinroe · web-flow · commit 99df559e451b · 2022-08-30T22:55:44.000+02:00
feat: insert many, select on mutations and more
diff --git a/.changeset/sixty-pumpkins-add.md b/.changeset/sixty-pumpkins-add.md
@@ -0,0 +1,11 @@
+---
+"@supabase-cache-helpers/postgrest-fetcher": minor
+"@supabase-cache-helpers/postgrest-mutate": minor
+"@supabase-cache-helpers/postgrest-swr": minor
+"@supabase-cache-helpers/postgrest-shared": patch
+---
+
+- [BREAKING] Add support for insert many
+- Allow defining the select query on mutations
+- refactor internal swr mutation functions to prepare for subscriptions
+- move mutation fetchers into common postgrest-fetcher lib
diff --git a/packages/postgrest-fetcher/src/delete.ts b/packages/postgrest-fetcher/src/delete.ts
@@ -0,0 +1,28 @@
+import { PostgrestQueryBuilder } from "@supabase/postgrest-js";
+import { GetResult } from "@supabase/postgrest-js/dist/module/select-query-parser";
+import { GenericTable } from "@supabase/postgrest-js/dist/module/types";
+
+export const buildDeleteFetcher =
+  <
+    T extends GenericTable,
+    Q extends string = "*",
+    R = GetResult<T["Row"], Q extends "*" ? "*" : Q>
+  >(
+    qb: PostgrestQueryBuilder<T>,
+    primaryKeys: (keyof T["Row"])[],
+    query?: Q
+  ) =>
+  async (input: Partial<T["Row"]>) => {
+    let filterBuilder = qb.delete();
+    for (const key of primaryKeys) {
+      const value = input[key];
+      if (!value)
+        throw new Error(`Missing value for primary key ${String(key)}`);
+      filterBuilder = filterBuilder.eq(key as string, value);
+    }
+    const { data } = await filterBuilder
+      .select(query ?? "*")
+      .throwOnError()
+      .single();
+    return data as R;
+  };
diff --git a/packages/postgrest-fetcher/src/index.ts b/packages/postgrest-fetcher/src/index.ts
@@ -1,2 +1,6 @@
+export * from "./delete";
 export * from "./fetcher";
+export * from "./insert";
 export * from "./pagination-fetcher";
+export * from "./update";
+export * from "./upsert";
diff --git a/packages/postgrest-fetcher/src/insert.ts b/packages/postgrest-fetcher/src/insert.ts
@@ -0,0 +1,29 @@
+import { PostgrestQueryBuilder } from "@supabase/postgrest-js";
+import { GetResult } from "@supabase/postgrest-js/dist/module/select-query-parser";
+import { GenericTable } from "@supabase/postgrest-js/dist/module/types";
+
+export const buildInsertFetcher =
+  <
+    T extends GenericTable,
+    Q extends string = "*",
+    R = GetResult<T["Row"], Q extends "*" ? "*" : Q>
+  >(
+    qb: PostgrestQueryBuilder<T>,
+    mode: "single" | "multiple",
+    query?: Q
+  ) =>
+  async (input: T["Insert"] | T["Insert"][]) => {
+    if (!Array.isArray(input)) input = [input];
+    const filterBuilder = qb
+      .insert(input)
+      .throwOnError()
+      .select(query ?? "*");
+
+    if (mode === "single") {
+      const { data } = await filterBuilder.single();
+      return data as R;
+    } else {
+      const { data } = await filterBuilder;
+      return data as R[];
+    }
+  };
diff --git a/packages/postgrest-fetcher/src/update.ts b/packages/postgrest-fetcher/src/update.ts
@@ -0,0 +1,29 @@
+import { PostgrestQueryBuilder } from "@supabase/postgrest-js";
+import { GetResult } from "@supabase/postgrest-js/dist/module/select-query-parser";
+import { GenericTable } from "@supabase/postgrest-js/dist/module/types";
+
+export const buildUpdateFetcher =
+  <
+    T extends GenericTable,
+    Q extends string = "*",
+    R = GetResult<T["Row"], Q extends "*" ? "*" : Q>
+  >(
+    qb: PostgrestQueryBuilder<T>,
+    primaryKeys: (keyof T["Row"])[],
+    query?: Q
+  ) =>
+  async (input: Partial<T["Row"]>) => {
+    let filterBuilder = qb.update(input);
+    for (const key of primaryKeys) {
+      const value = input[key];
+      if (!value)
+        throw new Error(`Missing value for primary key ${String(key)}`);
+      filterBuilder = filterBuilder.eq(key as string, value);
+    }
+    const { data } = await filterBuilder
+      .select(query ?? "*")
+      .throwOnError()
+      .single();
+
+    return data as R;
+  };
diff --git a/packages/postgrest-fetcher/src/upsert.ts b/packages/postgrest-fetcher/src/upsert.ts
@@ -0,0 +1,29 @@
+import { PostgrestQueryBuilder } from "@supabase/postgrest-js";
+import { GetResult } from "@supabase/postgrest-js/dist/module/select-query-parser";
+import { GenericTable } from "@supabase/postgrest-js/dist/module/types";
+
+export const buildUpsertFetcher =
+  <
+    T extends GenericTable,
+    Q extends string = "*",
+    R = GetResult<T["Row"], Q extends "*" ? "*" : Q>
+  >(
+    qb: PostgrestQueryBuilder<T>,
+    mode: "single" | "multiple",
+    query?: Q
+  ) =>
+  async (input: T["Insert"] | T["Insert"][]) => {
+    if (!Array.isArray(input)) input = [input];
+    const filterBuilder = qb
+      .upsert(input)
+      .throwOnError()
+      .select(query ?? "*");
+
+    if (mode === "single") {
+      const { data } = await filterBuilder.single();
+      return data as R;
+    } else {
+      const { data } = await filterBuilder;
+      return data as R[];
+    }
+  };
diff --git a/packages/postgrest-filter/__tests__/postgrest-filter-fn.integration.spec.ts b/packages/postgrest-filter/__tests__/postgrest-filter-fn.integration.spec.ts
@@ -222,7 +222,6 @@ describe("postgrest-filter-fn", () => {
   ])("%s", async (name, applyFilterQuery) => {
     const q = applyFilterQuery(query);
     const { data, error } = await q.single();
-    console.log(data);
     expect(error).toEqual(undefined);
     expect(data).toBeTruthy();
     expect(
diff --git a/packages/postgrest-mutate/src/upsert.ts b/packages/postgrest-mutate/src/upsert.ts
@@ -5,7 +5,7 @@ import { isPaginationCacheData } from "@supabase-cache-helpers/postgrest-shared"
 import { calculateNewCount } from "./lib";
 import { MutatorFn } from "./types";
 
-export const buildUpsertMutator = <Type extends object>(
+export const buildUpsertMutator = <Type>(
   input: Type,
   primaryKeys: (keyof Type)[],
   hasPathsFilterFn: (input: Type) => boolean
diff --git a/packages/postgrest-shared/src/types.ts b/packages/postgrest-shared/src/types.ts
@@ -16,19 +16,22 @@ export const isPaginationCacheData = <Type>(
   data: PostgrestCacheData<Type>
 ): data is PostgrestPaginationCacheData<Type> => Array.isArray(data);
 
+export type RevalidateTableOpt = { schema?: string; table: string };
+
+export type RevalidateRelationOpt<Type> = {
+  schema?: string;
+  relation: string;
+  relationIdColumn: string;
+  fKeyColumn: keyof Type;
+};
 export type PostgrestMutatorOpts<Type> = {
   /**
    * Will set all keys of the tables to stale
    */
-  revalidateTables?: { schema?: string; table: string }[];
+  revalidateTables?: RevalidateTableOpt[];
   /**
    * Will set all keys of the tables where relation.primaryKey === myObj.fKey
    */
-  revalidateRelations?: {
-    schema?: string;
-    relation: string;
-    relationIdColumn: string;
-    fKeyColumn: keyof Type;
-  }[];
+  revalidateRelations?: RevalidateRelationOpt<Type>[];
   schema?: string;
 };
diff --git a/packages/postgrest-swr/__tests__/mutate/use-delete-mutation.integration.spec.tsx b/packages/postgrest-swr/__tests__/mutate/use-delete-mutation.integration.spec.tsx
@@ -36,7 +36,7 @@ describe("useDeleteMutation", () => {
           revalidateOnReconnect: false,
         }
       );
-      const [insert] = useInsertMutation(client.from("contact"));
+      const [insert] = useInsertMutation(client.from("contact"), "single");
       const [deleteContact] = useDeleteMutation(client.from("contact"), ["id"]);
       return (
         <div>
diff --git a/packages/postgrest-swr/__tests__/mutate/use-insert-mutation.integration.spec.tsx b/packages/postgrest-swr/__tests__/mutate/use-insert-mutation.integration.spec.tsx
@@ -23,35 +23,62 @@ describe("useInsertMutation", () => {
   });
 
   it("should insert into existing cache item", async () => {
-    const USERNAME = `insert-test-${testId}`;
+    const USERNAME_1 = `insert-test-1-${testId}`;
+    const USERNAME_2 = `insert-test-2-${testId}`;
+    const USERNAME_3 = `insert-test-3-${testId}`;
     function Page() {
       const { data, count } = useQuery(
         client
           .from("contact")
           .select("id,username", { count: "exact" })
-          .eq("username", USERNAME),
+          .in("username", [USERNAME_1, USERNAME_2, USERNAME_3]),
         "multiple",
         {
           revalidateOnFocus: false,
           revalidateOnReconnect: false,
         }
       );
-      const [insert] = useInsertMutation(client.from("contact"));
+      const [insertOne] = useInsertMutation(client.from("contact"), "single");
+      const [insertMany] = useInsertMutation(
+        client.from("contact"),
+        "multiple"
+      );
+
       return (
-        <div
-          data-testid="insert"
-          onClick={async () => await insert({ username: USERNAME })}
-        >
-          <span>{data?.find((d) => d.username === USERNAME)?.username}</span>
+        <div>
+          <div
+            data-testid="insertOne"
+            onClick={async () => await insertOne({ username: USERNAME_1 })}
+          />
+          <div
+            data-testid="insertMany"
+            onClick={async () =>
+              await insertMany([
+                {
+                  username: USERNAME_2,
+                },
+                {
+                  username: USERNAME_3,
+                },
+              ])
+            }
+          />
+          {(data ?? []).map((d) => (
+            <span key={d.id}>{d.username}</span>
+          ))}
           <span data-testid="count">{`count: ${count}`}</span>
         </div>
       );
     }
 
     renderWithConfig(<Page />, { provider: () => provider });
     await screen.findByText("count: 0", {});
-    fireEvent.click(screen.getByTestId("insert"));
-    await screen.findByText(USERNAME);
+    fireEvent.click(screen.getByTestId("insertOne"));
+    await screen.findByText(USERNAME_1);
     expect(screen.getByTestId("count").textContent).toEqual("count: 1");
+    fireEvent.click(screen.getByTestId("insertMany"));
+    await screen.findByText(USERNAME_2);
+    await screen.findByText(USERNAME_3);
+    expect(screen.getByTestId("count").textContent).toEqual("count: 3");
   });
 });
diff --git a/packages/postgrest-swr/__tests__/mutate/use-update-mutation.integration.spec.tsx b/packages/postgrest-swr/__tests__/mutate/use-update-mutation.integration.spec.tsx
@@ -37,7 +37,7 @@ describe("useUpdateMutation", () => {
           revalidateOnReconnect: false,
         }
       );
-      const [insert] = useInsertMutation(client.from("contact"));
+      const [insert] = useInsertMutation(client.from("contact"), "single");
       const [update] = useUpdateMutation(client.from("contact"), ["id"]);
       return (
         <div>
diff --git a/packages/postgrest-swr/__tests__/query/use-counted-pagination.integration.spec.tsx b/packages/postgrest-swr/__tests__/query/use-counted-pagination.integration.spec.tsx
@@ -69,17 +69,18 @@ describe("useCountedPagination", () => {
             ))}
           </div>
           <div data-testid="pageIndex">{pageIndex}</div>
-          <div data-testid="pageCount">{pageCount}</div>
+          <div data-testid="pageCount">{`pageCount: ${pageCount}`}</div>
         </div>
       );
     }
 
     renderWithConfig(<Page />, { provider: () => provider });
     await screen.findByText("kiwicopple");
+    await screen.findByText("pageCount: 3");
     const currentPageList = screen.getByTestId("currentPage");
     expect(currentPageList.childElementCount).toEqual(1);
     expect(screen.getByTestId("pageIndex").textContent).toEqual("0");
-    expect(screen.getByTestId("pageCount").textContent).toEqual("3");
+    expect(screen.getByTestId("pageCount").textContent).toEqual("pageCount: 3");
     const pagesList = screen.getByTestId("pages");
     expect(pagesList.childElementCount).toEqual(1);
 
diff --git a/packages/postgrest-swr/src/lib/index.ts b/packages/postgrest-swr/src/lib/index.ts
@@ -1,6 +1,10 @@
 export * from "./coder";
 export * from "./constants";
+export * from "./remove";
 export * from "./get-key";
+export * from "./insert";
 export * from "./middleware";
 export * from "./types";
+export * from "./update";
+export * from "./upsert";
 export * from "./use-cache-scanner";
diff --git a/packages/postgrest-swr/src/lib/insert.ts b/packages/postgrest-swr/src/lib/insert.ts
@@ -0,0 +1,37 @@
+import { buildInsertMutator } from "@supabase-cache-helpers/postgrest-mutate";
+import { GetResult } from "@supabase/postgrest-js/dist/module/select-query-parser";
+import { MutatorOptions, ScopedMutator } from "swr/dist/types";
+import { GenericTable } from "./types";
+import { CacheScanResult } from "./use-cache-scanner";
+
+export const insert = async <
+  T extends GenericTable,
+  Q extends string = "*",
+  R = GetResult<T["Row"], Q extends "*" ? "*" : Q>
+>(
+  result: R[],
+  keys: CacheScanResult<T>,
+  mutate: ScopedMutator,
+  opts?: MutatorOptions<T>
+) => {
+  const { keysToMutate, keysToRevalidateTable, keysToRevalidateRelation } =
+    keys;
+
+  await Promise.all(
+    result.map(async (d) => [
+      ...keysToMutate
+        .filter(({ filter }) => filter.apply(d))
+        .map(({ key }) => mutate(key, buildInsertMutator(d), opts)),
+      // set all entries of the specified table to stale
+      ...keysToRevalidateTable.map(({ key }) => mutate(key)),
+      // apply filter with relation.id.eq.obj.fkey and set all to stale
+      ...keysToRevalidateRelation
+        .filter(({ filter, fKeyColumn, relationIdColumn }) =>
+          filter.applyFilters({
+            [relationIdColumn]: d[fKeyColumn as keyof R],
+          })
+        )
+        .map(({ key }) => mutate(key)),
+    ])
+  );
+};
diff --git a/packages/postgrest-swr/src/lib/remove.ts b/packages/postgrest-swr/src/lib/remove.ts
@@ -0,0 +1,41 @@
+import { buildDeleteMutator } from "@supabase-cache-helpers/postgrest-mutate";
+import { GetResult } from "@supabase/postgrest-js/dist/module/select-query-parser";
+import { MutatorOptions, ScopedMutator } from "swr/dist/types";
+import { GenericTable } from "./types";
+import { CacheScanResult } from "./use-cache-scanner";
+
+export const remove = async <
+  T extends GenericTable,
+  Q extends string = "*",
+  R = GetResult<T["Row"], Q extends "*" ? "*" : Q>
+>(
+  result: R,
+  primaryKeys: (keyof T["Row"])[],
+  keys: CacheScanResult<T>,
+  mutate: ScopedMutator,
+  opts?: MutatorOptions
+) => {
+  const { keysToMutate, keysToRevalidateTable, keysToRevalidateRelation } =
+    keys;
+  await Promise.all([
+    ...keysToMutate
+      .filter(({ filter }) => filter.apply(result))
+      .map(({ key }) =>
+        mutate(
+          key,
+          buildDeleteMutator<R>(result, primaryKeys as (keyof R)[]),
+          opts
+        )
+      ),
+    // set all entries of the specified table to stale
+    ...keysToRevalidateTable.map(({ key }) => mutate(key)),
+    // apply filter with relation.id.eq.obj.fkey and set all to stale
+    ...keysToRevalidateRelation
+      .filter(({ filter, fKeyColumn, relationIdColumn }) =>
+        filter.applyFilters({
+          [relationIdColumn]: result[fKeyColumn as keyof R],
+        })
+      )
+      .map(({ key }) => mutate(key)),
+  ]);
+};
diff --git a/packages/postgrest-swr/src/lib/types.ts b/packages/postgrest-swr/src/lib/types.ts
diff --git a/packages/postgrest-swr/src/lib/update.ts b/packages/postgrest-swr/src/lib/update.ts
diff --git a/packages/postgrest-swr/src/lib/upsert.ts b/packages/postgrest-swr/src/lib/upsert.ts
diff --git a/packages/postgrest-swr/src/lib/use-cache-scanner.ts b/packages/postgrest-swr/src/lib/use-cache-scanner.ts
diff --git a/packages/postgrest-swr/src/mutate/use-delete-mutation.ts b/packages/postgrest-swr/src/mutate/use-delete-mutation.ts
diff --git a/packages/postgrest-swr/src/mutate/use-insert-mutation.ts b/packages/postgrest-swr/src/mutate/use-insert-mutation.ts
diff --git a/packages/postgrest-swr/src/mutate/use-update-mutation.ts b/packages/postgrest-swr/src/mutate/use-update-mutation.ts
diff --git a/packages/postgrest-swr/src/mutate/use-upsert-mutation.ts b/packages/postgrest-swr/src/mutate/use-upsert-mutation.ts

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ describe("useDeleteMutation", () => {`
`36`	`36`	`revalidateOnReconnect: false,`
`37`	`37`	`}`
`38`	`38`	`);`
`39`		`- const [insert] = useInsertMutation(client.from("contact"));`
	`39`	`+ const [insert] = useInsertMutation(client.from("contact"), "single");`
`40`	`40`	`const [deleteContact] = useDeleteMutation(client.from("contact"), ["id"]);`
`41`	`41`	`return (`
`42`	`42`	`<div>`