@legendapp/state 2.2.0-next.65 → 2.2.0-next.67

package/src/helpers.ts

@@ -41,37 +41,49 @@ export function setAtPath<T extends object>(
     path: string[],
     pathTypes: TypeAtPath[],
     value: any,
+    mode?: 'set' | 'merge',
     fullObj?: T,
     restore?: (path: string[], value: any) => void,
 ) {
     let o: Record<string, any> = obj;
     let oFull: Record<string, any> | undefined = fullObj;
+    let p: string | undefined = undefined;
     if (path.length > 0) {
         for (let i = 0; i < path.length; i++) {
-            const p = path[i];
-            if (i === path.length - 1) {
-                // Don't set if the value is the same. This prevents creating a new key
-                // when setting undefined on an object without this key
-                if (o[p] !== value) {
-                    o[p] = value;
-                }
-            } else if (o[p] === symbolDelete) {
+            p = path[i];
+            if (o[p] === symbolDelete) {
                 // If this was previously deleted, restore it
                 if (oFull) {
                     o[p] = oFull[p];
                     restore?.(path.slice(0, i + 1), o[p]);
                 }
-                break;
+                return obj;
             } else if (o[p] === undefined || o[p] === null) {
                 o[p] = initializePathType(pathTypes[i]);
             }
-            o = o[p];
-            if (oFull) {
-                oFull = oFull[p];
+            if (i < path.length - 1) {
+                o = o[p];
+                if (oFull) {
+                    oFull = oFull[p];
+                }
             }
         }
+    }
+
+    // Don't set if the value is the same. This prevents creating a new key
+    // when setting undefined on an object without this key
+    if (p === undefined) {
+        if (mode === 'merge') {
+            obj = _mergeIntoObservable(obj, value);
+        } else {
+            obj = value;
+        }
     } else {
-        obj = value;
+        if (mode === 'merge') {
+            o[p] = _mergeIntoObservable(o[p], value);
+        } else {
+            o[p] = value;
+        }
     }
 
     return obj;
@@ -81,7 +93,7 @@ export function setInObservableAtPath(
     path: string[],
     pathTypes: TypeAtPath[],
     value: any,
-    mode: 'assign' | 'set',
+    mode: 'assign' | 'set' | 'merge',
 ) {
     let o: Record<string, any> = obs;
     let v = value;
@@ -100,6 +112,8 @@ export function setInObservableAtPath(
     // Assign if possible, or set otherwise
     else if (mode === 'assign' && (o as Observable).assign && isObject(o.peek())) {
         (o as Observable<{}>).assign(v);
+    } else if (mode === 'merge') {
+        mergeIntoObservable(o, v);
     } else {
         o.set(v);
     }

package/src/observableInterfaces.ts

@@ -1,6 +1,6 @@
 import type { symbolOpaque } from './globals';
 import type { Observable, ObservableParam } from './observableTypes';
-import { GetMode, ObservableSyncState, SyncedParams } from './syncTypes';
+import { GetMode, ObservableSyncState, SyncedOptions } from './syncTypes';
 
 export type TrackingType = undefined | true | symbol; // true === shallow
 
@@ -67,7 +67,6 @@ export interface TrackingState {
 interface BaseNodeValue {
     children?: Map<string, ChildNodeValue>;
     proxy?: object;
-    // TODOV3 Remove this
     root: ObservableRoot;
     listeners?: Set<NodeValueListener>;
     listenersImmediate?: Set<NodeValueListener>;
@@ -86,7 +85,7 @@ interface BaseNodeValue {
     needsExtract?: boolean;
     state?: Observable<ObservableSyncState>;
     activated?: boolean;
-    activationState?: SyncedParams & { onError?: () => void; persistedRetry?: boolean };
+    activationState?: SyncedOptions & { onError?: () => void; persistedRetry?: boolean };
     dirtyFn?: () => void;
 }
 

package/src/persist/persistObservable.ts

@@ -12,9 +12,9 @@ import type {
     ObservablePersistRemoteFunctions,
     ObservablePersistState,
     PersistMetadata,
-    PersistOptions,
-    PersistOptionsLocal,
-    PersistOptionsRemote,
+    LegacyPersistOptions,
+    LegacyPersistOptionsLocal,
+    LegacyPersistOptionsRemote,
     PersistTransform,
     TypeAtPath,
 } from '@legendapp/state';
@@ -77,15 +77,15 @@ interface PreppedChangeRemote {
 
 type ChangeWithPathStr = Change & { pathStr: string };
 
-function parseLocalConfig(config: string | PersistOptionsLocal | undefined): {
+function parseLocalConfig(config: string | LegacyPersistOptionsLocal | undefined): {
     table: string;
-    config: PersistOptionsLocal;
+    config: LegacyPersistOptionsLocal;
 } {
     return config
         ? isString(config)
             ? { table: config, config: { name: config } }
             : { table: config.name, config }
-        : ({} as { table: string; config: PersistOptionsLocal });
+        : ({} as { table: string; config: LegacyPersistOptionsLocal });
 }
 
 function doInOrder<T>(arg1: T | Promise<T>, arg2: (value: T) => void): any {
@@ -155,7 +155,7 @@ async function updateMetadataImmediate<T>(
     obs: ObservableParam<any>,
     localState: LocalState,
     syncState: Observable<ObservablePersistState>,
-    persistOptions: PersistOptions<T>,
+    persistOptions: LegacyPersistOptions<T>,
     newMetadata: PersistMetadata,
 ) {
     const saves = Array.from(promisesLocalSaves);
@@ -194,14 +194,15 @@ function updateMetadata<T>(
     obs: ObservableParam<any>,
     localState: LocalState,
     syncState: ObservableObject<ObservablePersistState>,
-    persistOptions: PersistOptions<T>,
+    persistOptions: LegacyPersistOptions<T>,
     newMetadata: PersistMetadata,
 ) {
     if (localState.timeoutSaveMetadata) {
         clearTimeout(localState.timeoutSaveMetadata);
     }
     localState.timeoutSaveMetadata = setTimeout(
-        () => updateMetadataImmediate(obs, localState, syncState, persistOptions as PersistOptions<T>, newMetadata),
+        () =>
+            updateMetadataImmediate(obs, localState, syncState, persistOptions as LegacyPersistOptions<T>, newMetadata),
         persistOptions?.remote?.metadataTimeout || 0,
     );
 }
@@ -212,7 +213,7 @@ interface QueuedChange<T = any> {
     obs: Observable<T>;
     syncState: ObservableObject<ObservablePersistState>;
     localState: LocalState;
-    persistOptions: PersistOptions<T>;
+    persistOptions: LegacyPersistOptions<T>;
     changes: ListenerParams['changes'];
 }
 
@@ -566,7 +567,7 @@ async function doChangeRemote(changeInfo: PreppedChangeRemote | undefined) {
     const local = persistOptions.local;
     const { table, config: configLocal } = parseLocalConfig(local!);
     const { offlineBehavior, allowSetIfError, onBeforeSet, onSetError, waitForSet, onAfterSet } =
-        persistOptions.remote || ({} as PersistOptionsRemote);
+        persistOptions.remote || ({} as LegacyPersistOptionsRemote);
     const shouldSaveMetadata = local && offlineBehavior === 'retry';
 
     if (changesRemote.length > 0) {
@@ -668,7 +669,7 @@ function onObsChange<T>(
     obs: Observable<T>,
     syncState: ObservableObject<ObservablePersistState>,
     localState: LocalState,
-    persistOptions: PersistOptions<T>,
+    persistOptions: LegacyPersistOptions<T>,
     { changes, loading, remote }: ListenerParams,
 ) {
     if (!loading) {
@@ -692,7 +693,7 @@ function onObsChange<T>(
 
 async function loadLocal<T>(
     obs: ObservableParam<T>,
-    persistOptions: PersistOptions<any>,
+    persistOptions: LegacyPersistOptions<any>,
     syncState: ObservableObject<ObservablePersistState>,
     localState: LocalState,
 ) {
@@ -796,14 +797,17 @@ async function loadLocal<T>(
     syncState.isLoadedLocal.set(true);
 }
 
-export function persistObservable<T>(observable: ObservableParam<T>, persistOptions: PersistOptions<T>): Observable<T>;
+export function persistObservable<T>(
+    observable: ObservableParam<T>,
+    persistOptions: LegacyPersistOptions<T>,
+): Observable<T>;
 export function persistObservable<T>(
     initial: T | (() => T) | (() => Promise<T>),
-    persistOptions: PersistOptions<T>,
+    persistOptions: LegacyPersistOptions<T>,
 ): Observable<T>;
 export function persistObservable<T>(
     initialOrObservable: ObservableParam<T> | T | (() => T) | (() => Promise<T>),
-    persistOptions: PersistOptions<T>,
+    persistOptions: LegacyPersistOptions<T>,
 ): Observable<T> {
     const obs$ = (
         isObservable(initialOrObservable)
@@ -820,7 +824,7 @@ export function persistObservable<T>(
             removeNullUndefined(persistOptions.remote),
         );
     }
-    let { remote } = persistOptions as { remote: PersistOptionsRemote<T> };
+    let { remote } = persistOptions as { remote: LegacyPersistOptionsRemote<T> };
     const { local } = persistOptions;
     const remotePersistence = persistOptions.pluginRemote! || observablePersistConfiguration?.pluginRemote;
     const localState: LocalState = {};
@@ -871,7 +875,7 @@ export function persistObservable<T>(
                     get({
                         state: syncState,
                         obs: obs$,
-                        options: persistOptions as PersistOptions<any>,
+                        options: persistOptions as LegacyPersistOptions<any>,
                         lastSync,
                         dateModified: lastSync,
                         onError: (error: Error) => {
@@ -945,7 +949,7 @@ export function persistObservable<T>(
                                 }
                             }
                             if (lastSync && local) {
-                                updateMetadata(obs$, localState, syncState, persistOptions as PersistOptions<T>, {
+                                updateMetadata(obs$, localState, syncState, persistOptions as LegacyPersistOptions<T>, {
                                     lastSync,
                                 });
                             }
@@ -1014,7 +1018,7 @@ export function persistObservable<T>(
         }
 
         obs$.onChange(
-            onObsChange.bind(this, obs$ as any, syncState, localState, persistOptions as PersistOptions<any>),
+            onObsChange.bind(this, obs$ as any, syncState, localState, persistOptions as LegacyPersistOptions<any>),
         );
     });
 

package/src/{cache-plugins → persist-plugins}/async-storage.ts

@@ -1,10 +1,10 @@
 import type {
     Change,
-    ObservablePersistLocal,
+    ObservablePersistPlugin,
     ObservablePersistenceConfigLocalGlobalOptions,
     PersistMetadata,
 } from '@legendapp/state';
-import { isArray, setAtPath, internal } from '@legendapp/state';
+import { internal, isArray, setAtPath } from '@legendapp/state';
 import type { AsyncStorageStatic } from '@react-native-async-storage/async-storage';
 
 const MetadataSuffix = '__m';
@@ -13,7 +13,7 @@ let AsyncStorage: AsyncStorageStatic;
 
 const { safeParse, safeStringify } = internal;
 
-export class ObservablePersistAsyncStorage implements ObservablePersistLocal {
+export class ObservablePersistAsyncStorage implements ObservablePersistPlugin {
     private data: Record<string, any> = {};
 
     // Init
@@ -58,11 +58,11 @@ export class ObservablePersistAsyncStorage implements ObservablePersistLocal {
         }
     }
     // Gets
-    public getTable(table: string) {
-        return this.data[table] ?? {};
+    public getTable(table: string, init: object) {
+        return this.data[table] ?? init ?? {};
     }
     public getMetadata(table: string): PersistMetadata {
-        return this.getTable(table + MetadataSuffix);
+        return this.getTable(table + MetadataSuffix, {});
     }
     // Sets
     public set(table: string, changes: Change[]): Promise<void> {

package/src/persist-plugins/firebase.ts

@@ -5,7 +5,7 @@ import {
     ObservablePersistRemoteSetParams,
     ObservablePrimitive,
     ObservableParam,
-    PersistOptions,
+    LegacyPersistOptions,
     QueryByModified,
     TypeAtPath,
     batch,
@@ -82,7 +82,7 @@ type SaveInfoDictionary<T = any> = {
 };
 
 interface PendingSaves {
-    options: PersistOptions;
+    options: LegacyPersistOptions;
     saves: SaveInfoDictionary;
 }
 
@@ -564,7 +564,7 @@ class ObservablePersistFirebaseBase implements ObservablePersistRemoteClass {
         return {};
     }
     private _constructBatch(
-        options: PersistOptions,
+        options: LegacyPersistOptions,
         batch: Record<string, string | object>,
         basePath: string,
         saves: SaveInfoDictionary,

package/src/{cache-plugins → persist-plugins}/indexeddb.ts

@@ -1,10 +1,10 @@
 import type {
     Change,
     Observable,
-    ObservableCachePluginOptions,
-    ObservablePersistLocal,
+    ObservablePersistPluginOptions,
+    ObservablePersistPlugin,
     PersistMetadata,
-    PersistOptionsLocal,
+    PersistOptions,
 } from '@legendapp/state';
 import { isPrimitive, isPromise, observable, setAtPath, when } from '@legendapp/state';
 
@@ -14,14 +14,14 @@ function requestToPromise(request: IDBRequest) {
     return new Promise<void>((resolve) => (request.onsuccess = () => resolve()));
 }
 
-export class ObservablePersistIndexedDB implements ObservablePersistLocal {
+export class ObservablePersistIndexedDB implements ObservablePersistPlugin {
     private tableData: Record<string, any> = {};
     private tableMetadata: Record<string, any> = {};
     private tablesAdjusted: Map<string, Observable<boolean>> = new Map();
     private db: IDBDatabase | undefined;
     private isSaveTaskQueued = false;
     private pendingSaves = new Map<
-        PersistOptionsLocal,
+        PersistOptions,
         Record<string, { tableName: string; tablePrev?: any; items: Set<string> }>
     >();
     private promisesQueued: (() => void)[] = [];
@@ -30,7 +30,7 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
         this.doSave = this.doSave.bind(this);
     }
 
-    public async initialize(config: ObservableCachePluginOptions) {
+    public async initialize(config: ObservablePersistPluginOptions) {
         if (typeof indexedDB === 'undefined') return;
         if (process.env.NODE_ENV === 'development' && !config?.indexedDB) {
             console.error('[legend-state] Must configure ObservablePersistIndexedDB');
@@ -75,7 +75,7 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
             };
         });
     }
-    public loadTable(table: string, config: PersistOptionsLocal): void | Promise<void> {
+    public loadTable(table: string, config: PersistOptions): void | Promise<void> {
         if (!this.tableData[table]) {
             const transaction = this.db!.transaction(table, 'readonly');
 
@@ -94,7 +94,7 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
             } else {
                 const obsLoaded = observable(false);
                 this.tablesAdjusted.set(tableName, obsLoaded);
-                const data = this.getTable(table, config);
+                const data = this.getTable(table, {}, config);
                 let hasPromise = false;
                 let promises: Promise<any>[];
                 if (data) {
@@ -122,7 +122,7 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
             }
         }
     }
-    public getTable(table: string, config: PersistOptionsLocal) {
+    public getTable(table: string, init: object, config: PersistOptions) {
         const configIDB = config.indexedDB;
         const prefix = configIDB?.prefixID;
         const data = this.tableData[prefix ? table + '/' + prefix : table];
@@ -132,11 +132,11 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
             return data;
         }
     }
-    public getMetadata(table: string, config: PersistOptionsLocal) {
+    public getMetadata(table: string, config: PersistOptions) {
         const { tableName } = this.getMetadataTableName(table, config);
         return this.tableMetadata[tableName];
     }
-    public async setMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal) {
+    public async setMetadata(table: string, metadata: PersistMetadata, config: PersistOptions) {
         const { tableName, tableNameBase } = this.getMetadataTableName(table, config);
         // Assign new metadata into the table, and make sure it has the id
         this.tableMetadata[tableName] = Object.assign(metadata, {
@@ -146,14 +146,14 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
         const store = this.transactionStore(table);
         return store.put(metadata);
     }
-    public async deleteMetadata(table: string, config: PersistOptionsLocal): Promise<void> {
+    public async deleteMetadata(table: string, config: PersistOptions): Promise<void> {
         const { tableName, tableNameBase } = this.getMetadataTableName(table, config);
         delete this.tableMetadata[tableName];
         const store = this.transactionStore(table);
         const key = tableNameBase + MetadataSuffix;
         store.delete(key);
     }
-    public async set(table: string, changes: Change[], config: PersistOptionsLocal) {
+    public async set(table: string, changes: Change[], config: PersistOptions) {
         if (typeof indexedDB === 'undefined') return;
 
         if (!this.pendingSaves.has(config)) {
@@ -249,7 +249,7 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
 
         promisesQueued.forEach((resolve) => resolve());
     }
-    public async deleteTable(table: string, config: PersistOptionsLocal): Promise<void> {
+    public async deleteTable(table: string, config: PersistOptions): Promise<void> {
         const configIDB = config.indexedDB;
         const prefixID = configIDB?.prefixID;
         const tableName = prefixID ? table + '/' + prefixID : table;
@@ -289,7 +289,7 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
         }
     }
     // Private
-    private getMetadataTableName(table: string, config: PersistOptionsLocal) {
+    private getMetadataTableName(table: string, config: PersistOptions) {
         const configIDB = config.indexedDB;
         let name = '';
         if (configIDB) {
@@ -357,7 +357,7 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
         const transaction = this.db!.transaction(table, 'readwrite');
         return transaction.objectStore(table);
     }
-    private _setItem(table: string, key: string, value: any, store: IDBObjectStore, config: PersistOptionsLocal) {
+    private _setItem(table: string, key: string, value: any, store: IDBObjectStore, config: PersistOptions) {
         if (!value) {
             if (this.tableData[table]) {
                 delete this.tableData[table][key];
@@ -399,7 +399,7 @@ export class ObservablePersistIndexedDB implements ObservablePersistLocal {
         prev: object,
         value: Record<string, any>,
         store: IDBObjectStore,
-        config: PersistOptionsLocal,
+        config: PersistOptions,
     ) {
         const keys = Object.keys(value);
         let lastSet: IDBRequest | undefined;

package/src/{cache-plugins → persist-plugins}/local-storage.ts

@@ -1,30 +1,30 @@
-import type { Change, ObservableCachePlugin, PersistMetadata } from '@legendapp/state';
+import type { Change, ObservablePersistPlugin, PersistMetadata } from '@legendapp/state';
 import { internal, setAtPath } from '@legendapp/state';
 
 const MetadataSuffix = '__m';
 
 const { safeParse, safeStringify } = internal;
 
-export class ObservableCacheLocalStorageBase implements ObservableCachePlugin {
+export class ObservablePersistLocalStorageBase implements ObservablePersistPlugin {
     private data: Record<string, any> = {};
     private storage: Storage | undefined;
     constructor(storage: Storage | undefined) {
         this.storage = storage;
     }
-    public getTable(table: string) {
+    public getTable(table: string, init: any) {
         if (!this.storage) return undefined;
         if (this.data[table] === undefined) {
             try {
                 const value = this.storage.getItem(table);
-                this.data[table] = value ? safeParse(value) : undefined;
+                this.data[table] = value ? safeParse(value) : init;
             } catch {
-                console.error('[legend-state] ObservableCacheLocalStorageBase failed to parse', table);
+                console.error('[legend-state] ObservablePersistLocalStorageBase failed to parse', table);
             }
         }
         return this.data[table];
     }
     public getMetadata(table: string): PersistMetadata {
-        return this.getTable(table + MetadataSuffix);
+        return this.getTable(table + MetadataSuffix, {});
     }
     public set(table: string, changes: Change[]): void {
         if (!this.data[table]) {
@@ -64,7 +64,7 @@ export class ObservableCacheLocalStorageBase implements ObservableCachePlugin {
         }
     }
 }
-export class ObservableCacheLocalStorage extends ObservableCacheLocalStorageBase {
+export class ObservablePersistLocalStorage extends ObservablePersistLocalStorageBase {
     constructor() {
         super(
             typeof localStorage !== 'undefined'
@@ -76,7 +76,7 @@ export class ObservableCacheLocalStorage extends ObservableCacheLocalStorageBase
         );
     }
 }
-export class ObservableCacheSessionStorage extends ObservableCacheLocalStorageBase {
+export class ObservablePersistSessionStorage extends ObservablePersistLocalStorageBase {
     constructor() {
         super(
             typeof sessionStorage !== 'undefined'

package/src/{cache-plugins → persist-plugins}/mmkv.ts

@@ -1,4 +1,4 @@
-import type { Change, ObservablePersistLocal, PersistMetadata, PersistOptionsLocal } from '@legendapp/state';
+import type { Change, ObservablePersistPlugin, PersistMetadata, PersistOptions } from '@legendapp/state';
 import { internal, setAtPath } from '@legendapp/state';
 import { MMKV } from 'react-native-mmkv';
 
@@ -7,7 +7,7 @@ const MetadataSuffix = '__m';
 
 const { safeParse, safeStringify } = internal;
 
-export class ObservablePersistMMKV implements ObservablePersistLocal {
+export class ObservablePersistMMKV implements ObservablePersistPlugin {
     private data: Record<string, any> = {};
     private storages = new Map<symbol | string, MMKV>([
         [
@@ -18,23 +18,23 @@ export class ObservablePersistMMKV implements ObservablePersistLocal {
         ],
     ]);
     // Gets
-    public getTable<T = any>(table: string, config: PersistOptionsLocal): T {
+    public getTable<T = any>(table: string, init: object, config: PersistOptions): T {
         const storage = this.getStorage(config);
         if (this.data[table] === undefined) {
             try {
                 const value = storage.getString(table);
-                this.data[table] = value ? safeParse(value) : undefined;
+                this.data[table] = value ? safeParse(value) : init;
             } catch {
                 console.error('[legend-state] MMKV failed to parse', table);
             }
         }
         return this.data[table];
     }
-    public getMetadata(table: string, config: PersistOptionsLocal): PersistMetadata {
-        return this.getTable(table + MetadataSuffix, config);
+    public getMetadata(table: string, config: PersistOptions): PersistMetadata {
+        return this.getTable(table + MetadataSuffix, {}, config);
     }
     // Sets
-    public set(table: string, changes: Change[], config: PersistOptionsLocal) {
+    public set(table: string, changes: Change[], config: PersistOptions) {
         if (!this.data[table]) {
             this.data[table] = {};
         }
@@ -44,19 +44,19 @@ export class ObservablePersistMMKV implements ObservablePersistLocal {
         }
         this.save(table, config);
     }
-    public setMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal) {
+    public setMetadata(table: string, metadata: PersistMetadata, config: PersistOptions) {
         return this.setValue(table + MetadataSuffix, metadata, config);
     }
-    public deleteTable(table: string, config: PersistOptionsLocal): void {
+    public deleteTable(table: string, config: PersistOptions): void {
         const storage = this.getStorage(config);
         delete this.data[table];
         storage.delete(table);
     }
-    public deleteMetadata(table: string, config: PersistOptionsLocal) {
+    public deleteMetadata(table: string, config: PersistOptions) {
         this.deleteTable(table + MetadataSuffix, config);
     }
     // Private
-    private getStorage(config: PersistOptionsLocal): MMKV {
+    private getStorage(config: PersistOptions): MMKV {
         const { mmkv } = config;
         if (mmkv) {
             const key = JSON.stringify(mmkv);
@@ -70,11 +70,11 @@ export class ObservablePersistMMKV implements ObservablePersistLocal {
             return this.storages.get(symbolDefault)!;
         }
     }
-    private async setValue(table: string, value: any, config: PersistOptionsLocal) {
+    private async setValue(table: string, value: any, config: PersistOptions) {
         this.data[table] = value;
         this.save(table, config);
     }
-    private save(table: string, config: PersistOptionsLocal) {
+    private save(table: string, config: PersistOptions) {
         const storage = this.getStorage(config);
         const v = this.data[table];
         if (v !== undefined) {

package/src/persistTypes.ts

@@ -6,7 +6,7 @@ import type { AsyncStorageStatic } from '@react-native-async-storage/async-stora
 // @ts-ignore
 import type { DatabaseReference, Query } from 'firebase/database';
 
-import type { GetMode } from './syncTypes';
+import type { GetMode, PersistMetadata } from './syncTypes';
 import type {
     ArrayValue,
     Change,
@@ -24,7 +24,7 @@ export interface PersistTransform<TOrig = any, TSaved = TOrig> {
     save?: (value: TOrig) => TSaved | Promise<TSaved>;
 }
 
-export interface PersistOptionsLocal<T = any> {
+export interface LegacyPersistOptionsLocal<T = any> {
     name: string;
     transform?: PersistTransform<T>;
     fieldTransforms?: FieldTransforms<T>;
@@ -36,7 +36,7 @@ export interface PersistOptionsLocal<T = any> {
     };
     options?: any;
 }
-export type PersistOptionsRemote<T = any> = ObservablePersistenceConfigRemoteGlobalOptions & {
+export type LegacyPersistOptionsRemote<T = any> = ObservablePersistenceConfigRemoteGlobalOptions & {
     readonly?: boolean;
     waitForGet?: Selector<any>;
     waitForSet?: LinkedParams['waitForSet'];
@@ -92,29 +92,22 @@ export interface ObservablePersistenceConfig {
     localOptions?: ObservablePersistenceConfigLocalGlobalOptions;
     remoteOptions?: ObservablePersistenceConfigRemoteGlobalOptions;
 }
-export interface PersistOptions<T = any> {
-    local?: string | PersistOptionsLocal<T>;
-    remote?: PersistOptionsRemote<T>;
+export interface LegacyPersistOptions<T = any> {
+    local?: string | LegacyPersistOptionsLocal<T>;
+    remote?: LegacyPersistOptionsRemote<T>;
     pluginLocal?: ClassConstructor<ObservablePersistLocal>;
     pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions<T>;
 }
 
-export interface PersistMetadata {
-    id?: '__legend_metadata';
-    // modified ?: number;
-    lastSync?: number;
-    pending?: any;
-}
-
 export interface ObservablePersistLocal {
     initialize?(config: ObservablePersistenceConfigLocalGlobalOptions): void | Promise<void>;
-    loadTable?(table: string, config: PersistOptionsLocal): Promise<any> | void;
-    getTable<T = any>(table: string, config: PersistOptionsLocal): T;
-    set(table: string, changes: Change[], config: PersistOptionsLocal): Promise<any> | void;
-    deleteTable(table: string, config: PersistOptionsLocal): Promise<any> | void;
-    getMetadata(table: string, config: PersistOptionsLocal): PersistMetadata;
-    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal): Promise<any> | void;
-    deleteMetadata(table: string, config: PersistOptionsLocal): Promise<any> | void;
+    loadTable?(table: string, config: LegacyPersistOptionsLocal): Promise<any> | void;
+    getTable<T = any>(table: string, config: LegacyPersistOptionsLocal): T;
+    set(table: string, changes: Change[], config: LegacyPersistOptionsLocal): Promise<any> | void;
+    deleteTable(table: string, config: LegacyPersistOptionsLocal): Promise<any> | void;
+    getMetadata(table: string, config: LegacyPersistOptionsLocal): PersistMetadata;
+    setMetadata(table: string, metadata: PersistMetadata, config: LegacyPersistOptionsLocal): Promise<any> | void;
+    deleteMetadata(table: string, config: LegacyPersistOptionsLocal): Promise<any> | void;
 }
 export interface ObservableOnChangeParams {
     value: unknown;
@@ -127,14 +120,14 @@ export interface ObservableOnChangeParams {
 export interface ObservablePersistRemoteSetParams<T> {
     syncState: Observable<ObservablePersistState>;
     obs: ObservableParam<T>;
-    options: PersistOptions<T>;
+    options: LegacyPersistOptions<T>;
     changes: Change[];
     value: T;
 }
 export interface ObservablePersistRemoteGetParams<T> {
     state: Observable<ObservablePersistState>;
     obs: ObservableParam<T>;
-    options: PersistOptions<T>;
+    options: LegacyPersistOptions<T>;
     dateModified?: number;
     lastSync?: number;
     mode?: GetMode;