@legendapp/state 2.2.0-next.87 → 2.2.0-next.89

package/src/sync-plugins/crud.ts

@@ -1,13 +1,5 @@
-import { internal, isArray, isNullOrUndefined, isNumber, isObject, isString } from '@legendapp/state';
-import {
-    synced,
-    diffObjects,
-    SyncTransform,
-    SyncTransformMethod,
-    SyncedGetParams,
-    SyncedOptions,
-    SyncedSetParams,
-} from '@legendapp/state/sync';
+import { internal, isArray, isNullOrUndefined } from '@legendapp/state';
+import { SyncedGetParams, SyncedOptions, SyncedSetParams, diffObjects, synced } from '@legendapp/state/sync';
 
 const { clone } = internal;
 
@@ -26,17 +18,17 @@ export interface SyncedCrudPropsMany<TRemote, TLocal, TAsOption extends CrudAsOp
     initial?: InitialValue<TLocal, TAsOption>;
 }
 export interface SyncedCrudPropsBase<TRemote extends { id: string | number }, TLocal = TRemote>
-    extends Omit<SyncedOptions<TLocal>, 'get' | 'set' | 'transform' | 'initial'> {
+    extends Omit<SyncedOptions<TRemote, TLocal>, 'get' | 'set' | 'initial'> {
     create?(input: TRemote, params: SyncedSetParams<TRemote>): Promise<CrudResult<TRemote> | null | undefined>;
     update?(
         input: Partial<TRemote>,
         params: SyncedSetParams<TRemote>,
     ): Promise<CrudResult<Partial<TRemote> | null | undefined>>;
     delete?(input: { id: TRemote['id'] }, params: SyncedSetParams<TRemote>): Promise<CrudResult<any>>;
-    onSaved?(saved: TLocal, input: TRemote, isCreate: boolean): Partial<TLocal> | void;
-    transform?: SyncTransform<TLocal, TRemote>;
+    onSaved?(saved: TLocal, input: TRemote, isCreate: boolean): void;
     fieldUpdatedAt?: string;
     fieldCreatedAt?: string;
+    fieldDeleted?: string;
     updatePartial?: boolean;
     changesSince?: 'all' | 'last-sync';
     generateId?: () => string | number;
@@ -64,73 +56,6 @@ function transformOut<T1, T2>(data: T1, transform: undefined | ((value: T1) => T
     return transform ? transform(clone(data)) : data;
 }
 
-// TODO
-export function createTransform<T extends Record<string, any>, T2 extends Record<string, any>>(
-    ...keys: (keyof T | { from: keyof T; to: keyof T2 })[]
-): SyncTransform<T2, T> {
-    return {
-        load: (value: T) => {
-            (keys as string[]).forEach((key) => {
-                const keyRemote = isObject(key) ? key.from : key;
-                const keyLocal = isObject(key) ? key.to : key;
-                const v = value[keyRemote];
-                if (!isNullOrUndefined(v)) {
-                    value[keyLocal as keyof T] = isString(v) ? JSON.parse(v as string) : v;
-                }
-                if (keyLocal !== keyRemote) {
-                    delete value[keyRemote];
-                }
-            });
-            return value as unknown as T2;
-        },
-        save: (value: T2) => {
-            (keys as string[]).forEach((key: string) => {
-                const keyRemote = isObject(key) ? key.from : key;
-                const keyLocal = isObject(key) ? key.to : key;
-                let v = (value as any)[keyLocal];
-                if (!isNullOrUndefined(v)) {
-                    if (isArray(v)) {
-                        v = v.filter((val) => !isNullOrUndefined(val));
-                    }
-                    value[keyRemote as keyof T2] =
-                        isNumber(v) || isObject(v) || isArray(v) ? (JSON.stringify(v) as any) : v;
-                }
-                if (keyLocal !== keyRemote) {
-                    delete value[keyLocal];
-                }
-            });
-            return value as unknown as T;
-        },
-    };
-}
-
-// TODO
-export function combineTransforms<T, T2>(
-    transform1: SyncTransform<T2, T>,
-    ...transforms: Partial<SyncTransform<T2, T>>[]
-): SyncTransform<T2, T> {
-    return {
-        load: (value: T, method: SyncTransformMethod) => {
-            let inValue = transform1.load?.(value, method) as any;
-            transforms.forEach((transform) => {
-                if (transform.load) {
-                    inValue = transform.load(inValue, method);
-                }
-            });
-            return inValue;
-        },
-        save: (value: T2) => {
-            let outValue = value as any;
-            transforms.forEach((transform) => {
-                if (transform.save) {
-                    outValue = transform.save(outValue);
-                }
-            });
-            return transform1.save?.(outValue) ?? outValue;
-        },
-    };
-}
-
 function ensureId(obj: { id: string | number }, generateId: () => string | number) {
     if (!obj.id) {
         obj.id = generateId();
@@ -165,6 +90,7 @@ export function syncedCrud<
         transform,
         fieldCreatedAt,
         fieldUpdatedAt,
+        fieldDeleted,
         updatePartial,
         onSaved,
         mode: modeParam,
@@ -211,7 +137,8 @@ export function syncedCrud<
                       } else {
                           const out: Record<string, any> = asMap ? new Map() : {};
                           transformed.forEach((result: any) => {
-                              const value = result.__deleted ? internal.symbolDelete : result;
+                              const value =
+                                  result[fieldDeleted as any] || result.__deleted ? internal.symbolDelete : result;
                               asMap ? (out as Map<any, any>).set(result.id, value) : (out[result.id] = value);
                           });
                           return out;
@@ -298,11 +225,7 @@ export function syncedCrud<
                               isCreateGuess = !(fieldCreatedAt || fieldUpdatedAt) && path.length === 1 && !prevAtPath;
                               if (!itemValue) {
                                   if (path.length === 1 && prevAtPath) {
-                                      if (deleteFn) {
-                                          deletes.add(itemKey);
-                                      } else {
-                                          console.log('[legend-state] missing delete function');
-                                      }
+                                      deletes.add(itemKey);
                                   }
                               } else {
                                   itemsChanged = [[itemKey, itemValue]];
@@ -352,7 +275,7 @@ export function syncedCrud<
                               transform?.load ? transform.load(data as any, 'set') : data
                           ) as any;
 
-                          const savedOut = onSaved(dataLoaded, input, isCreate);
+                          const savedOut = diffObjects(input, dataLoaded as any);
 
                           if (savedOut) {
                               const createdAt = fieldCreatedAt ? savedOut[fieldCreatedAt as keyof TLocal] : undefined;
@@ -366,6 +289,8 @@ export function syncedCrud<
                                       updatedAt || createdAt ? +new Date(updatedAt || (createdAt as any)) : undefined,
                                   mode: 'merge',
                               });
+
+                              onSaved(dataLoaded, input, isCreate);
                           }
                       }
                   };
@@ -392,8 +317,15 @@ export function syncedCrud<
                               );
                           }
                       }),
