@legendapp/state 2.2.0-next.78 → 2.2.0-next.79

package/src/sync/activateSyncedNode.ts

@@ -1,14 +1,12 @@
+import type { NodeValue, Observable, UpdateFn } from '@legendapp/state';
 import type {
-    NodeValue,
-    Observable,
-    ObservablePersistState,
     ObservableSyncFunctions,
     ObservableSyncGetParams,
     ObservableSyncSetParams,
     SyncedGetParams,
     SyncedSetParams,
-    UpdateFn,
-} from '@legendapp/state';
+} from './syncTypes';
+import type { ObservablePersistState } from './persistTypes';
 import { internal, isFunction, isPromise, mergeIntoObservable, whenReady } from '@legendapp/state';
 import { syncObservable } from './syncObservable';
 const { getProxy, globalState, runWithRetry, symbolLinked, setNodeValue, getNodeValue } = internal;

package/src/sync/configureObservableSync.ts

@@ -1,4 +1,4 @@
-import type { SyncedOptionsGlobal } from '@legendapp/state';
+import type { SyncedOptionsGlobal } from '@legendapp/state/sync';
 
 export const observableSyncConfiguration: SyncedOptionsGlobal = {};
 

package/src/{persistTypes.ts → sync/persistTypes.ts}

@@ -6,18 +6,18 @@ import type { AsyncStorageStatic } from '@react-native-async-storage/async-stora
 // @ts-ignore
 import type { DatabaseReference, Query } from 'firebase/database';
 
