@legendapp/state 3.0.0-alpha.1 → 3.0.0-alpha.3

package/sync-plugins/supabase.d.mts

@@ -0,0 +1,39 @@
+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';
+
+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 SyncedSupabaseConfig<TRemote extends {
+    id: string | number;
+}, TLocal> = Omit<SyncedCrudPropsBase<TRemote, TLocal>, 'create' | 'update' | 'delete'>;
+interface SyncedSupabaseConfiguration extends Omit<SyncedSupabaseConfig<{
+    id: string | number;
+}, {
+    id: string | number;
+}>, 'persist' | keyof SyncedOptions> {
+    persist?: SyncedOptionsGlobal;
+    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;
+    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, []>;
+    actions?: ('create' | 'read' | 'update' | 'delete')[];
+    realtime?: boolean | {
+        schema?: string;
+        filter?: string;
+    };
+    stringifyDates?: boolean;
+}
+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>;
+
+export { type SupabaseCollectionOf, type SupabaseRowOf, type SupabaseSchemaOf, type SupabaseTableOf, type SyncedSupabaseConfig, type SyncedSupabaseConfiguration, configureSyncedSupabase, getSyncedSupabaseConfiguration, syncedSupabase };

package/sync-plugins/supabase.d.ts

@@ -1,16 +1,17 @@
 import { Observable } from '@legendapp/state';
