@legendapp/state 3.0.0-alpha.9 → 3.0.0-beta.0

package/sync-plugins/keel.mjs

@@ -1,88 +1,99 @@
-import ksuid from 'ksuid';
-import { observable, computeSelector, isFunction, isEmpty, when, internal } from '@legendapp/state';
-import { removeNullUndefined } from '@legendapp/state/sync';
+import { observable, isFunction, when, batch, isEmpty } from '@legendapp/state';
 import { syncedCrud } from '@legendapp/state/sync-plugins/crud';
+import ksuid from 'ksuid';
 
 // src/sync-plugins/keel.ts
-var { clone } = internal;
 var KeelKeys = ["createdAt", "updatedAt"];
 function generateKeelId() {
   return ksuid.randomSync().string;
 }
-var keelConfig = {};
 var modifiedClients = /* @__PURE__ */ new WeakSet();
-var isEnabled$ = observable(true);
-async function ensureAuthToken() {
-  await when(isEnabled$.get());
-  let isAuthed = await keelConfig.client.auth.isAuthenticated();
+var isAuthed$ = observable(false);
+var isAuthing$ = observable(false);
+async function ensureAuthToken(props, force) {
+  if (!force && isAuthed$.get()) {
+    return true;
+  }
+  const { client, refreshAuth } = props;
+  let isAuthed = await client.auth.isAuthenticated().then(({ data }) => data);
   if (!isAuthed) {
-    isAuthed = await keelConfig.client.auth.refresh();
+    if (!force && isAuthing$.get()) {
+      return when(
+        () => !isAuthing$.get(),
+        () => isAuthed$.get()
+      );
+    }
+    isAuthing$.set(true);
+    if (refreshAuth) {
+      await refreshAuth();
+    }
+    isAuthed = await client.auth.isAuthenticated().then(({ data }) => data);
+    if (!isAuthed) {
+      isAuthed = await client.auth.refresh().then(({ data }) => data);
+    }
+  }
+  if (isAuthed) {
+    batch(() => {
+      isAuthed$.set(true);
+      isAuthing$.set(false);
+    });
+  } else {
+    setTimeout(() => ensureAuthToken(
+      props,
+      /*force*/
+      true
+    ), 1e3);
   }
   return isAuthed;
 }
-async function handleApiError(error, retry) {
+async function handleApiError(props, error, retry) {
   if (error.type === "unauthorized" || error.type === "forbidden") {
     console.warn("Keel token expired, refreshing...");
-    await ensureAuthToken();
+    isAuthed$.set(false);
+    await ensureAuthToken(props);
   }
 }
 function convertObjectToCreate(item) {
-  const cloned = clone(item);
-  Object.keys(cloned).forEach((key) => {
+  const cloned = {};
+  Object.keys(item).forEach((key) => {
     if (key.endsWith("Id")) {
-      if (cloned[key]) {
-        cloned[key.slice(0, -2)] = { id: cloned[key] };
+      if (item[key]) {
+        cloned[key.slice(0, -2)] = { id: item[key] };
+      }
+    } else if (key !== "createdAt" && key !== "updatedAt") {
+      if (item[key] === void 0) {
+        cloned[key] = null;
+      } else {
+        cloned[key] = item[key];
       }
-      delete cloned[key];
     }
   });
-  delete cloned.createdAt;
-  delete cloned.updatedAt;
   return cloned;
 }
-function getSyncedKeelConfiguration() {
-  return keelConfig;
-}
-function configureSyncedKeel(config) {
-  const { enabled, realtimePlugin, client, ...rest } = config;
-  Object.assign(keelConfig, removeNullUndefined(rest));
-  if (enabled !== void 0) {
-    isEnabled$.set(enabled);
-  }
-  if (realtimePlugin) {
-    keelConfig.realtimePlugin = realtimePlugin;
-    if (client && !modifiedClients.has(client)) {
-      modifiedClients.add(client);
-      const queries = client.api.queries;
-      Object.keys(queries).forEach((key) => {
-        if (key.startsWith("list")) {
-          const oldFn = queries[key];
-          queries[key] = (i) => {
-            const realtimeKey = [key, ...Object.values(i.where || {})].filter((value) => value && typeof value !== "object").join("/");
-            const subscribe = ({ refresh }) => {
-              if (realtimeKey) {
-                return realtimePlugin.subscribe(realtimeKey, refresh);
-              }
-            };
-            return oldFn(i).then((ret) => {
-              if (subscribe) {
-                ret.subscribe = subscribe;
-                ret.subscribeKey = realtimeKey;
-              }
-              return ret;
-            });
+var realtimeState = { current: {} };
+function setupRealtime(props) {
+  const { client } = props;
+  if (client && !modifiedClients.has(client)) {
+    modifiedClients.add(client);
+    const queries = client.api.queries;
+    Object.keys(queries).forEach((key) => {
+      if (key.startsWith("list")) {
+        const origFn = queries[key];
+        queries[key] = (i) => {
+          realtimeState.current = {
+            lastAction: key,
+            lastParams: i
           };
-        }
-      });
-    }
+          return origFn(i);
+        };
+      }
+    });
   }
 }
 var NumPerPage = 200;
-async function getAllPages(listFn, params) {
+async function getAllPages(props, listFn, params) {
   const allData = [];
   let pageInfo = void 0;
-  let subscribe_;
-  let subscribeKey_;
   const { first: firstParam } = params;
   do {
     const first = firstParam ? Math.min(firstParam - allData.length, NumPerPage) : NumPerPage;
@@ -94,13 +105,9 @@ async function getAllPages(listFn, params) {
     pageInfo = void 0;
     const ret = await listFn(paramsWithCursor);
     if (ret) {
-      const { data, error, subscribe, subscribeKey } = ret;
-      if (subscribe) {
-        subscribe_ = subscribe;
-        subscribeKey_ = subscribeKey;
-      }
+      const { data, error } = ret;
       if (error) {
-        await handleApiError(error);
+        await handleApiError(props, error);
         throw new Error(error.message);
       } else if (data) {
         pageInfo = data.pageInfo;
@@ -108,21 +115,25 @@ async function getAllPages(listFn, params) {
       }
     }
   } while (pageInfo == null ? void 0 : pageInfo.hasNextPage);
-  return { results: allData, subscribe: subscribe_, subscribeKey: subscribeKey_ };
+  return allData;
 }
 function syncedKeel(props) {
-  const { realtimePlugin } = keelConfig;
-  props = { ...keelConfig, ...props };
   const {
     get: getParam,
     list: listParam,
     create: createParam,
     update: updateParam,
     delete: deleteParam,
+    subscribe: subscribeParam,
     first,
     where: whereParam,
     waitFor,
+    waitForSet,
     fieldDeleted,
+    realtime,
+    mode,
+    onError,
+    requireAuth = true,
     ...rest
   } = props;
   const { changesSince } = props;
@@ -131,28 +142,38 @@ function syncedKeel(props) {
   const subscribeFnKey$ = observable("");
   const fieldCreatedAt = "createdAt";
   const fieldUpdatedAt = "updatedAt";
+  const setupSubscribe = realtime ? async (getParams) => {
+    const { lastAction, lastParams } = realtimeState.current;
+    const { path, plugin } = realtime;
+    if (lastAction && path && plugin) {
+      const key = await path(lastAction, lastParams);
+      subscribeFn = () => realtime.plugin.subscribe(key, getParams);
+      subscribeFnKey$.set(key);
+    }
+  } : void 0;
   const list = listParam ? async (listParams) => {
-    const { lastSync, refresh } = listParams;
+    const { lastSync } = listParams;
     const queryBySync = !!lastSync && changesSince === "last-sync";
     const where = Object.assign(
       queryBySync ? { updatedAt: { after: new Date(lastSync + 1) } } : {},
       isFunction(whereParam) ? whereParam() : whereParam
     );
     const params = { where, first };
-    const { results, subscribe: subscribe2, subscribeKey } = await getAllPages(listParam, params);
-    if (subscribe2) {
-      subscribeFn = () => subscribe2({ refresh });
-      subscribeFnKey$.set(subscribeKey);
+    realtimeState.current = {};
+    const promise = getAllPages(props, listParam, params);
+    if (realtime) {
+      setupSubscribe(listParams);
     }
-    return results;
+    return promise;
   } : void 0;
   const get = getParam ? async (getParams) => {
     const { refresh } = getParams;
-    const { data, error, subscribe: subscribe2, subscribeKey } = await getParam({ refresh });
-    if (subscribe2) {
-      subscribeFn = () => subscribe2({ refresh });
-      subscribeFnKey$.set(subscribeKey);
+    realtimeState.current = {};
+    const promise = getParam({ refresh });
+    if (realtime) {
+      setupSubscribe(getParams);
     }
+    const { data, error } = await promise;
     if (error) {
       throw new Error(error.message);
     } else {
@@ -161,41 +182,54 @@ function syncedKeel(props) {
   } : void 0;
   const onSaved = ({ saved }) => {
     if (saved) {
-      const updatedAt = saved[fieldUpdatedAt];
-      if (updatedAt && realtimePlugin) {
+      if (realtime == null ? void 0 : realtime.plugin) {
         const subscribeFnKey = subscribeFnKey$.get();
         if (subscribeFnKey) {
-          realtimePlugin.setLatestChange(subscribeFnKey, updatedAt);
+          realtime == null ? void 0 : realtime.plugin.setSaved(subscribeFnKey);
         }
       }
     }
   };
-  const handleSetError = async (error, params, isCreate) => {
-    var _a, _b, _c;
-    const { retryNum, cancelRetry, update: update2 } = params;
-    if (isCreate && ((_a = error.message) == null ? void 0 : _a.includes("for the unique")) && ((_b = error.message) == null ? void 0 : _b.includes("must be unique"))) {
+  const handleSetError = async (error, params, input, fn, from) => {
+    var _a, _b;
+    const { retryNum, update: update2 } = params;
+    if (from === "create" && ((_a = error.message) == null ? void 0 : _a.includes("for the unique")) && ((_b = error.message) == null ? void 0 : _b.includes("must be unique"))) {
       if (__DEV__) {
         console.log("Creating duplicate data already saved, just ignore.");
       }
+      params.cancelRetry = true;
       update2({
         value: {},
         mode: "assign"
       });
+    } else if (from === "delete") {
+      if (error.message === "record not found") {
+        if (__DEV__) {
+          console.log("Deleting non-existing data, just ignore.");
+        }
+        params.cancelRetry = true;
+      }
     } else if (error.type === "bad_request") {
-      (_c = keelConfig.onError) == null ? void 0 : _c.call(keelConfig, error);
+      onError == null ? void 0 : onError(new Error(error.message), params, {
+        error,
+        params,
+        input,
+        type: from,
+        action: fn.name || fn.toString()
+      });
       if (retryNum > 4) {
-        cancelRetry();
+        params.cancelRetry = true;
       }
-      throw new Error(error.message);
+      throw new Error(error.message, { cause: { input } });
     } else {
-      await handleApiError(error);
-      throw new Error(error.message);
+      await handleApiError(props, error);
+      throw new Error(error.message, { cause: { input } });
     }
   };
   const create = createParam ? async (input, params) => {
     const { data, error } = await createParam(convertObjectToCreate(input));
     if (error) {
-      handleSetError(error, params, true);
+      await handleSetError(error, params, input, createParam, "create");
     }
     return data;
   } : void 0;
@@ -203,44 +237,58 @@ function syncedKeel(props) {
     const id = input.id;
     const values = convertObjectToCreate(input);
     delete values.id;
-    delete values.createdAt;
-    delete values.updatedAt;
     if (!isEmpty(values)) {
       const { data, error } = await updateParam({ where: { id }, values });
       if (error) {
-        handleSetError(error, params, false);
+        await handleSetError(error, params, input, updateParam, "update");
       }
       return data;
     }
   } : void 0;
-  const deleteFn = deleteParam ? async ({ id }, params) => {
-    const { data, error } = await deleteParam({ id });
+  const deleteFn = deleteParam ? async (value, params) => {
+    const { data, error } = await deleteParam({ id: value.id });
     if (error) {
-      handleSetError(error, params, false);
+      await handleSetError(error, params, value, deleteParam, "delete");
     }
     return data;
   } : void 0;
-  const subscribe = (params) => {
+  if (realtime) {
+    setupRealtime(props);
+  }
+  const subscribe = realtime ? (params) => {
     let unsubscribe = void 0;
     when(subscribeFnKey$, () => {
       unsubscribe = subscribeFn(params);
     });
+    const unsubscribeParam = subscribeParam == null ? void 0 : subscribeParam(params);
     return () => {
       unsubscribe == null ? void 0 : unsubscribe();
+      unsubscribeParam == null ? void 0 : unsubscribeParam();
     };
-  };
+  } : subscribeParam;
   return syncedCrud({
     ...rest,
     as: asType,
+    mode: mode || "merge",
     list,
     create,
     update,
     delete: deleteFn,
-    waitFor: () => isEnabled$.get() && (waitFor ? computeSelector(waitFor) : true),
+    waitFor: () => {
+      ensureAuthToken(props);
+      return [requireAuth ? isAuthed$ : true, waitFor || true];
+    },
+    waitForSet: (params) => {
+      ensureAuthToken(props);
+      return [
+        requireAuth ? isAuthed$ : true,
+        () => waitForSet ? isFunction(waitForSet) ? waitForSet(params) : waitForSet : true
+      ];
+    },
     onSaved,
     fieldCreatedAt,
     fieldUpdatedAt,
-    fieldDeleted: fieldDeleted || "deleted",
+    fieldDeleted,
     changesSince,
     updatePartial: true,
     subscribe,
@@ -250,4 +298,4 @@ function syncedKeel(props) {
   });
 }
 
-export { KeelKeys, configureSyncedKeel, generateKeelId, getSyncedKeelConfiguration, syncedKeel };
+export { KeelKeys, generateKeelId, syncedKeel };

package/sync-plugins/supabase.d.mts

@@ -2,12 +2,17 @@ import { Observable } from '@legendapp/state';
 import { SyncedOptions, SyncedOptionsGlobal, SyncedGetParams } from '@legendapp/state/sync';
 import { SyncedCrudPropsBase, CrudAsOption, SyncedCrudReturnType, SyncedCrudPropsMany } from '@legendapp/state/sync-plugins/crud';
 import { PostgrestQueryBuilder, PostgrestFilterBuilder } from '@supabase/postgrest-js';
-import { SupabaseClient } from '@supabase/supabase-js';
+import { SupabaseClient, PostgrestSingleResponse } from '@supabase/supabase-js';
+import { FunctionsResponse } from '@supabase/functions-js';
 
+type DatabaseOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer TDB> ? TDB : never;
+type SchemaNameOf<Client extends SupabaseClient> = keyof DatabaseOf<Client>;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type IsUnionOfStrings<T> = [T] extends [string] ? ([T] extends [UnionToIntersection<T>] ? false : true) : false;
 type SupabaseSchemaOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer _, infer __, infer Schema> ? Schema : never;
-type SupabaseTableOf<Client extends SupabaseClient> = SupabaseSchemaOf<Client>['Tables'];
-type SupabaseCollectionOf<Client extends SupabaseClient> = keyof SupabaseTableOf<Client>;
-type SupabaseRowOf<Client extends SupabaseClient, Collection extends SupabaseCollectionOf<Client>> = SupabaseTableOf<Client>[Collection]['Row'];
+type SupabaseTableOf<Client extends SupabaseClient, SchemaName extends SchemaNameOf<Client>> = DatabaseOf<Client>[SchemaName]['Tables'];
+type SupabaseCollectionOf<Client extends SupabaseClient, SchemaName extends SchemaNameOf<Client>> = keyof SupabaseTableOf<Client, IsUnionOfStrings<SchemaName> extends true ? 'public' : SchemaName>;
+type SupabaseRowOf<Client extends SupabaseClient, Collection extends SupabaseCollectionOf<Client, SchemaName>, SchemaName extends SchemaNameOf<Client>> = SupabaseTableOf<Client, SchemaName>[Collection]['Row'];
 type SyncedSupabaseConfig<TRemote extends {
     id: string | number;
 }, TLocal> = Omit<SyncedCrudPropsBase<TRemote, TLocal>, 'create' | 'update' | 'delete'>;
@@ -20,20 +25,25 @@ interface SyncedSupabaseConfiguration extends Omit<SyncedSupabaseConfig<{
     enabled?: Observable<boolean>;
     as?: Exclude<CrudAsOption, 'value'>;
 }
-interface SyncedSupabaseProps<Client extends SupabaseClient, Collection extends SupabaseCollectionOf<Client>, TOption extends CrudAsOption = 'object', TRemote extends SupabaseRowOf<Client, Collection> = SupabaseRowOf<Client, Collection>, TLocal = TRemote> extends SyncedSupabaseConfig<TRemote, TLocal>, SyncedCrudPropsMany<TRemote, TRemote, TOption> {
-    supabase: Client;
+interface SyncedSupabaseProps<Client extends SupabaseClient<any, any>, Collection extends SupabaseCollectionOf<Client, SchemaName>, SchemaName extends SchemaNameOf<Client> = 'public', TOption extends CrudAsOption = 'object', TRemote extends SupabaseRowOf<Client, Collection, SchemaName> = SupabaseRowOf<Client, Collection, SchemaName>, TLocal = TRemote> extends SyncedSupabaseConfig<TRemote, TLocal>, Omit<SyncedCrudPropsMany<TRemote, TRemote, TOption>, 'list'> {
+    supabase?: Client;
     collection: Collection;
-    select?: (query: PostgrestQueryBuilder<SupabaseSchemaOf<Client>, SupabaseTableOf<Client>[Collection], Collection>) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
-    filter?: (select: PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>, params: SyncedGetParams) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
+    schema?: SchemaName;
+    select?: (query: PostgrestQueryBuilder<SupabaseSchemaOf<Client>, SupabaseTableOf<Client, SchemaName>[Collection], Collection>) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
+    filter?: (select: PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>, params: SyncedGetParams<TRemote>) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
     actions?: ('create' | 'read' | 'update' | 'delete')[];
     realtime?: boolean | {
         schema?: string;
         filter?: string;
     };
     stringifyDates?: boolean;
+    list?: (...params: Parameters<Required<SyncedCrudPropsMany<TRemote, TLocal, TOption>>['list']>) => PromiseLike<PostgrestSingleResponse<TRemote[]>> | Promise<FunctionsResponse<NoInfer<TRemote>[]>>;
+    create?: (...params: Parameters<Required<SyncedCrudPropsBase<TRemote>>['create']>) => PromiseLike<PostgrestSingleResponse<TRemote>> | Promise<FunctionsResponse<NoInfer<TRemote>>>;
+    update?: (...params: Parameters<Required<SyncedCrudPropsBase<TRemote>>['update']>) => PromiseLike<PostgrestSingleResponse<TRemote>> | Promise<FunctionsResponse<NoInfer<TRemote>>>;
+    delete?: (...params: Parameters<Required<SyncedCrudPropsBase<TRemote>>['delete']>) => PromiseLike<PostgrestSingleResponse<TRemote>> | Promise<FunctionsResponse<NoInfer<TRemote>>>;
 }
 declare function getSyncedSupabaseConfiguration(): SyncedSupabaseConfiguration;
 declare function configureSyncedSupabase(config: SyncedSupabaseConfiguration): void;
-declare function syncedSupabase<Client extends SupabaseClient, Collection extends SupabaseCollectionOf<Client> & string, AsOption extends CrudAsOption = 'object', TRemote extends SupabaseRowOf<Client, Collection> = SupabaseRowOf<Client, Collection>, TLocal = TRemote>(props: SyncedSupabaseProps<Client, Collection, AsOption, TRemote, TLocal>): SyncedCrudReturnType<TLocal, AsOption>;
+declare function syncedSupabase<Client extends SupabaseClient<any, any>, Collection extends SupabaseCollectionOf<Client, SchemaName> & string, SchemaName extends SchemaNameOf<Client> = 'public', AsOption extends CrudAsOption = 'object', TRemote extends SupabaseRowOf<Client, Collection, SchemaName> = SupabaseRowOf<Client, Collection, SchemaName>, TLocal = TRemote>(props: SyncedSupabaseProps<Client, Collection, SchemaName, AsOption, TRemote, TLocal>): SyncedCrudReturnType<TLocal, AsOption>;
 
 export { type SupabaseCollectionOf, type SupabaseRowOf, type SupabaseSchemaOf, type SupabaseTableOf, type SyncedSupabaseConfig, type SyncedSupabaseConfiguration, configureSyncedSupabase, getSyncedSupabaseConfiguration, syncedSupabase };

package/sync-plugins/supabase.d.ts

@@ -2,12 +2,17 @@ import { Observable } from '@legendapp/state';
 import { SyncedOptions, SyncedOptionsGlobal, SyncedGetParams } from '@legendapp/state/sync';
 import { SyncedCrudPropsBase, CrudAsOption, SyncedCrudReturnType, SyncedCrudPropsMany } from '@legendapp/state/sync-plugins/crud';
 import { PostgrestQueryBuilder, PostgrestFilterBuilder } from '@supabase/postgrest-js';
-import { SupabaseClient } from '@supabase/supabase-js';
+import { SupabaseClient, PostgrestSingleResponse } from '@supabase/supabase-js';
+import { FunctionsResponse } from '@supabase/functions-js';
 
+type DatabaseOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer TDB> ? TDB : never;
+type SchemaNameOf<Client extends SupabaseClient> = keyof DatabaseOf<Client>;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type IsUnionOfStrings<T> = [T] extends [string] ? ([T] extends [UnionToIntersection<T>] ? false : true) : false;
 type SupabaseSchemaOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer _, infer __, infer Schema> ? Schema : never;
-type SupabaseTableOf<Client extends SupabaseClient> = SupabaseSchemaOf<Client>['Tables'];
-type SupabaseCollectionOf<Client extends SupabaseClient> = keyof SupabaseTableOf<Client>;
-type SupabaseRowOf<Client extends SupabaseClient, Collection extends SupabaseCollectionOf<Client>> = SupabaseTableOf<Client>[Collection]['Row'];
+type SupabaseTableOf<Client extends SupabaseClient, SchemaName extends SchemaNameOf<Client>> = DatabaseOf<Client>[SchemaName]['Tables'];
+type SupabaseCollectionOf<Client extends SupabaseClient, SchemaName extends SchemaNameOf<Client>> = keyof SupabaseTableOf<Client, IsUnionOfStrings<SchemaName> extends true ? 'public' : SchemaName>;
+type SupabaseRowOf<Client extends SupabaseClient, Collection extends SupabaseCollectionOf<Client, SchemaName>, SchemaName extends SchemaNameOf<Client>> = SupabaseTableOf<Client, SchemaName>[Collection]['Row'];
 type SyncedSupabaseConfig<TRemote extends {
     id: string | number;
 }, TLocal> = Omit<SyncedCrudPropsBase<TRemote, TLocal>, 'create' | 'update' | 'delete'>;
@@ -20,20 +25,25 @@ interface SyncedSupabaseConfiguration extends Omit<SyncedSupabaseConfig<{
     enabled?: Observable<boolean>;
     as?: Exclude<CrudAsOption, 'value'>;
 }
-interface SyncedSupabaseProps<Client extends SupabaseClient, Collection extends SupabaseCollectionOf<Client>, TOption extends CrudAsOption = 'object', TRemote extends SupabaseRowOf<Client, Collection> = SupabaseRowOf<Client, Collection>, TLocal = TRemote> extends SyncedSupabaseConfig<TRemote, TLocal>, SyncedCrudPropsMany<TRemote, TRemote, TOption> {
-    supabase: Client;
+interface SyncedSupabaseProps<Client extends SupabaseClient<any, any>, Collection extends SupabaseCollectionOf<Client, SchemaName>, SchemaName extends SchemaNameOf<Client> = 'public', TOption extends CrudAsOption = 'object', TRemote extends SupabaseRowOf<Client, Collection, SchemaName> = SupabaseRowOf<Client, Collection, SchemaName>, TLocal = TRemote> extends SyncedSupabaseConfig<TRemote, TLocal>, Omit<SyncedCrudPropsMany<TRemote, TRemote, TOption>, 'list'> {
+    supabase?: Client;
     collection: Collection;
-    select?: (query: PostgrestQueryBuilder<SupabaseSchemaOf<Client>, SupabaseTableOf<Client>[Collection], Collection>) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
-    filter?: (select: PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>, params: SyncedGetParams) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
+    schema?: SchemaName;
+    select?: (query: PostgrestQueryBuilder<SupabaseSchemaOf<Client>, SupabaseTableOf<Client, SchemaName>[Collection], Collection>) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
+    filter?: (select: PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>, params: SyncedGetParams<TRemote>) => PostgrestFilterBuilder<SupabaseSchemaOf<Client>, TRemote, TRemote[], Collection, []>;
     actions?: ('create' | 'read' | 'update' | 'delete')[];
     realtime?: boolean | {
         schema?: string;
         filter?: string;
     };
     stringifyDates?: boolean;
+    list?: (...params: Parameters<Required<SyncedCrudPropsMany<TRemote, TLocal, TOption>>['list']>) => PromiseLike<PostgrestSingleResponse<TRemote[]>> | Promise<FunctionsResponse<NoInfer<TRemote>[]>>;
+    create?: (...params: Parameters<Required<SyncedCrudPropsBase<TRemote>>['create']>) => PromiseLike<PostgrestSingleResponse<TRemote>> | Promise<FunctionsResponse<NoInfer<TRemote>>>;
+    update?: (...params: Parameters<Required<SyncedCrudPropsBase<TRemote>>['update']>) => PromiseLike<PostgrestSingleResponse<TRemote>> | Promise<FunctionsResponse<NoInfer<TRemote>>>;
+    delete?: (...params: Parameters<Required<SyncedCrudPropsBase<TRemote>>['delete']>) => PromiseLike<PostgrestSingleResponse<TRemote>> | Promise<FunctionsResponse<NoInfer<TRemote>>>;
 }
 declare function getSyncedSupabaseConfiguration(): SyncedSupabaseConfiguration;
 declare function configureSyncedSupabase(config: SyncedSupabaseConfiguration): void;
-declare function syncedSupabase<Client extends SupabaseClient, Collection extends SupabaseCollectionOf<Client> & string, AsOption extends CrudAsOption = 'object', TRemote extends SupabaseRowOf<Client, Collection> = SupabaseRowOf<Client, Collection>, TLocal = TRemote>(props: SyncedSupabaseProps<Client, Collection, AsOption, TRemote, TLocal>): SyncedCrudReturnType<TLocal, AsOption>;
+declare function syncedSupabase<Client extends SupabaseClient<any, any>, Collection extends SupabaseCollectionOf<Client, SchemaName> & string, SchemaName extends SchemaNameOf<Client> = 'public', AsOption extends CrudAsOption = 'object', TRemote extends SupabaseRowOf<Client, Collection, SchemaName> = SupabaseRowOf<Client, Collection, SchemaName>, TLocal = TRemote>(props: SyncedSupabaseProps<Client, Collection, SchemaName, AsOption, TRemote, TLocal>): SyncedCrudReturnType<TLocal, AsOption>;
 
 export { type SupabaseCollectionOf, type SupabaseRowOf, type SupabaseSchemaOf, type SupabaseTableOf, type SyncedSupabaseConfig, type SyncedSupabaseConfiguration, configureSyncedSupabase, getSyncedSupabaseConfiguration, syncedSupabase };

package/sync-plugins/supabase.js

@@ -18,12 +18,22 @@ function configureSyncedSupabase(config) {
   }
   Object.assign(supabaseConfig, sync.removeNullUndefined(rest));
 }
+function wrapSupabaseFn(fn) {
+  return async (...args) => {
+    const { data, error } = await fn(...args);
+    if (error) {
+      throw new Error(error.message);
+    }
+    return data;
+  };
+}
 function syncedSupabase(props) {
   props = { ...supabaseConfig, ...props };
   const {
-    supabase: client,
+    supabase,
     collection,
     select: selectFn,
+    schema,
     filter,
     actions,
     fieldCreatedAt: fieldCreatedAtParam,
@@ -36,14 +46,21 @@ function syncedSupabase(props) {
     waitFor,
     waitForSet,
     generateId,
+    mode,
+    list: listParam,
+    create: createParam,
+    update: updateParam,
+    delete: deleteParam,
     ...rest
   } = props;
+  const client = supabase;
   const fieldCreatedAt = fieldCreatedAtParam || (changesSince === "last-sync" ? "created_at" : void 0);
   const fieldUpdatedAt = fieldUpdatedAtParam || (changesSince === "last-sync" ? "updated_at" : void 0);
   const fieldDeleted = fieldDeletedParam || (changesSince === "last-sync" ? "deleted" : void 0);
-  const list = !actions || actions.includes("read") ? async (params) => {
+  const list = !actions || actions.includes("read") ? listParam ? wrapSupabaseFn(listParam) : async (params) => {
     const { lastSync } = params;
-    const from = client.from(collection);
+    const clientSchema = schema ? client.schema(schema) : client;
+    const from = clientSchema.from(collection);
     let select = selectFn ? selectFn(from) : from.select();
     if (changesSince === "last-sync" && lastSync) {
       const date = new Date(lastSync).toISOString();
@@ -58,8 +75,8 @@ function syncedSupabase(props) {
     }
     return data || [];
   } : void 0;
-  const upsert = async (input) => {
-    const res = await client.from(collection).upsert(input).select();
+  const create = createParam ? wrapSupabaseFn(createParam) : !actions || actions.includes("create") ? async (input) => {
+    const res = await client.from(collection).insert(input).select();
     const { data, error } = res;
     if (data) {
       const created = data[0];
@@ -67,10 +84,18 @@ function syncedSupabase(props) {
     } else {
       throw new Error(error == null ? void 0 : error.message);
     }
-  };
-  const create = !actions || actions.includes("create") ? upsert : void 0;
-  const update = !actions || actions.includes("update") ? upsert : void 0;
-  const deleteFn = !fieldDeleted && (!actions || actions.includes("delete")) ? async (input) => {
+  } : void 0;
+  const update = !actions || actions.includes("update") ? updateParam ? wrapSupabaseFn(updateParam) : async (input) => {
+    const res = await client.from(collection).update(input).eq("id", input.id).select();
+    const { data, error } = res;
+    if (data) {
+      const created = data[0];
+      return created;
+    } else {
+      throw new Error(error == null ? void 0 : error.message);
+    }
+  } : void 0;
+  const deleteFn = !fieldDeleted && (!actions || actions.includes("delete")) ? deleteParam ? wrapSupabaseFn(deleteParam) : async (input) => {
     const id = input.id;
     const res = await client.from(collection).delete().eq("id", id).select();
     const { data, error } = res;
@@ -82,13 +107,13 @@ function syncedSupabase(props) {
     }
   } : void 0;
   const subscribe = realtime ? ({ node, value$, update: update2 }) => {
-    const { filter: filter2, schema } = state.isObject(realtime) ? realtime : {};
+    const { filter: filter2, schema: schema2 } = state.isObject(realtime) ? realtime : {};
     const channel = client.channel(`LS_${node.key || ""}${channelNum++}`).on(
       "postgres_changes",
       {
         event: "*",
         table: collection,
-        schema: schema || "public",
+        schema: schema2 || "public",
         filter: filter2 || void 0
       },
       (payload) => {
@@ -96,25 +121,30 @@ function syncedSupabase(props) {
         const { eventType, new: value, old } = payload;
         if (eventType === "INSERT" || eventType === "UPDATE") {
           const cur = (_a = value$.peek()) == null ? void 0 : _a[value.id];
-          const curDateStr = cur && (fieldUpdatedAt && cur[fieldUpdatedAt] || fieldCreatedAt || cur[fieldCreatedAt]);
-          const valueDateStr = fieldUpdatedAt && value[fieldUpdatedAt] || fieldCreatedAt && value[fieldCreatedAt];
-          const valueDate = +new Date(valueDateStr);
-          if (valueDateStr && (!curDateStr || valueDate > +new Date(curDateStr))) {
+          let isOk = !fieldUpdatedAt;
+          let lastSync = void 0;
+          if (!isOk) {
+            const curDateStr = cur && (fieldUpdatedAt && cur[fieldUpdatedAt] || fieldCreatedAt || cur[fieldCreatedAt]);
+            const valueDateStr = fieldUpdatedAt && value[fieldUpdatedAt] || fieldCreatedAt && value[fieldCreatedAt];
+            lastSync = +new Date(valueDateStr);
+            isOk = valueDateStr && (!curDateStr || lastSync > +new Date(curDateStr));
+          }
+          if (isOk) {
             update2({
-              value: { [value.id]: value },
-              lastSync: valueDate,
+              value: [value],
+              lastSync,
               mode: "merge"
             });
           }
         } else if (eventType === "DELETE") {
-          const { id } = old;
+          old[state.symbolDelete] = true;
           update2({
-            value: { [id]: state.symbolDelete }
+            value: [old]
           });
         }
       }
     ).subscribe();
-    return channel.unsubscribe;
+    return () => channel.unsubscribe();
   } : void 0;
   let transform = transformParam;
   if (stringifyDates) {
@@ -123,6 +153,7 @@ function syncedSupabase(props) {
   }
   return crud.syncedCrud({
     ...rest,
+    mode: mode || "merge",
     list,
     create,
     update,
@@ -135,7 +166,7 @@ function syncedSupabase(props) {
     transform,
     generateId,
     waitFor: () => isEnabled$.get() && (waitFor ? state.computeSelector(waitFor) : true),
-    waitForSet
+    waitForSet: (params) => isEnabled$.get() && (waitForSet ? state.isFunction(waitForSet) ? waitForSet(params) : waitForSet : true)
   });
 }