-import type { GetMode, PersistMetadata } from './syncTypes';
 import type {
     ArrayValue,
     Change,
     ClassConstructor,
+    GetMode,
     LinkedOptions,
     RecordValue,
-    RetryOptions,
     Selector,
     TypeAtPath,
-} from './observableInterfaces';
-import type { Observable, ObservableParam, ObservableState } from './observableTypes';
+} from '../observableInterfaces';
+import type { Observable, ObservableParam, ObservableState } from '../observableTypes';
+import type { PersistMetadata, RetryOptions } from './syncTypes';
 
 export interface PersistTransform<TOrig = any, TSaved = TOrig> {
     load?: (value: TSaved) => TOrig | Promise<TOrig>;

package/src/sync/syncObservable.ts

@@ -5,17 +5,7 @@ import type {
     NodeValue,
     Observable,
     ObservableObject,
-    ObservableOnChangeParams,
     ObservableParam,
-    ObservablePersistPlugin,
-    ObservableSyncClass,
-    ObservableSyncState,
-    PersistMetadata,
-    PersistOptions,
-    SyncTransform,
-    SyncTransformMethod,
-    Synced,
-    SyncedOptions,
     TypeAtPath,
     UpdateFnParams,
 } from '@legendapp/state';
@@ -37,10 +27,22 @@ import {
     when,
 } from '@legendapp/state';
 import { observableSyncConfiguration } from './configureObservableSync';
+import type { ObservableOnChangeParams } from './persistTypes';
 import { removeNullUndefined } from './syncHelpers';
 import { syncObservableAdapter } from './syncObservableAdapter';
+import type {
+    ObservablePersistPlugin,
+    ObservableSyncClass,
+    ObservableSyncState,
+    PersistMetadata,
+    PersistOptions,
+    SyncTransform,
+    SyncTransformMethod,
+    Synced,
+    SyncedOptions,
+} from './syncTypes';
 
-const { createPreviousHandler, getValueAtPath, globalState, symbolLinked, getNode, getNodeValue } = internal;
+const { createPreviousHandler, clone, getValueAtPath, globalState, symbolLinked, getNode, getNodeValue } = internal;
 
 export const mapSyncPlugins: WeakMap<
     ClassConstructor<ObservablePersistPlugin | ObservableSyncClass>,
@@ -832,15 +834,13 @@ export function syncObservable<T>(
     const node = getNode(obs$);
 
     // Merge remote sync options with global options
-    if (syncOptions) {
-        syncOptions = Object.assign(
-            {
-                syncMode: 'auto',
-            } as SyncedOptions,
-            observableSyncConfiguration,
-            removeNullUndefined(syncOptions),
-        );
-    }
+    syncOptions = mergeIntoObservable(
+        {
+            syncMode: 'auto',
+        } as SyncedOptions,
+        clone(observableSyncConfiguration),
+        removeNullUndefined(syncOptions || {}),
+    );
     const localState: LocalState = {};
     let sync: () => Promise<void>;
 

package/src/sync/syncObservableAdapter.ts

@@ -1,4 +1,5 @@
-import { ObservableSyncGetParams, SyncedOptions, isPromise, type ObservableSyncClass } from '@legendapp/state';
+import { isPromise } from '@legendapp/state';
+import { ObservableSyncGetParams, SyncedOptions, type ObservableSyncClass } from '@legendapp/state/sync';
 
 export function syncObservableAdapter<T = {}>({ get, set }: SyncedOptions<T>): ObservableSyncClass {
     const ret: ObservableSyncClass = {};

package/src/{syncTypes.ts → sync/syncTypes.ts}

@@ -7,14 +7,14 @@ import type { AsyncStorageStatic } from '@react-native-async-storage/async-stora
 import {
     Change,
     ClassConstructor,
+    GetMode,
     LinkedOptions,
     NodeValue,
-    RetryOptions,
     SetParams,
     UpdateFn,
     UpdateFnParams,
-} from './observableInterfaces';
-import { Observable, ObservableParam, ObservableState } from './observableTypes';
+} from '../observableInterfaces';
+import { Observable, ObservableParam, ObservableState } from '../observableTypes';
 
 export interface PersistOptions<T = any> {
     name: string;
@@ -54,8 +54,6 @@ export interface SyncedSubscribeParams {
     refresh: () => void;
 }
 
-export type GetMode = 'set' | 'assign' | 'merge' | 'append' | 'prepend';
-
 export interface SyncedOptions<T = any> extends Omit<LinkedOptions<T>, 'get' | 'set'> {
     get?: (params: SyncedGetParams) => Promise<T> | T;
     set?: (params: SyncedSetParams<T>) => void | Promise<any>;
@@ -172,3 +170,19 @@ export interface ObservableSyncFunctions<T = any> {
         params: ObservableSyncSetParams<T>,
     ): void | Promise<void | { changes?: object | undefined; dateModified?: number; lastSync?: number }>;
 }
+
+export interface RetryOptions {
+    infinite?: boolean;
+    times?: number;
+    delay?: number;
+    backoff?: 'constant' | 'exponential';
+    maxDelay?: number;
+}
+
+export interface SubscribeOptions {
+    node: NodeValue;
+    update: UpdateFn;
+    refresh: () => void;
+}
+
+export type Synced<T> = T;

package/src/sync/synced.ts

@@ -1,4 +1,4 @@
-import type { Synced, SyncedOptions } from '@legendapp/state';
+import type { Synced, SyncedOptions } from './syncTypes';
 import { internal } from '@legendapp/state';
 import { enableActivateSyncedNode } from './activateSyncedNode';
 

package/src/sync-plugins/crud.ts

@@ -1,17 +1,13 @@
+import { internal, isArray, isNullOrUndefined, isNumber, isObject, isString } from '@legendapp/state';
 import {
+    synced,
+    diffObjects,
     SyncTransform,
     SyncTransformMethod,
     SyncedGetParams,
     SyncedOptions,
     SyncedSetParams,
-    internal,
-    isArray,
-    isNullOrUndefined,
-    isNumber,
-    isObject,
-    isString,
-} from '@legendapp/state';
-import { synced, diffObjects } from '@legendapp/state/sync';
+} from '@legendapp/state/sync';
 
 const { clone } = internal;
 
@@ -43,6 +39,7 @@ export interface SyncedCrudPropsBase<TRemote extends { id: string | number }, TL
     fieldCreatedAt?: string;
     updatePartial?: boolean;
     changesSince?: 'all' | 'last-sync';
+    generateId?: () => string | number;
 }
 
 type InitialValue<T, TAsOption extends CrudAsOption> = TAsOption extends 'Map'
@@ -134,6 +131,13 @@ export function combineTransforms<T, T2>(
     };
 }
 