-                      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                      ...Array.from(deletes).map((itemKey) => deleteFn!({ id: itemKey }, params)),
+                      ...Array.from(deletes).map((id) => {
+                          if (fieldDeleted && updateFn) {
+                              updateFn({ id, [fieldDeleted]: true } as any, params);
+                          } else if (deleteFn) {
+                              deleteFn({ id }, params);
+                          } else {
+                              console.log('[legend-state] missing delete function');
+                          }
+                      }),
                   ]);
               }
             : undefined;

package/src/sync-plugins/keel.ts

@@ -1,4 +1,4 @@
-import { computeSelector, observable, when, internal } from '@legendapp/state';
+import { computeSelector, observable, when, internal, isFunction, mergeIntoObservable } from '@legendapp/state';
 import {
     SyncedOptions,
     removeNullUndefined,
@@ -44,15 +44,14 @@ type Result<T, U> = NonNullable<Data<T> | Err<U>>;
 
 // Keel plugin types
 
-interface GetGetParams {
-    refresh: () => void;
-}
+export interface KeelGetParams {}
 
-interface ListGetParams {
-    where: { updatedAt?: { after: Date } };
-    refresh?: () => void;
+export interface KeelListParams<Where = {}> {
+    where: { updatedAt?: { after: Date } } & Where;
     after?: string;
     first?: number;
+    last?: number;
+    before?: string;
 }
 
 export interface KeelRealtimePlugin {
@@ -68,9 +67,7 @@ export interface SyncedKeelConfiguration
         | 'update'
         | 'delete'
         | 'onSaved'
-        | 'transform'
         | 'updatePartial'
-        | 'subscribe'
         | 'fieldCreatedAt'
         | 'fieldUpdatedAt'
     > {
@@ -92,23 +89,60 @@ interface PageInfo {
     totalCount: number;
 }
 
-interface SyncedKeelPropsMany<TRemote, TLocal, AOption extends CrudAsOption>
+interface SyncedKeelPropsManyBase<TRemote, TLocal, AOption extends CrudAsOption>
     extends Omit<SyncedCrudPropsMany<TRemote, TLocal, AOption>, 'list'> {
-    list?: (params: ListGetParams) => Promise<CrudResult<APIResult<{ results: TRemote[]; pageInfo: any }>>>;
     first?: number;
     get?: never;
 }
+interface SyncedKeelPropsManyWhere<TRemote, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>>
+    extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
+    list?: (params: KeelListParams<NoInfer<Where>>) => Promise<
+        CrudResult<
+            APIResult<{
+                results: TRemote[];
+                pageInfo: any;
+            }>
+        >
+    >;
+    where?: Where | (() => Where);
+}
+interface SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption extends CrudAsOption>
+    extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
+    list?: (params: KeelListParams<{}>) => Promise<
+        CrudResult<
+            APIResult<{
+                results: TRemote[];
+                pageInfo: any;
+            }>
+        >
+    >;
+    where?: never | {};
+}
+type HasAnyKeys<T> = keyof T extends never ? false : true;
+
+type SyncedKeelPropsMany<
+    TRemote,
+    TLocal,
+    AOption extends CrudAsOption,
+    Where extends Record<string, any>,
+> = HasAnyKeys<Where> extends true
+    ? SyncedKeelPropsManyWhere<TRemote, TLocal, AOption, Where>
+    : SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption>;
 
 interface SyncedKeelPropsSingle<TRemote, TLocal> extends Omit<SyncedCrudPropsSingle<TRemote, TLocal>, 'get'> {
-    get?: (params: GetGetParams) => Promise<APIResult<TRemote>>;
+    get?: (params: KeelGetParams) => Promise<APIResult<TRemote>>;
 
     first?: never;
+    where?: never;
     list?: never;
     as?: never;
 }
 
 interface SyncedKeelPropsBase<TRemote extends { id: string }, TLocal = TRemote>
-    extends Omit<SyncedCrudPropsBase<TRemote, TLocal>, 'create' | 'update' | 'delete'> {
+    extends Omit<
+        SyncedCrudPropsBase<TRemote, TLocal>,
+        'create' | 'update' | 'delete' | 'updatePartial' | 'fieldUpdatedAt' | 'fieldCreatedAt'
+    > {
     create?: (i: NoInfer<Partial<TRemote>>) => Promise<APIResult<NoInfer<TRemote>>>;
     update?: (params: { where: any; values?: Partial<TRemote> }) => Promise<APIResult<TRemote>>;
     delete?: (params: { id: string }) => Promise<APIResult<string>>;
@@ -153,13 +187,12 @@ function convertObjectToCreate<TRemote>(item: TRemote): TRemote {
 }
 
 export function configureSyncedKeel(config: SyncedKeelConfiguration) {
-    const { enabled, realtimePlugin, ...rest } = config;
+    const { enabled, realtimePlugin, client, ...rest } = config;
     Object.assign(keelConfig, removeNullUndefined(rest));
 
     if (enabled !== undefined) {
         isEnabled$.set(enabled);
     }
-    const { client } = keelConfig;
 
     if (realtimePlugin) {
         keelConfig.realtimePlugin = realtimePlugin;
@@ -198,13 +231,13 @@ export function configureSyncedKeel(config: SyncedKeelConfiguration) {
 
 const NumPerPage = 200;
 async function getAllPages<TRemote>(
-    listFn: (params: ListGetParams) => Promise<
+    listFn: (params: KeelListParams<any>) => Promise<
         APIResult<{
             results: TRemote[];
             pageInfo: any;
         }>
     >,
-    params: ListGetParams,
+    params: KeelListParams,
 ): Promise<{ results: TRemote[]; subscribe: (params: { refresh: () => void }) => string }> {
     const allData: TRemote[] = [];
     let pageInfo: PageInfo | undefined = undefined;
@@ -218,7 +251,7 @@ async function getAllPages<TRemote>(
             break;
         }
         const pageEndCursor = pageInfo?.endCursor;
-        const paramsWithCursor: ListGetParams = pageEndCursor
+        const paramsWithCursor: KeelListParams = pageEndCursor
             ? { first, ...params, after: pageEndCursor }
             : { first, ...params };
         pageInfo = undefined;
@@ -248,13 +281,26 @@ async function getAllPages<TRemote>(
 export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote>(
     props: SyncedKeelPropsBase<TRemote, TLocal> & SyncedKeelPropsSingle<TRemote, TLocal>,
 ): SyncedCrudReturnType<TLocal, 'first'>;
-export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOption extends CrudAsOption = 'object'>(
-    props: SyncedKeelPropsBase<TRemote, TLocal> & SyncedKeelPropsMany<TRemote, TLocal, TOption>,
+export function syncedKeel<
+    TRemote extends { id: string },
+    TLocal = TRemote,
+    TOption extends CrudAsOption = 'object',
+    Where extends Record<string, any> = {},
+>(
+    props: SyncedKeelPropsBase<TRemote, TLocal> & SyncedKeelPropsMany<TRemote, TLocal, TOption, Where>,
 ): SyncedCrudReturnType<TLocal, Exclude<TOption, 'first'>>;
-export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOption extends CrudAsOption = 'object'>(
+export function syncedKeel<
+    TRemote extends { id: string },
+    TLocal = TRemote,
+    TOption extends CrudAsOption = 'object',
+    Where extends Record<string, any> = {},
+>(
     props: SyncedKeelPropsBase<TRemote, TLocal> &
-        (SyncedKeelPropsSingle<TRemote, TLocal> | SyncedKeelPropsMany<TRemote, TLocal, TOption>),
+        (SyncedKeelPropsSingle<TRemote, TLocal> | SyncedKeelPropsMany<TRemote, TLocal, TOption, Where>),
 ): SyncedCrudReturnType<TLocal, TOption> {
+    const { realtimePlugin } = keelConfig;
+    mergeIntoObservable(props, keelConfig);
+
     const {
         get: getParam,
         list: listParam,
@@ -262,23 +308,18 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
         update: updateParam,
         delete: deleteParam,
         first,
+        where: whereParam,
         waitFor,
-        waitForSet,
         generateId: generateIdParam,
         ...rest
     } = props;
 
     const { changesSince } = props;
 
-    let asType = props.as as TOption;
-
-    if (!asType) {
-        asType = (getParam ? 'first' : keelConfig.as || undefined) as TOption;
-    }
+    const asType: TOption = getParam ? ('first' as TOption) : props.as!;
 
     const generateId = generateIdParam || keelConfig.generateId;
 
-    const realtimePlugin = keelConfig.realtimePlugin;
     let realtimeKeyList: string | undefined = undefined;
     let realtimeKeyGet: string | undefined = undefined;
 
@@ -289,12 +330,12 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
         ? async (listParams: SyncedGetParams) => {
               const { lastSync, refresh } = listParams;
               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, first } : { where, refresh, first };
+              const where = Object.assign(
+                  queryBySync ? { updatedAt: { after: new Date(+new Date(lastSync) + 1) } } : {},
+                  isFunction(whereParam) ? whereParam() : whereParam,
+              );
+              const params: KeelListParams = { where, first };
 
               // TODO: Error?
               const { results, subscribe } = await getAllPages(listParam, params);
@@ -323,30 +364,11 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
           }
         : undefined;
 
-    const onSaved = (data: TLocal, input: TRemote, isCreate: boolean): Partial<TLocal> | void => {
-        if (data) {
-            const savedOut: Partial<TLocal> = {};
-            if (isCreate) {
-                // Update with any fields that were undefined when creating
-                Object.keys(data).forEach((key) => {
-                    if (input[key as keyof TRemote] === undefined) {
-                        savedOut[key as keyof TLocal] = data[key as keyof TLocal];
-                    }
-                });
-            } else {
-                // Update with any fields ending in createdAt or updatedAt
-                Object.keys(data).forEach((key) => {
-                    const k = key as keyof TLocal;
-                    const keyLower = key.toLowerCase();
-                    if ((keyLower.endsWith('createdat') || keyLower.endsWith('updatedat')) && data[k] instanceof Date) {
-                        savedOut[k] = data[k];
-                    }
-                });
-            }
-
+    const onSaved = (data: TLocal) => {
+        if (realtimePlugin && data) {
             const updatedAt = data[fieldUpdatedAt as keyof TLocal] as Date;
 
-            if (updatedAt && realtimePlugin) {
+            if (updatedAt) {
                 if (realtimeKeyGet) {
                     realtimePlugin.setLatestChange(realtimeKeyGet, updatedAt);
                 }
@@ -354,8 +376,6 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
                     realtimePlugin.setLatestChange(realtimeKeyList, updatedAt);
                 }
             }
-
-            return savedOut;
         }
     };
 
@@ -421,8 +441,8 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
           }
         : undefined;
     const deleteFn = deleteParam
-        ? async (input: { id: string }, params: SyncedSetParams<TRemote>) => {
-              const { data, error } = await deleteParam({ id: input.id });
+        ? async ({ id }: { id: string }, params: SyncedSetParams<TRemote>) => {
+              const { data, error } = await deleteParam({ id });
 
               if (error) {
                   handleSetError(error, params, false);
@@ -440,7 +460,6 @@ export function syncedKeel<TRemote extends { id: string }, TLocal = TRemote, TOp
         update,
         delete: deleteFn,
         waitFor: () => isEnabled$.get() && (waitFor ? computeSelector(waitFor) : true),
-        waitForSet,
         onSaved,
         fieldCreatedAt,
         fieldUpdatedAt,

package/src/sync-plugins/supabase.ts

@@ -1,4 +1,4 @@
-import { Observable, computeSelector, mergeIntoObservable, observable, symbolDelete } from '@legendapp/state';
+import { Observable, computeSelector, isObject, mergeIntoObservable, observable, symbolDelete } from '@legendapp/state';
 import {
     SyncedOptions,
     SyncedOptionsGlobal,
@@ -22,20 +22,28 @@ import type { SupabaseClient } from '@supabase/supabase-js';
 //     ? SchemaName
 //     : never;
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-type SchemaOf<Client extends SupabaseClient> = Client extends SupabaseClient<infer _, infer __, infer Schema>
+export type SupabaseSchemaOf<Client extends SupabaseClient> = Client extends SupabaseClient<
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    infer _,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    infer __,
+    infer Schema
+>
     ? Schema
     : never;
-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 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<T extends { id: string }> = Omit<
     SyncedCrudPropsBase<T>,
-    'create' | 'update' | 'delete' | 'onSaved' | 'transform' | 'updatePartial' | 'subscribe'
+    'create' | 'update' | 'delete'
 >;
 
-export interface SyncedSupabaseGlobalConfig
+export interface SyncedSupabaseConfiguration
     extends Omit<SyncedSupabaseConfig<{ id: string }>, 'persist' | keyof SyncedOptions> {
     persist?: SyncedOptionsGlobal;
     enabled?: Observable<boolean>;
@@ -44,46 +52,46 @@ export interface SyncedSupabaseGlobalConfig
 
 interface SyncedSupabaseProps<
     Client extends SupabaseClient,
-    Collection extends CollectionOf<Client>,
+    Collection extends SupabaseCollectionOf<Client>,
     TOption extends CrudAsOption = 'object',
-> extends SyncedSupabaseConfig<RowOf<Client, Collection>>,
-        SyncedCrudPropsMany<RowOf<Client, Collection>, RowOf<Client, Collection>, TOption> {
+> extends SyncedSupabaseConfig<SupabaseRowOf<Client, Collection>>,
+        SyncedCrudPropsMany<SupabaseRowOf<Client, Collection>, SupabaseRowOf<Client, Collection>, TOption> {
     supabase: Client;
     collection: Collection;
     select?: (
-        query: PostgrestQueryBuilder<SchemaOf<Client>, TableOf<Client>[Collection], Collection>,
+        query: PostgrestQueryBuilder<SupabaseSchemaOf<Client>, SupabaseTableOf<Client>[Collection], Collection>,
     ) => PostgrestFilterBuilder<
-        SchemaOf<Client>,
-        RowOf<Client, Collection>,
-        RowOf<Client, Collection>[],
+        SupabaseSchemaOf<Client>,
+        SupabaseRowOf<Client, Collection>,
+        SupabaseRowOf<Client, Collection>[],
         Collection,
         []
     >;
     filter?: (
         select: PostgrestFilterBuilder<
-            SchemaOf<Client>,
-            RowOf<Client, Collection>,
-            RowOf<Client, Collection>[],
+            SupabaseSchemaOf<Client>,
+            SupabaseRowOf<Client, Collection>,
+            SupabaseRowOf<Client, Collection>[],
             Collection,
             []
         >,
         params: SyncedGetParams,
     ) => PostgrestFilterBuilder<
-        SchemaOf<Client>,
-        RowOf<Client, Collection>,
-        RowOf<Client, Collection>[],
+        SupabaseSchemaOf<Client>,
+        SupabaseRowOf<Client, Collection>,
+        SupabaseRowOf<Client, Collection>[],
         Collection,
         []
     >;
     actions?: ('create' | 'read' | 'update' | 'delete')[];
-    realtime?: { schema?: string; filter?: string };
+    realtime?: boolean | { schema?: string; filter?: string };
 }
 
 let channelNum = 1;
-const supabaseConfig: SyncedSupabaseGlobalConfig = {};
+const supabaseConfig: SyncedSupabaseConfiguration = {};
 const isEnabled$ = observable(true);
 
-export function configureSyncedSupabase(config: SyncedSupabaseGlobalConfig) {
+export function configureSyncedSupabase(config: SyncedSupabaseConfiguration) {
     const { enabled, ...rest } = config;
     if (enabled !== undefined) {
         isEnabled$.set(enabled);
@@ -93,9 +101,11 @@ export function configureSyncedSupabase(config: SyncedSupabaseGlobalConfig) {
 
 export function syncedSupabase<
     Client extends SupabaseClient,
-    Collection extends CollectionOf<Client> & string,
+    Collection extends SupabaseCollectionOf<Client> & string,
     AsOption extends CrudAsOption = 'object',
->(props: SyncedSupabaseProps<Client, Collection, AsOption>): SyncedCrudReturnType<RowOf<Client, Collection>, AsOption> {
+>(
+    props: SyncedSupabaseProps<Client, Collection, AsOption>,
+): SyncedCrudReturnType<SupabaseRowOf<Client, Collection>, AsOption> {
     mergeIntoObservable(props, supabaseConfig);
     const {
         supabase: client,
@@ -122,7 +132,6 @@ export function syncedSupabase<
                   const from = client.from(collection);
                   let select = selectFn ? selectFn(from) : from.select();
                   if (changesSince === 'last-sync') {
-                      select = select.neq('deleted', true);
                       if (lastSync) {
                           const date = new Date(lastSync).toISOString();
                           select = select.or(
@@ -140,11 +149,11 @@ export function syncedSupabase<
                   if (error) {
                       throw new Error(error?.message);
                   }
-                  return (data! || []) as RowOf<Client, Collection>[];
+                  return (data! || []) as SupabaseRowOf<Client, Collection>[];
               }
             : undefined;
 
-    const upsert = async (input: RowOf<Client, Collection>) => {
+    const upsert = async (input: SupabaseRowOf<Client, Collection>) => {
         const res = await client.from(collection).upsert(input).select();
         const { data, error } = res;
         if (data) {
@@ -158,12 +167,10 @@ export function syncedSupabase<
     const update = !actions || actions.includes('update') ? upsert : undefined;
     const deleteFn =
         !actions || actions.includes('delete')
-            ? async (input: { id: RowOf<Client, Collection>['id'] }) => {
+            ? async (input: { id: SupabaseRowOf<Client, Collection>['id'] }) => {
                   const id = input.id;
                   const from = client.from(collection);
-                  const res = await (changesSince === 'last-sync' ? from.update({ deleted: true }) : from.delete())
-                      .eq('id', id)
-                      .select();
+                  const res = await from.delete().eq('id', id).select();
                   const { data, error } = res;
                   if (data) {
                       const created = data[0];
@@ -175,7 +182,7 @@ export function syncedSupabase<
             : undefined;
     const subscribe = realtime
         ? ({ node, value$, update }: SyncedSubscribeParams) => {
-              const { filter, schema } = realtime;
+              const { filter, schema } = (isObject(realtime) ? realtime : {}) as { schema?: string; filter?: string };
               const channel = client
                   .channel(`LS_${node.key || ''}${channelNum++}`)
                   .on(
@@ -222,31 +229,16 @@ export function syncedSupabase<
           }
         : undefined;
 
-    return syncedCrud<RowOf<Client, Collection>, RowOf<Client, Collection>, AsOption>({
+    return syncedCrud<SupabaseRowOf<Client, Collection>, SupabaseRowOf<Client, Collection>, AsOption>({
         ...rest,
         list,
         create,
         update,
         delete: deleteFn,
-        onSaved: (saved) => {
-            // Update the local timestamps with server response
-            if (fieldCreatedAt || fieldUpdatedAt) {
-                const ret: any = {
-                    id: saved.id,
-                };
-                if (fieldCreatedAt) {
-                    ret[fieldCreatedAt] = fieldCreatedAt;
-                }
-                if (fieldUpdatedAt) {
-                    ret[fieldUpdatedAt] = fieldUpdatedAt;
-                }
-                return ret;
-            }
-        },
         subscribe,
         fieldCreatedAt,
         fieldUpdatedAt,
-        updatePartial: true,
+        updatePartial: false,
         generateId,
         waitFor: () => isEnabled$.get() && (waitFor ? computeSelector(waitFor) : true),
         waitForSet,