-import { SyncedOptions, SyncedOptionsGlobal, type SyncedGetParams } from '@legendapp/state/sync';
-import { CrudAsOption, SyncedCrudPropsBase, SyncedCrudPropsMany, SyncedCrudReturnType } from '@legendapp/state/sync-plugins/crud';
-import type { PostgrestFilterBuilder, PostgrestQueryBuilder } from '@supabase/postgrest-js';
-import type { SupabaseClient } from '@supabase/supabase-js';
-export type SupabaseSchemaOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer _, infer __, infer Schema> ? Schema : never;
-export type SupabaseTableOf<Client extends SupabaseClient> = SupabaseSchemaOf<Client>['Tables'];
-export type SupabaseCollectionOf<Client extends SupabaseClient> = keyof SupabaseTableOf<Client>;
-export type SupabaseRowOf<Client extends SupabaseClient, Collection extends SupabaseCollectionOf<Client>> = SupabaseTableOf<Client>[Collection]['Row'];
-export type SyncedSupabaseConfig<TRemote extends {
+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';
+
+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 SyncedSupabaseConfig<TRemote extends {
     id: string | number;
 }, TLocal> = Omit<SyncedCrudPropsBase<TRemote, TLocal>, 'create' | 'update' | 'delete'>;
-export interface SyncedSupabaseConfiguration extends Omit<SyncedSupabaseConfig<{
+interface SyncedSupabaseConfiguration extends Omit<SyncedSupabaseConfig<{
     id: string | number;
 }, {
     id: string | number;
@@ -31,7 +32,8 @@ interface SyncedSupabaseProps<Client extends SupabaseClient, Collection extends
     };
     stringifyDates?: boolean;
 }
-export declare function getSyncedSupabaseConfiguration(): SyncedSupabaseConfiguration;
-export declare function configureSyncedSupabase(config: SyncedSupabaseConfiguration): void;
-export 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>;
-export {};
+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>;
+
+export { type SupabaseCollectionOf, type SupabaseRowOf, type SupabaseSchemaOf, type SupabaseTableOf, type SyncedSupabaseConfig, type SyncedSupabaseConfiguration, configureSyncedSupabase, getSyncedSupabaseConfiguration, syncedSupabase };

package/sync-plugins/supabase.js

@@ -4,142 +4,142 @@ var state = require('@legendapp/state');
 var sync = require('@legendapp/state/sync');
 var crud = require('@legendapp/state/sync-plugins/crud');
 
-let channelNum = 1;
-const supabaseConfig = {};
-const isEnabled$ = state.observable(true);
+// src/sync-plugins/supabase.ts
+var channelNum = 1;
+var supabaseConfig = {};
+var isEnabled$ = state.observable(true);
 function getSyncedSupabaseConfiguration() {
-    return supabaseConfig;
+  return supabaseConfig;
 }
 function configureSyncedSupabase(config) {
-    const { enabled, ...rest } = config;
-    if (enabled !== undefined) {
-        isEnabled$.set(enabled);
-    }
-    Object.assign(supabaseConfig, sync.removeNullUndefined(rest));
+  const { enabled, ...rest } = config;
+  if (enabled !== void 0) {
+    isEnabled$.set(enabled);
+  }
+  Object.assign(supabaseConfig, sync.removeNullUndefined(rest));
 }
 function syncedSupabase(props) {
-    props = { ...supabaseConfig, ...props };
-    const { supabase: client, collection, select: selectFn, filter, actions, fieldCreatedAt: fieldCreatedAtParam, fieldUpdatedAt: fieldUpdatedAtParam, fieldDeleted: fieldDeletedParam, realtime, changesSince, transform: transformParam, stringifyDates, waitFor, waitForSet, generateId, ...rest } = props;
-    // If using last-sync mode then put it into soft delete mode
-    const fieldCreatedAt = fieldCreatedAtParam || (changesSince === 'last-sync' ? 'created_at' : undefined);
-    const fieldUpdatedAt = fieldUpdatedAtParam || (changesSince === 'last-sync' ? 'updated_at' : undefined);
-    const fieldDeleted = fieldDeletedParam || (changesSince === 'last-sync' ? 'deleted' : undefined);
-    const list = !actions || actions.includes('read')
-        ? async (params) => {
-            const { lastSync } = params;
-            const from = client.from(collection);
-            let select = selectFn ? selectFn(from) : from.select();
-            // in last-sync mode, filter for rows updated more recently than the last sync
-            if (changesSince === 'last-sync' && lastSync) {
-                const date = new Date(lastSync).toISOString();
-                select = select.gt(fieldUpdatedAt, date);
-            }
-            // filter with filter parameter
-            if (filter) {
-                select = filter(select, params);
-            }
-            const { data, error } = await select;
-            if (error) {
-                throw new Error(error === null || error === void 0 ? void 0 : error.message);
-            }
-            return (data || []);
-        }
-        : undefined;
-    const upsert = async (input) => {
-        const res = await client.from(collection).upsert(input).select();
-        const { data, error } = res;
-        if (data) {
-            const created = data[0];
-            return created;
-        }
-        else {
-            throw new Error(error === null || error === void 0 ? void 0 : error.message);
-        }
-    };
-    const create = !actions || actions.includes('create') ? upsert : undefined;
-    const update = !actions || actions.includes('update') ? upsert : undefined;
-    const deleteFn = !fieldDeleted && (!actions || actions.includes('delete'))
-        ? async (input) => {
-            const id = input.id;
-            const res = await client.from(collection).delete().eq('id', id).select();
-            const { data, error } = res;
-            if (data) {
-                const created = data[0];
-                return created;
-            }
-            else {
-                throw new Error(error === null || error === void 0 ? void 0 : error.message);
-            }
-        }
-        : undefined;
-    const subscribe = realtime
-        ? ({ node, value$, update }) => {
-            const { filter, schema } = (state.isObject(realtime) ? realtime : {});
-            const channel = client
-                .channel(`LS_${node.key || ''}${channelNum++}`)
-                .on('postgres_changes', {
-                event: '*',
-                table: collection,
-                schema: schema || 'public',
-                filter: filter || undefined,
-            }, (payload) => {
-                var _a;
-                const { eventType, new: value, old } = payload;
-                if (eventType === 'INSERT' || eventType === 'UPDATE') {
-                    const cur = (_a = value$.peek()) === null || _a === void 0 ? 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);
-                    // Check if new or newer than last seen locally
-                    if (valueDateStr && (!curDateStr || valueDate > +new Date(curDateStr))) {
-                        // Update local with the new value
-                        update({
-                            value: { [value.id]: value },
-                            lastSync: valueDate,
-                            mode: 'merge',
-                        });
-                    }
-                }
-                else if (eventType === 'DELETE') {
-                    const { id } = old;
-                    update({
-                        value: { [id]: state.symbolDelete },
-                    });
-                }
-            })
-                .subscribe();
-            return channel.unsubscribe;
-        }
-        : undefined;
-    let transform = transformParam;
-    if (stringifyDates) {
-        const stringifier = sync.transformStringifyDates();
-        transform = transform ? sync.combineTransforms(stringifier, transform) : stringifier;
+  props = { ...supabaseConfig, ...props };
+  const {
+    supabase: client,
+    collection,
+    select: selectFn,
+    filter,
+    actions,
+    fieldCreatedAt: fieldCreatedAtParam,
+    fieldUpdatedAt: fieldUpdatedAtParam,
+    fieldDeleted: fieldDeletedParam,
+    realtime,
+    changesSince,
+    transform: transformParam,
+    stringifyDates,
+    waitFor,
+    waitForSet,
+    generateId,
+    ...rest
+  } = props;
+  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 { lastSync } = params;
+    const from = client.from(collection);
+    let select = selectFn ? selectFn(from) : from.select();
+    if (changesSince === "last-sync" && lastSync) {
+      const date = new Date(lastSync).toISOString();
+      select = select.gt(fieldUpdatedAt, date);
     }
-    return crud.syncedCrud({
-        ...rest,
-        list,
-        create,
-        update,
-        delete: deleteFn,
-        subscribe,
-        fieldCreatedAt,
-        fieldUpdatedAt,
-        fieldDeleted,
-        updatePartial: false,
-        onSavedUpdate: 'createdUpdatedAt',
-        transform,
-        generateId,
-        waitFor: () => isEnabled$.get() && (waitFor ? state.computeSelector(waitFor) : true),
-        waitForSet,
-    });
+    if (filter) {
+      select = filter(select, params);
+    }
+    const { data, error } = await select;
+    if (error) {
+      throw new Error(error == null ? void 0 : error.message);
+    }
+    return data || [];
+  } : void 0;
+  const upsert = async (input) => {
+    const res = await client.from(collection).upsert(input).select();
+    const { data, error } = res;
+    if (data) {
+      const created = data[0];
+      return created;
+    } 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) => {
+    const id = input.id;
+    const res = await client.from(collection).delete().eq("id", 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 subscribe = realtime ? ({ node, value$, update: update2 }) => {
+    const { filter: filter2, schema } = state.isObject(realtime) ? realtime : {};
+    const channel = client.channel(`LS_${node.key || ""}${channelNum++}`).on(
+      "postgres_changes",
+      {
+        event: "*",
+        table: collection,
+        schema: schema || "public",
+        filter: filter2 || void 0
+      },
+      (payload) => {
+        var _a;
+        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))) {
+            update2({
+              value: { [value.id]: value },
+              lastSync: valueDate,
+              mode: "merge"
+            });
+          }
+        } else if (eventType === "DELETE") {
+          const { id } = old;
+          update2({
+            value: { [id]: state.symbolDelete }
+          });
+        }
+      }
+    ).subscribe();
+    return channel.unsubscribe;
+  } : void 0;
+  let transform = transformParam;
+  if (stringifyDates) {
+    const stringifier = sync.transformStringifyDates();
+    transform = transform ? sync.combineTransforms(stringifier, transform) : stringifier;
+  }
+  return crud.syncedCrud({
+    ...rest,
+    list,
+    create,
+    update,
+    delete: deleteFn,
+    subscribe,
+    fieldCreatedAt,
+    fieldUpdatedAt,
+    fieldDeleted,
+    updatePartial: false,
+    onSavedUpdate: "createdUpdatedAt",
+    transform,
+    generateId,
+    waitFor: () => isEnabled$.get() && (waitFor ? state.computeSelector(waitFor) : true),
+    waitForSet
+  });
 }
 
 exports.configureSyncedSupabase = configureSyncedSupabase;
 exports.getSyncedSupabaseConfiguration = getSyncedSupabaseConfiguration;
 exports.syncedSupabase = syncedSupabase;