+function ensureId(obj: { id: string | number }, generateId: () => string | number) {
+    if (!obj.id) {
+        obj.id = generateId();
+    }
+    return obj.id;
+}
+
 export function syncedCrud<TRemote extends { id: string | number }, TLocal = TRemote>(
     props: SyncedCrudPropsBase<TRemote, TLocal> & SyncedCrudPropsSingle<TRemote, TLocal>,
 ): SyncedCrudReturnType<TLocal, 'first'>;
@@ -165,6 +169,7 @@ export function syncedCrud<
         onSaved,
         mode: modeParam,
         changesSince,
+        generateId,
         ...rest
     } = props;
 
@@ -242,9 +247,12 @@ export function syncedCrud<
                   changes.forEach(({ path, prevAtPath, valueAtPath }) => {
                       if (asType === 'first') {
                           if (value) {
-                              const id = value?.id;
+                              let id = value?.id;
+                              const isCreate = fieldCreatedAt ? !value[fieldCreatedAt!] : !prevAtPath;
+                              if (!id && generateId) {
+                                  id = ensureId(value, generateId);
+                              }
                               if (id) {
-                                  const isCreate = fieldCreatedAt ? !value[fieldCreatedAt!] : !prevAtPath;
                                   if (isCreate || retryAsCreate) {
                                       creates.set(id, value);
                                   } else if (path.length === 0) {
@@ -308,6 +316,12 @@ export function syncedCrud<
                                   ? !item[fieldUpdatedAt]
                                   : isCreateGuess;
                               if (isCreate) {
+                                  if (generateId) {
+                                      ensureId(item, generateId);
+                                  }
+                                  if (!item.id) {
+                                      console.error('[legend-state]: added item without an id');
+                                  }
                                   if (createFn) {
                                       creates.set(item.id, item);
                                   } else {
@@ -362,7 +376,10 @@ export function syncedCrud<
                       }),
                       ...Array.from(updates).map(([itemKey, itemValue]) => {
                           const toSave = updatePartial
-                              ? diffObjects(asType === 'first' ? valuePrevious : valuePrevious[itemKey], itemValue)
+                              ? Object.assign(
+                                    diffObjects(asType === 'first' ? valuePrevious : valuePrevious[itemKey], itemValue),
+                                    { id: (itemValue as any).id },
+                                )
                               : itemValue;
                           const changed = transformOut(toSave as TLocal, transform?.save) as TRemote;
 

package/src/sync-plugins/fetch.ts

@@ -1,5 +1,5 @@
-import { Selector, SyncTransform, Synced, SyncedOptions, SyncedSetParams, computeSelector } from '@legendapp/state';
-import { synced } from '@legendapp/state/sync';
+import { Selector, computeSelector } from '@legendapp/state';
+import { synced, SyncTransform, Synced, SyncedOptions, SyncedSetParams } from '@legendapp/state/sync';
 
 export interface SyncedFetchProps<TRemote, TLocal> extends Omit<SyncedOptions, 'get' | 'set' | 'transform'> {
     get: Selector<string>;

package/src/sync-plugins/keel.ts

@@ -1,12 +1,11 @@
+import { computeSelector, observable, when, internal } from '@legendapp/state';
 import {
-    SyncedSetParams,
-    computeSelector,
-    internal,
-    observable,
-    when,
+    SyncedOptions,
+    removeNullUndefined,
     type SyncedGetParams,
+    type SyncedSetParams,
     type SyncedSubscribeParams,
-} from '@legendapp/state';
+} from '@legendapp/state/sync';
 import {
     CrudAsOption,
     CrudResult,
@@ -54,7 +53,6 @@ interface ListGetParams {
     refresh?: () => void;
     after?: string;
     first?: number;
-    maxResults?: number;
 }
 
 export interface KeelRealtimePlugin {
@@ -62,7 +60,20 @@ export interface KeelRealtimePlugin {
     setLatestChange: (realtimeKey: string, time: Date) => void;
 }
 
-interface SyncedKeelConfiguration {
+export interface SyncedKeelConfiguration
+    extends Omit<
+        SyncedCrudPropsBase<any>,
+        | keyof SyncedOptions
+        | 'create'
+        | 'update'
+        | 'delete'
+        | 'onSaved'
+        | 'transform'
+        | 'updatePartial'
+        | 'subscribe'
+        | 'fieldCreatedAt'
+        | 'fieldUpdatedAt'
+    > {
     client: {
         auth: { refresh: () => Promise<boolean>; isAuthenticated: () => Promise<boolean> };
         api: { queries: Record<string, (i: any) => Promise<any>> };
@@ -84,14 +95,14 @@ interface PageInfo {
 interface SyncedKeelPropsMany<TRemote, TLocal, AOption extends CrudAsOption>
     extends Omit<SyncedCrudPropsMany<TRemote, TLocal, AOption>, 'list'> {
     list?: (params: ListGetParams) => Promise<CrudResult<APIResult<{ results: TRemote[]; pageInfo: any }>>>;
-    maxResults?: number;
+    first?: number;
     get?: never;
 }
 
 interface SyncedKeelPropsSingle<TRemote, TLocal> extends Omit<SyncedCrudPropsSingle<TRemote, TLocal>, 'get'> {
     get?: (params: GetGetParams) => Promise<APIResult<TRemote>>;
 
-    maxResults?: never;
+    first?: never;
     list?: never;
     as?: never;
 }
@@ -103,18 +114,15 @@ interface SyncedKeelPropsBase<TRemote extends { id: string }, TLocal = TRemote>
     delete?: (params: { id: string }) => Promise<APIResult<string>>;
 }
 
-let _client: SyncedKeelConfiguration['client'];
-let _asOption: CrudAsOption;
-let _realtimePlugin: KeelRealtimePlugin;
-let _onError: (error: APIResult<any>['error']) => void;
+const keelConfig: SyncedKeelConfiguration = {} as SyncedKeelConfiguration;
 const modifiedClients = new WeakSet<Record<string, any>>();
 const isEnabled$ = observable(true);
 
 async function ensureAuthToken() {
     await when(isEnabled$.get());
-    let isAuthed = await _client.auth.isAuthenticated();
+    let isAuthed = await keelConfig.client.auth.isAuthenticated();
     if (!isAuthed) {
-        isAuthed = await _client.auth.refresh();
+        isAuthed = await keelConfig.client.auth.refresh();
     }
 
     return isAuthed;
@@ -144,25 +152,17 @@ function convertObjectToCreate<TRemote, TLocal>(item: TRemote) {
     return cloned as unknown as TLocal;
 }
 
-export function configureSyncedKeel({
-    realtimePlugin,
-    as: asOption,
-    client,
-    enabled,
-    onError,
-}: SyncedKeelConfiguration) {
-    if (asOption) {
-        _asOption = asOption;
-    }
-    if (client) {
-        _client = client;
-    }
+export function configureSyncedKeel(config: SyncedKeelConfiguration) {
+    const { enabled, realtimePlugin, ...rest } = config;
+    Object.assign(keelConfig, removeNullUndefined(rest));
+
     if (enabled !== undefined) {
         isEnabled$.set(enabled);
     }
+    const { client } = keelConfig;
 
     if (realtimePlugin) {
-        _realtimePlugin = realtimePlugin;
+        keelConfig.realtimePlugin = realtimePlugin;
         if (client && !modifiedClients.has(client)) {
             modifiedClients.add(client);
             const queries = client.api.queries;
@@ -194,10 +194,6 @@ export function configureSyncedKeel({
             });
         }
     }
-
-    if (onError) {
-        _onError = onError;
-    }
 }
 
 const NumPerPage = 200;
@@ -214,10 +210,10 @@ async function getAllPages<TRemote>(
     let pageInfo: PageInfo | undefined = undefined;
     let subscribe_;
 
-    const { maxResults } = params;
+    const { first: firstParam } = params;
 
     do {
-        const first = maxResults ? Math.min(maxResults - allData.length, NumPerPage) : NumPerPage;
+        const first = firstParam ? Math.min(firstParam - allData.length, NumPerPage) : NumPerPage;
         if (first < 1) {
             break;
         }
@@ -265,19 +261,24 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
         create: createParam,
         update: updateParam,
         delete: deleteParam,
-        maxResults,
-        initial,
+        first,
         waitFor,
         waitForSet,
+        generateId: generateIdParam,
         ...rest
     } = props;
 
+    const { changesSince } = props;
+
     let asType = props.as as TOption;
 
     if (!asType) {
-        asType = (getParam ? 'first' : _asOption || undefined) as TOption;
+        asType = (getParam ? 'first' : keelConfig.as || undefined) as TOption;
     }
 
+    const generateId = generateIdParam || keelConfig.generateId;
+
+    const realtimePlugin = keelConfig.realtimePlugin;
     let realtimeKeyList: string | undefined = undefined;
     let realtimeKeyGet: string | undefined = undefined;
 
@@ -287,10 +288,13 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
     const list = listParam
         ? async (listParams: SyncedGetParams) => {
               const { lastSync, refresh } = listParams;
-              const queryBySync = !!lastSync;
+              const queryBySync = !!lastSync && changesSince === 'last-sync';
+              // If this is one of the customized functions for use with realtime then we need to pass
+              // the refresh function to it
               const isRawRequest = (listParam || getParam).toString().includes('rawRequest');
+              // If querying with lastSync pass it to the "where" parameters
               const where = queryBySync ? { updatedAt: { after: new Date(+new Date(lastSync) + 1) } } : {};
-              const params: ListGetParams = isRawRequest ? { where, maxResults } : { where, refresh, maxResults };
+              const params: ListGetParams = isRawRequest ? { where, first } : { where, refresh, first };
 
               // TODO: Error?
               const { results, subscribe } = await getAllPages(listParam, params);
@@ -342,12 +346,12 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
 
             const updatedAt = data[fieldUpdatedAt as keyof TLocal] as Date;
 
-            if (updatedAt && _realtimePlugin) {
+            if (updatedAt && realtimePlugin) {
                 if (realtimeKeyGet) {
-                    _realtimePlugin.setLatestChange(realtimeKeyGet, updatedAt);
+                    realtimePlugin.setLatestChange(realtimeKeyGet, updatedAt);
                 }
                 if (realtimeKeyList) {
-                    _realtimePlugin.setLatestChange(realtimeKeyList, updatedAt);
+                    realtimePlugin.setLatestChange(realtimeKeyList, updatedAt);
                 }
             }
 
@@ -372,7 +376,7 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
                 mode: 'assign',
             });
         } else if (error.type === 'bad_request') {
-            _onError?.(error);
+            keelConfig.onError?.(error);
 
             if (retryNum > 4) {
                 cancelRetry();
@@ -434,13 +438,14 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
         create,
         update,
         delete: deleteFn,
-        retry: { infinite: true },
         waitFor: () => isEnabled$.get() && (waitFor ? computeSelector(waitFor) : true),
         waitForSet: () => isEnabled$.get() && (waitForSet ? computeSelector(waitForSet) : true),
         onSaved,
         fieldCreatedAt,
         fieldUpdatedAt,
-        initial: initial as any, // This errors because of the get/list union type
+        changesSince,
+        updatePartial: true,
+        generateId,
         // @ts-expect-error This errors because of the get/list union type
         get: get as any,
     }) as SyncedCrudReturnType<TLocal, TOption>;

package/src/sync-plugins/supabase.ts

@@ -1,15 +1,18 @@
 import {
     Observable,
-    SyncedOptions,
-    SyncedOptionsGlobal,
     computeSelector,
     getNodeValue,
     mergeIntoObservable,
     observable,
     symbolDelete,
+} from '@legendapp/state';
+import {
+    SyncedOptions,
+    SyncedOptionsGlobal,
+    removeNullUndefined,
     type SyncedGetParams,
     type SyncedSubscribeParams,
-} from '@legendapp/state';
+} from '@legendapp/state/sync';
 import {
     CrudAsOption,
     SyncedCrudPropsBase,
@@ -17,25 +20,22 @@ import {
     SyncedCrudReturnType,
     syncedCrud,
 } from '@legendapp/state/sync-plugins/crud';
-import type { PostgrestFilterBuilder } from '@supabase/postgrest-js';
+import type { PostgrestFilterBuilder, PostgrestQueryBuilder } from '@supabase/postgrest-js';
 import type { SupabaseClient } from '@supabase/supabase-js';
 
 // Unused types but maybe useful in the future so keeping them for now
-// type DatabaseOf<TClient extends SupabaseClient> = TClient extends SupabaseClient<infer TDB> ? TDB : never;
-// type SchemaNameOf<TClient extends SupabaseClient> = TClient extends SupabaseClient<infer _, infer TSchemaName>
-//     ? TSchemaName
+// type DatabaseOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer TDB> ? TDB : never;
+// type SchemaNameOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer _, infer SchemaName>
+//     ? SchemaName
 //     : never;
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-type SchemaOf<TClient extends SupabaseClient> = TClient extends SupabaseClient<infer _, infer __, infer TSchema>
-    ? TSchema
+type SchemaOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer _, infer __, infer Schema>
+    ? Schema
     : never;
-type TableOf<TClient extends SupabaseClient> = SchemaOf<TClient>['Tables'];
-type CollectionOf<TClient extends SupabaseClient> = keyof TableOf<TClient>;
-type RowOf<
-    TClient extends SupabaseClient,
-    TCollection extends CollectionOf<TClient>,
-> = TableOf<TClient>[TCollection]['Row'];
+type TableOf<Client extends SupabaseClient> = SchemaOf<Client>['Tables'];
+type CollectionOf<Client extends SupabaseClient> = keyof TableOf<Client>;
+type RowOf<Client extends SupabaseClient, Collection extends CollectionOf<Client>> = TableOf<Client>[Collection]['Row'];
 
 export type SyncedSupabaseConfig<T extends { id: string }> = Omit<
     SyncedCrudPropsBase<T>,
@@ -50,27 +50,36 @@ export interface SyncedSupabaseGlobalConfig
 }
 
 interface SyncedSupabaseProps<
-    TClient extends SupabaseClient,
-    TCollection extends CollectionOf<TClient>,
+    Client extends SupabaseClient,
+    Collection extends CollectionOf<Client>,
     TOption extends CrudAsOption = 'object',
-> extends SyncedSupabaseConfig<RowOf<TClient, TCollection>>,
-        SyncedCrudPropsMany<RowOf<TClient, TCollection>, RowOf<TClient, TCollection>, TOption> {
-    supabase: TClient;
-    collection: TCollection;
+> extends SyncedSupabaseConfig<RowOf<Client, Collection>>,
+        SyncedCrudPropsMany<RowOf<Client, Collection>, RowOf<Client, Collection>, TOption> {
+    supabase: Client;
+    collection: Collection;
+    select?: (
+        query: PostgrestQueryBuilder<SchemaOf<Client>, TableOf<Client>[Collection], Collection>,
+    ) => PostgrestFilterBuilder<
+        SchemaOf<Client>,
+        RowOf<Client, Collection>,
+        RowOf<Client, Collection>[],
+        Collection,
+        []
+    >;
     filter?: (
         select: PostgrestFilterBuilder<
-            SchemaOf<TClient>,
-            RowOf<TClient, TCollection>,
-            RowOf<TClient, TCollection>[],
-            TCollection,
+            SchemaOf<Client>,
+            RowOf<Client, Collection>,
+            RowOf<Client, Collection>[],
+            Collection,
             []
         >,
         params: SyncedGetParams,
     ) => PostgrestFilterBuilder<
-        SchemaOf<TClient>,
-        RowOf<TClient, TCollection>,
-        RowOf<TClient, TCollection>[],
-        TCollection,
+        SchemaOf<Client>,
+        RowOf<Client, Collection>,
+        RowOf<Client, Collection>[],
+        Collection,
         []
     >;
     actions?: ('create' | 'read' | 'update' | 'delete')[];
@@ -86,7 +95,7 @@ export function configureSyncedSupabase(config: SyncedSupabaseGlobalConfig) {
     if (enabled !== undefined) {
         isEnabled$.set(enabled);
     }
-    Object.assign(supabaseConfig, rest);
+    Object.assign(supabaseConfig, removeNullUndefined(rest));
 }
 
 export function syncedSupabase<
@@ -98,6 +107,7 @@ export function syncedSupabase<
     const {
         supabase: client,
         collection,
+        select: selectFn,
         filter,
         actions,
         fieldCreatedAt,
@@ -106,13 +116,18 @@ export function syncedSupabase<
         changesSince,
         waitFor,
         waitForSet,
+        generateId: generateIdParam,
         ...rest
     } = props;
+
+    const generateId = generateIdParam || supabaseConfig.generateId;
+
     const list =
         !actions || actions.includes('read')
             ? async (params: SyncedGetParams) => {
                   const { lastSync } = params;
-                  let select = client.from(collection).select();
+                  const from = client.from(collection);
+                  let select = selectFn ? selectFn(from) : from.select();
                   if (changesSince === 'last-sync') {
                       select = select.neq('deleted', true);
                       if (lastSync) {
@@ -239,6 +254,7 @@ export function syncedSupabase<
         fieldCreatedAt,
         fieldUpdatedAt,
         updatePartial: true,
+        generateId,
         waitFor: () => isEnabled$.get() && (waitFor ? computeSelector(waitFor) : true),
         waitForSet: () => isEnabled$.get() && (waitForSet ? computeSelector(waitForSet) : true),
     });

package/sync-plugins/crud.d.ts

@@ -1,4 +1,4 @@
-import { SyncTransform, SyncedGetParams, SyncedOptions, SyncedSetParams } from '@legendapp/state';
+import { SyncTransform, SyncedGetParams, SyncedOptions, SyncedSetParams } from '@legendapp/state/sync';
 export type CrudAsOption = 'Map' | 'object' | 'first';
 export type CrudResult<T> = T;
 export interface SyncedCrudPropsSingle<TRemote, TLocal> {
@@ -23,6 +23,7 @@ export interface SyncedCrudPropsBase<TRemote extends {
     fieldCreatedAt?: string;
     updatePartial?: boolean;
     changesSince?: 'all' | 'last-sync';
+    generateId?: () => string | number;
 }
 type InitialValue<T, TAsOption extends CrudAsOption> = TAsOption extends 'Map' ? Map<string, T> : TAsOption extends 'object' ? Record<string, T> : TAsOption extends 'first' ? T : T[];
 export type SyncedCrudReturnType<TLocal, TAsOption extends CrudAsOption> = TAsOption extends 'Map' ? Map<string, TLocal> : TAsOption extends 'object' ? Record<string, TLocal> : TAsOption extends 'first' ? TLocal : TLocal[];