@legendapp/state 2.2.0-next.8 → 2.2.0-next.80

package/src/sync/syncObservableAdapter.ts

@@ -0,0 +1,31 @@
+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 = {};
+
+    if (get) {
+        ret.get = (async (params: ObservableSyncGetParams<T>) => {
+            try {
+                let value = get(params as any);
+                if (isPromise(value)) {
+                    value = await value;
+                }
+
+                params.onChange({
+                    value,
+                    lastSync: params.lastSync,
+                    mode: params.mode!,
+                });
+                params.onGet();
+                // eslint-disable-next-line no-empty
+            } catch {}
+        }) as ObservableSyncClass['get'];
+    }
+
+    if (set) {
+        ret.set = set as unknown as ObservableSyncClass['set'];
+    }
+
+    return ret;
+}

package/src/sync/syncTypes.ts

@@ -0,0 +1,188 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-ignore
+import type { MMKVConfiguration } from 'react-native-mmkv';
+// @ts-ignore
+import type { AsyncStorageStatic } from '@react-native-async-storage/async-storage';
+
+import {
+    Change,
+    ClassConstructor,
+    GetMode,
+    LinkedOptions,
+    NodeValue,
+    SetParams,
+    UpdateFn,
+    UpdateFnParams,
+} from '../observableInterfaces';
+import { Observable, ObservableParam, ObservableState } from '../observableTypes';
+
+export interface PersistOptions<T = any> {
+    name: string;
+    plugin?: ClassConstructor<ObservablePersistPlugin, T[]>;
+    retrySync?: boolean;
+    transform?: SyncTransform<T>;
+    readonly?: boolean;
+    mmkv?: MMKVConfiguration;
+    indexedDB?: {
+        prefixID?: string;
+        itemID?: string;
+    };
+    options?: any;
+}
+
+export interface SyncedGetParams {
+    value: any;
+    lastSync: number | undefined;
+    updateLastSync: (lastSync: number) => void;
+    mode: GetMode;
+    refresh: () => void;
+}
+
+export interface SyncedSetParams<T> extends SetParams<T> {
+    node: NodeValue;
+    valuePrevious: T;
+    update: UpdateFn;
+    refresh: () => void;
+    cancelRetry: () => void;
+    retryNum: number;
+    fromSubscribe: boolean | undefined;
+}
+
+export interface SyncedSubscribeParams {
+    node: NodeValue;
+    update: UpdateFn;
+    refresh: () => void;
+}
+
+export interface SyncedOptions<T = any> extends Omit<LinkedOptions<T>, 'get' | 'set'> {
+    get?: (params: SyncedGetParams) => Promise<T> | T;
+    set?: (params: SyncedSetParams<T>) => void | Promise<any>;
+    subscribe?: (params: SyncedSubscribeParams) => void;
+    retry?: RetryOptions;
+    persist?: PersistOptions<any>;
+    debounceSet?: number;
+    syncMode?: 'auto' | 'manual';
+    mode?: GetMode;
+    transform?: SyncTransform<T>;
+    // Not implemented yet
+    enableSync?: boolean;
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    log?: (message?: any, ...optionalParams: any[]) => void;
+    onBeforeSet?: () => void;
+    onAfterSet?: () => void;
+    allowSetIfGetError?: boolean;
+}
+
+export interface SyncedOptionsGlobal<T = any>
+    extends Omit<
+        SyncedOptions<T>,
+        'get' | 'set' | 'persist' | 'initial' | 'waitForSet' | 'waitFor' | 'transform' | 'subscribe'
+    > {
+    persist?: ObservablePersistPluginOptions & Omit<PersistOptions, 'name' | 'transform' | 'options'>;
+}
+
+export interface ObservablePersistPluginOptions {
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    indexedDB?: {
+        databaseName: string;
+        version: number;
+        tableNames: string[];
+    };
+    asyncStorage?: {
+        AsyncStorage: AsyncStorageStatic;
+        preload?: boolean | string[];
+    };
+}
+export interface ObservablePersistPlugin {
+    initialize?(config: ObservablePersistPluginOptions): void | Promise<void>;
+    loadTable?(table: string, config: PersistOptions): Promise<any> | void;
+    getTable<T = any>(table: string, init: object, config: PersistOptions): T;
+    set(table: string, changes: Change[], config: PersistOptions): Promise<any> | void;
+    deleteTable(table: string, config: PersistOptions): Promise<any> | void;
+    getMetadata(table: string, config: PersistOptions): PersistMetadata;
+    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptions): Promise<any> | void;
+    deleteMetadata(table: string, config: PersistOptions): Promise<any> | void;
+}
+export interface PersistMetadata {
+    id?: '__legend_metadata';
+    // modified ?: number;
+    lastSync?: number;
+    pending?: any;
+}
+export type SyncTransformMethod = 'get' | 'set';
+export interface SyncTransform<TOrig = any, TSaved = TOrig> {
+    load?: (value: TSaved, method: SyncTransformMethod) => TOrig | Promise<TOrig>;
+    save?: (value: TOrig) => TSaved | Promise<TSaved>;
+}
+export interface ObservableSyncStateBase {
+    isPersistLoaded: boolean;
+    isPersistEnabled: boolean;
+    isSyncEnabled: boolean;
+    lastSync?: number;
+    syncCount?: number;
+    clearPersist: () => Promise<void>;
+    sync: () => Promise<void>;
+    getPendingChanges: () =>
+        | Record<
+              string,
+              {
+                  p: any;
+                  v?: any;
+              }
+          >
+        | undefined;
+}
+export type ObservableSyncState = ObservableState & ObservableSyncStateBase;
+
+export interface ObservableSyncSetParams<T> {
+    syncState: Observable<ObservableSyncState>;
+    obs: ObservableParam<T>;
+    options: SyncedOptions<T>;
+    changes: Change[];
+    value: T;
+    valuePrevious: T;
+}
+export interface ObservableSyncGetParams<T> {
+    state: Observable<ObservableSyncState>;
+    obs: ObservableParam<T>;
+    options: SyncedOptions<T>;
+    dateModified?: number;
+    lastSync?: number;
+    mode?: GetMode;
+    onGet: () => void;
+    onError: (error: Error) => void;
+    onChange: (params: UpdateFnParams) => void | Promise<void>;
+}
+export type ObservableSyncRemoteGetFnParams<T> = Omit<ObservableSyncGetParams<T>, 'onGet'>;
+
+export interface ObservableSyncClass {
+    get?<T>(params: ObservableSyncGetParams<T>): void;
+    set?<T>(
+        params: ObservableSyncSetParams<T>,
+    ): void | Promise<void | { changes?: object; dateModified?: number; lastSync?: number; pathStrs?: string[] }>;
+}
+
+export interface ObservableSyncFunctions<T = any> {
+    get?(params: ObservableSyncRemoteGetFnParams<T>): T | Promise<T>;
+    set?(
+        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

@@ -0,0 +1,20 @@
+import type { Synced, SyncedOptions } from './syncTypes';
+import { internal } from '@legendapp/state';
+import { enableActivateSyncedNode } from './activateSyncedNode';
+
+const { symbolLinked } = internal;
+
+export function synced<T>(params: SyncedOptions<T>): Synced<T> {
+    installPersistActivateNode();
+    return (() => ({
+        [symbolLinked]: { ...params, synced: true },
+    })) as any;
+}
+
+let didInstall = false;
+function installPersistActivateNode() {
+    if (!didInstall) {
+        enableActivateSyncedNode();
+        didInstall = true;
+    }
+}

package/src/sync-plugins/crud.ts

@@ -0,0 +1,404 @@
+import { internal, isArray, isNullOrUndefined, isNumber, isObject, isString } from '@legendapp/state';
+import {
+    synced,
+    diffObjects,
+    SyncTransform,
+    SyncTransformMethod,
+    SyncedGetParams,
+    SyncedOptions,
+    SyncedSetParams,
+} from '@legendapp/state/sync';
+
+const { clone } = internal;
+
+export type CrudAsOption = 'Map' | 'object' | 'first';
+
+export type CrudResult<T> = T;
+
+export interface SyncedCrudPropsSingle<TRemote, TLocal> {
+    get?: (params: SyncedGetParams) => Promise<CrudResult<TRemote | null>> | CrudResult<TRemote | null>;
+    initial?: InitialValue<TLocal, 'first'>;
+    as?: never | 'first';
+}
+export interface SyncedCrudPropsMany<TRemote, TLocal, TAsOption extends CrudAsOption> {
+    list?: (params: SyncedGetParams) => Promise<CrudResult<TRemote[] | null>> | CrudResult<TRemote[] | null>;
+    as?: TAsOption;
+    initial?: InitialValue<TLocal, TAsOption>;
+}
+export interface SyncedCrudPropsBase<TRemote extends { id: string | number }, TLocal = TRemote>
+    extends Omit<SyncedOptions<TLocal>, 'get' | 'set' | 'transform' | '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: TRemote, params: SyncedSetParams<TRemote>): Promise<CrudResult<any>>;
+    onSaved?(saved: TLocal, input: TRemote, isCreate: boolean): Partial<TLocal> | void;
+    transform?: SyncTransform<TLocal, TRemote>;
+    fieldUpdatedAt?: string;
+    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[];
+
+let _asOption: CrudAsOption;
+
+function transformOut<T1, T2>(data: T1, transform: undefined | ((value: T1) => T2)) {
+    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();
+    }
+    return obj.id;
+}
+
+export function syncedCrud<TRemote extends { id: string | number }, TLocal = TRemote>(
+    props: SyncedCrudPropsBase<TRemote, TLocal> & SyncedCrudPropsSingle<TRemote, TLocal>,
+): SyncedCrudReturnType<TLocal, 'first'>;
+export function syncedCrud<
+    TRemote extends { id: string | number },
+    TLocal = TRemote,
+    TAsOption extends CrudAsOption = 'object',
+>(
+    props: SyncedCrudPropsBase<TRemote, TLocal> & SyncedCrudPropsMany<TRemote, TLocal, TAsOption>,
+): SyncedCrudReturnType<TLocal, Exclude<TAsOption, 'first'>>;
+export function syncedCrud<
+    TRemote extends { id: string | number },
+    TLocal = TRemote,
+    TAsOption extends CrudAsOption = 'object',
+>(
+    props: SyncedCrudPropsBase<TRemote, TLocal> &
+        (SyncedCrudPropsSingle<TRemote, TLocal> & SyncedCrudPropsMany<TRemote, TLocal, TAsOption>),
+): SyncedCrudReturnType<TLocal, TAsOption> {
+    const {
+        get: getFn,
+        list: listFn,
+        create: createFn,
+        update: updateFn,
+        delete: deleteFn,
+        transform,
+        fieldCreatedAt,
+        fieldUpdatedAt,
+        updatePartial,
+        onSaved,
+        mode: modeParam,
+        changesSince,
+        generateId,
+        ...rest
+    } = props;
+
+    let asType = props.as as TAsOption;
+
+    if (!asType) {
+        asType = (getFn ? 'first' : _asOption || 'object') as CrudAsOption as TAsOption;
+    }
+
+    const asMap = asType === 'Map';
+
+    const get: undefined | ((params: SyncedGetParams) => Promise<TLocal>) =
+        getFn || listFn
+            ? async (getParams: SyncedGetParams) => {
+                  const { updateLastSync, lastSync } = getParams;
+                  if (listFn) {
+                      if (changesSince === 'last-sync' && lastSync) {
+                          getParams.mode = modeParam || (asType === 'first' ? 'set' : 'assign');
+                      }
+
+                      const data = (await listFn(getParams)) || [];
+                      let newLastSync = 0;
+                      for (let i = 0; i < data.length; i++) {
+                          const updated =
+                              (data[i] as any)[fieldUpdatedAt as any] || (data[i] as any)[fieldCreatedAt as any];
+                          if (updated) {
+                              newLastSync = Math.max(newLastSync, +new Date(updated));
+                          }
+                      }
+                      if (newLastSync && newLastSync !== lastSync) {
+                          updateLastSync(newLastSync);
+                      }
+                      let transformed = data as unknown as TLocal[];
+                      if (transform?.load) {
+                          transformed = await Promise.all(data.map((value) => transform.load!(value, 'get')));
+                      }
+                      if (asType === 'first') {
+                          return transformed.length > 0 ? transformed[0] : null;
+                      } else {
+                          const out: Record<string, any> = asMap ? new Map() : {};
+                          transformed.forEach((result: any) => {
+                              const value = result.__deleted ? internal.symbolDelete : result;
+                              asMap ? (out as Map<any, any>).set(result.id, value) : (out[result.id] = value);
+                          });
+                          return out;
+                      }
+                  } else if (getFn) {
+                      const data = await getFn(getParams);
+
+                      let transformed = data as unknown as TLocal;
+                      if (data) {
+                          const newLastSync =
+                              (data as any)[fieldUpdatedAt as any] || (data as any)[fieldCreatedAt as any];
+                          if (newLastSync && newLastSync !== lastSync) {
+                              updateLastSync(newLastSync);
+                          }
+                          if (transform?.load) {
+                              transformed = await transform.load(data, 'get');
+                          }
+                      }
+
+                      return transformed as any;
+                  }
+              }
+            : undefined;
+
+    const set =
+        createFn || updateFn || deleteFn
+            ? async (params: SyncedSetParams<any> & { retryAsCreate?: boolean }) => {
+                  const { value, changes, update, retryAsCreate, valuePrevious } = params;
+                  const creates = new Map<string, TLocal>();
+                  const updates = new Map<string, object>();
+                  const deletes = new Map<string, object>();
+
+                  changes.forEach(({ path, prevAtPath, valueAtPath }) => {
+                      if (asType === 'first') {
+                          if (value) {
+                              let id = value?.id;
+                              const isCreate = fieldCreatedAt ? !value[fieldCreatedAt!] : !prevAtPath;
+                              if (!id && generateId) {
+                                  id = ensureId(value, generateId);
+                              }
+                              if (id) {
+                                  if (isCreate || retryAsCreate) {
+                                      creates.set(id, value);
+                                  } else if (path.length === 0) {
+                                      if (valueAtPath) {
+                                          updates.set(id, valueAtPath);
+                                      } else if (prevAtPath) {
+                                          deletes.set(prevAtPath?.id, prevAtPath);
+                                      }
+                                  } else {
+                                      const key = path[0];
+                                      updates.set(id, Object.assign(updates.get(id) || { id }, { [key]: value[key] }));
+                                  }
+                              } else {
+                                  console.error('[legend-state]: added item without an id');
+                              }
+                          } else if (path.length === 0) {
+                              const id = prevAtPath?.id;
+                              if (id) {
+                                  deletes.set(id, prevAtPath);
+                              }
+                          }
+                      } else {
+                          let itemsChanged: any[] | undefined = undefined;
+                          let isCreateGuess: boolean;
+                          if (path.length === 0) {
+                              isCreateGuess =
+                                  !(fieldCreatedAt || fieldUpdatedAt) &&
+                                  !(
+                                      (asMap
+                                          ? Array.from((valueAtPath as Map<any, any>).values())
+                                          : isArray(valueAtPath)
+                                          ? valueAtPath
+                                          : Object.values(valueAtPath)
+                                      )?.length > 0
+                                  );
+                              itemsChanged = asMap
+                                  ? Array.from((valueAtPath as Map<any, any>).values())
+                                  : isArray(valueAtPath)
+                                  ? valueAtPath
+                                  : Object.values(valueAtPath);
+                          } else {
+                              const itemKey = path[0];
+                              const itemValue = asMap ? value.get(itemKey) : value[itemKey];
+                              isCreateGuess = !(fieldCreatedAt || fieldUpdatedAt) && path.length === 1 && !prevAtPath;
+                              if (!itemValue) {
+                                  if (path.length === 1 && prevAtPath) {
+                                      if (deleteFn) {
+                                          deletes.set(itemKey, prevAtPath);
+                                      } else {
+                                          console.log('[legend-state] missing delete function');
+                                      }
+                                  }
+                              } else {
+                                  itemsChanged = [itemValue];
+                              }
+                          }
+                          itemsChanged?.forEach((item) => {
+                              const isCreate = fieldCreatedAt
+                                  ? !item[fieldCreatedAt!]
+                                  : fieldUpdatedAt
+                                  ? !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 {
+                                      console.log('[legend-state] missing create function');
+                                  }
+                              } else {
+                                  if (updateFn) {
+                                      updates.set(item.id, item);
+                                  } else {
+                                      console.log('[legend-state] missing update function');
+                                  }
+                              }
+                          });
+                      }
+                  });
+
+                  const saveResult = async (
+                      itemKey: string,
+                      input: TRemote,
+                      data: CrudResult<TRemote>,
+                      isCreate: boolean,
+                  ) => {
+                      if (data && onSaved) {
+                          const dataLoaded: TLocal = (
+                              transform?.load ? transform.load(data as any, 'set') : data
+                          ) as any;
+
+                          const savedOut = onSaved(dataLoaded, input, isCreate);
+
+                          if (savedOut) {
+                              const createdAt = fieldCreatedAt ? savedOut[fieldCreatedAt as keyof TLocal] : undefined;
+                              const updatedAt = fieldUpdatedAt ? savedOut[fieldUpdatedAt as keyof TLocal] : undefined;
+
+                              const value =
+                                  itemKey !== 'undefined' && asType !== 'first' ? { [itemKey]: savedOut } : savedOut;
+                              update({
+                                  value,
+                                  lastSync:
+                                      updatedAt || createdAt ? +new Date(updatedAt || (createdAt as any)) : undefined,
+                                  mode: 'merge',
+                              });
+                          }
+                      }
+                  };
+
+                  return Promise.all([
+                      ...Array.from(creates).map(([itemKey, itemValue]) => {
+                          const createObj = transformOut(itemValue, transform?.save) as TRemote;
+                          return createFn!(createObj, params).then((result) =>
+                              saveResult(itemKey, createObj, result as any, true),
+                          );
+                      }),
+                      ...Array.from(updates).map(([itemKey, itemValue]) => {
+                          const toSave = updatePartial
+                              ? 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;
+
+                          if (Object.keys(changed).length > 0) {
+                              return updateFn!(changed, params).then((result) =>
+                                  saveResult(itemKey, changed, result as any, false),
+                              );
+                          }
+                      }),
+                      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                      ...Array.from(deletes).map(([_, itemValue]) => deleteFn!(itemValue as TRemote, params)),
+                  ]);
+              }
+            : undefined;
+
+    return synced<any>({
+        set,
+        get,
+        mode: modeParam,
+        ...rest,
+    });
+}