-//# sourceMappingURL=supabase.js.map

package/sync-plugins/supabase.mjs

@@ -2,140 +2,140 @@ import { observable, computeSelector, isObject, symbolDelete } from '@legendapp/
 import { removeNullUndefined, transformStringifyDates, combineTransforms } from '@legendapp/state/sync';
 import { syncedCrud } from '@legendapp/state/sync-plugins/crud';
 
-let channelNum = 1;
-const supabaseConfig = {};
-const isEnabled$ = observable(true);
+// src/sync-plugins/supabase.ts
+var channelNum = 1;
+var supabaseConfig = {};
+var isEnabled$ = observable(true);
 function getSyncedSupabaseConfiguration() {
-    return supabaseConfig;
+  return supabaseConfig;
 }
 function configureSyncedSupabase(config) {
-    const { enabled, ...rest } = config;
-    if (enabled !== undefined) {
-        isEnabled$.set(enabled);
-    }
-    Object.assign(supabaseConfig, removeNullUndefined(rest));
+  const { enabled, ...rest } = config;
+  if (enabled !== void 0) {
+    isEnabled$.set(enabled);
+  }
+  Object.assign(supabaseConfig, removeNullUndefined(rest));
 }
 function syncedSupabase(props) {
-    props = { ...supabaseConfig, ...props };
-    const { supabase: client, collection, select: selectFn, filter, actions, fieldCreatedAt: fieldCreatedAtParam, fieldUpdatedAt: fieldUpdatedAtParam, fieldDeleted: fieldDeletedParam, realtime, changesSince, transform: transformParam, stringifyDates, waitFor, waitForSet, generateId, ...rest } = props;
-    // If using last-sync mode then put it into soft delete mode
-    const fieldCreatedAt = fieldCreatedAtParam || (changesSince === 'last-sync' ? 'created_at' : undefined);
-    const fieldUpdatedAt = fieldUpdatedAtParam || (changesSince === 'last-sync' ? 'updated_at' : undefined);
-    const fieldDeleted = fieldDeletedParam || (changesSince === 'last-sync' ? 'deleted' : undefined);
-    const list = !actions || actions.includes('read')
-        ? async (params) => {
-            const { lastSync } = params;
-            const from = client.from(collection);
-            let select = selectFn ? selectFn(from) : from.select();
-            // in last-sync mode, filter for rows updated more recently than the last sync
-            if (changesSince === 'last-sync' && lastSync) {
-                const date = new Date(lastSync).toISOString();
-                select = select.gt(fieldUpdatedAt, date);
-            }
-            // filter with filter parameter
-            if (filter) {
-                select = filter(select, params);
-            }
-            const { data, error } = await select;
-            if (error) {
-                throw new Error(error === null || error === void 0 ? void 0 : error.message);
-            }
-            return (data || []);
-        }
-        : undefined;
-    const upsert = async (input) => {
-        const res = await client.from(collection).upsert(input).select();
-        const { data, error } = res;
-        if (data) {
-            const created = data[0];
-            return created;
-        }
-        else {
-            throw new Error(error === null || error === void 0 ? void 0 : error.message);
-        }
-    };
-    const create = !actions || actions.includes('create') ? upsert : undefined;
-    const update = !actions || actions.includes('update') ? upsert : undefined;
-    const deleteFn = !fieldDeleted && (!actions || actions.includes('delete'))
-        ? async (input) => {
-            const id = input.id;
-            const res = await client.from(collection).delete().eq('id', id).select();
-            const { data, error } = res;
-            if (data) {
-                const created = data[0];
-                return created;
-            }
-            else {
-                throw new Error(error === null || error === void 0 ? void 0 : error.message);
-            }
-        }
-        : undefined;
-    const subscribe = realtime
-        ? ({ node, value$, update }) => {
-            const { filter, schema } = (isObject(realtime) ? realtime : {});
-            const channel = client
-                .channel(`LS_${node.key || ''}${channelNum++}`)
-                .on('postgres_changes', {
-                event: '*',
-                table: collection,
-                schema: schema || 'public',
-                filter: filter || undefined,
-            }, (payload) => {
-                var _a;
-                const { eventType, new: value, old } = payload;
-                if (eventType === 'INSERT' || eventType === 'UPDATE') {
-                    const cur = (_a = value$.peek()) === null || _a === void 0 ? 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);
-                    // Check if new or newer than last seen locally
-                    if (valueDateStr && (!curDateStr || valueDate > +new Date(curDateStr))) {
-                        // Update local with the new value
-                        update({
-                            value: { [value.id]: value },
-                            lastSync: valueDate,
-                            mode: 'merge',
-                        });
-                    }
-                }
-                else if (eventType === 'DELETE') {
-                    const { id } = old;
-                    update({
-                        value: { [id]: symbolDelete },
-                    });
-                }
-            })
-                .subscribe();
-            return channel.unsubscribe;
-        }
-        : undefined;
-    let transform = transformParam;
-    if (stringifyDates) {
-        const stringifier = transformStringifyDates();
-        transform = transform ? combineTransforms(stringifier, transform) : stringifier;
+  props = { ...supabaseConfig, ...props };
+  const {
+    supabase: client,
+    collection,
+    select: selectFn,
+    filter,
+    actions,
+    fieldCreatedAt: fieldCreatedAtParam,
+    fieldUpdatedAt: fieldUpdatedAtParam,
+    fieldDeleted: fieldDeletedParam,
+    realtime,
+    changesSince,
+    transform: transformParam,
+    stringifyDates,
+    waitFor,
+    waitForSet,
+    generateId,
+    ...rest
+  } = props;
+  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 { lastSync } = params;
+    const from = client.from(collection);
+    let select = selectFn ? selectFn(from) : from.select();
+    if (changesSince === "last-sync" && lastSync) {
+      const date = new Date(lastSync).toISOString();
+      select = select.gt(fieldUpdatedAt, date);
     }
-    return syncedCrud({
-        ...rest,
-        list,
-        create,
-        update,
-        delete: deleteFn,
-        subscribe,
-        fieldCreatedAt,
-        fieldUpdatedAt,
-        fieldDeleted,
-        updatePartial: false,
-        onSavedUpdate: 'createdUpdatedAt',
-        transform,
-        generateId,
-        waitFor: () => isEnabled$.get() && (waitFor ? computeSelector(waitFor) : true),
-        waitForSet,
-    });
+    if (filter) {
+      select = filter(select, params);
+    }
+    const { data, error } = await select;
+    if (error) {
+      throw new Error(error == null ? void 0 : error.message);
+    }
+    return data || [];
+  } : void 0;
+  const upsert = async (input) => {
+    const res = await client.from(collection).upsert(input).select();
+    const { data, error } = res;
+    if (data) {
+      const created = data[0];
+      return created;
+    } 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) => {
+    const id = input.id;
+    const res = await client.from(collection).delete().eq("id", 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 subscribe = realtime ? ({ node, value$, update: update2 }) => {
+    const { filter: filter2, schema } = isObject(realtime) ? realtime : {};
+    const channel = client.channel(`LS_${node.key || ""}${channelNum++}`).on(
+      "postgres_changes",
+      {
+        event: "*",
+        table: collection,
+        schema: schema || "public",
+        filter: filter2 || void 0
+      },
+      (payload) => {
+        var _a;
+        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))) {
+            update2({
+              value: { [value.id]: value },
+              lastSync: valueDate,
+              mode: "merge"
+            });
+          }
+        } else if (eventType === "DELETE") {
+          const { id } = old;
+          update2({
+            value: { [id]: symbolDelete }
+          });
+        }
+      }
+    ).subscribe();
+    return channel.unsubscribe;
+  } : void 0;
+  let transform = transformParam;
+  if (stringifyDates) {
+    const stringifier = transformStringifyDates();
+    transform = transform ? combineTransforms(stringifier, transform) : stringifier;
+  }
+  return syncedCrud({
+    ...rest,
+    list,
+    create,
+    update,
+    delete: deleteFn,
+    subscribe,
+    fieldCreatedAt,
+    fieldUpdatedAt,
+    fieldDeleted,
+    updatePartial: false,
+    onSavedUpdate: "createdUpdatedAt",
+    transform,
+    generateId,
+    waitFor: () => isEnabled$.get() && (waitFor ? computeSelector(waitFor) : true),
+    waitForSet
+  });
 }
 
 export { configureSyncedSupabase, getSyncedSupabaseConfiguration, syncedSupabase };
-//# sourceMappingURL=supabase.mjs.map

package/sync-plugins/tanstack-query.d.mts

@@ -0,0 +1,14 @@
+import { SyncedOptions } from '@legendapp/state/sync';
+import { QueryKey, QueryObserverOptions, QueryClient, MutationObserverOptions, DefaultError } from '@tanstack/query-core';
+
+interface ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'> {
+    queryKey?: TQueryKey | (() => TQueryKey);
+}
+interface SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends SyncedOptions<TData> {
+    queryClient: QueryClient;
+    query: ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    mutation?: MutationObserverOptions<TData, TError, void>;
+}
+declare function syncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): NonNullable<TData>;
+
+export { type ObservableQueryOptions, type SyncedQueryParams, syncedQuery };