@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-beta.10

package/src/user/events/onUserUpdated.ts

@@ -8,7 +8,7 @@ import { createUserEventSubscriber } from './utils'
  * })
  * ```
  *
- * Fired when any {@link Amity.User} have been updated
+ * Fired when a {@link Amity.User} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening

package/src/user/events/utils.ts

@@ -1,8 +1,8 @@
 import { getActiveClient } from '~/client/api'
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
 import { createEventSubscriber } from '~/core/events'
 
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
 export const createUserEventSubscriber = (
   event: keyof Amity.MqttUserMessageEvents,
   callback: Amity.Listener<Amity.User>
@@ -10,8 +10,10 @@ export const createUserEventSubscriber = (
   const client = getActiveClient()
 
   const filter = (payload: Amity.UserPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
+    if (client.cache) {
+      ingestInCache(payload)
+    }
+
     callback(payload.users[0])
   }
 

package/src/user/observers/observeUser.ts

@@ -27,7 +27,7 @@ import {
  */
 export const observeUser = <Events extends ['onFetch', 'onUpdate', 'onFlagged', 'onUnflagged', 'onFlagCleared']>(
   userId: string,
-  callback: Amity.ObjectListener<Amity.QueryResult<Amity.User>, Events>,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.User>, Events>
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient()
 
@@ -36,17 +36,15 @@ export const observeUser = <Events extends ['onFetch', 'onUpdate', 'onFlagged',
 
   // wrapper function to make sure
   const router = (
-    result: Amity.QueryResult<Amity.User>,
+    result: Amity.Snapshot<Amity.User>,
     action: Events[number]
   ) => {
     // filter function
     if (result.data?.userId !== userId) return
 
-    if (callback instanceof Function)
-      return callback(result)
+    if (callback instanceof Function) return callback(result)
 
-    if (action !== 'onFetch')
-      callback.onEvent?.(action, result)
+    if (action !== 'onFetch') callback.onEvent?.(action, result)
 
     callback[action]?.(result)
   }
@@ -54,15 +52,15 @@ export const observeUser = <Events extends ['onFetch', 'onUpdate', 'onFlagged',
   const disposers: Amity.Unsubscriber[] = []
 
   disposers.push(
-    onUserUpdated(data => router({ data }, 'onUpdate')),
-    onUserFlagged(data => router({ data }, 'onFlagged')),
-    onUserUnflagged(data => router({ data }, 'onUnflagged')),
-    onUserFlagCleared(data => router({ data }, 'onFlagCleared'))
+    onUserUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onUserFlagged(data => router({ data, loading: false, origin: 'event' }, 'onFlagged')),
+    onUserUnflagged(data => router({ data, loading: false, origin: 'event' }, 'onUnflagged')),
+    onUserFlagCleared(data => router({ data, loading: false, origin: 'event' }, 'onFlagCleared'))
   )
 
   runQuery(
     createQuery(getUser, userId),
-    (result) => result.data && router(result, 'onFetch'),
+    result => result.data && router(result, 'onFetch')
   )
 
   return () => {

package/dist/@types/core/store.d.ts

@@ -1,46 +0,0 @@
-export {};
-declare global {
-    namespace Amity {
-        /**
-         * Represents what needs to be done to read the state of a store
-         * @hidden
-         */
-        type StateReader<T extends {}> = () => Record<string, T>;
-        /**
-         * Represents what needs to be done to write in the state of a store.
-         * @hidden
-         */
-        type StateWriter<T extends {}> = (payload: Record<string, T>) => void;
-        /**
-         * Represents what needs to be done to erase records in the state of a store.
-         * @hidden
-         */
-        type StateEraser = (...payload: string[]) => void;
-        /**
-         * Every object which has a read:StateReader function and a write:StateWriter function can be
-         * considered as a valid store. This opens the door for open and generic storage implementations.
-         * We can imagine linking this to React Context, Redux, MobX, VueX, any local database...
-         *
-         * Below "defaultStore" is a minimal "in memory + mutable" storage implementation, which is the
-         * bare minimum required to make the cache implementation working.
-         *
-         * Further storage strategies (offline, immutables, etc...) could be provided as
-         * core or community plugins.
-         * @hidden
-         */
-        type Store<T extends {} = any> = {
-            read: StateReader<T>;
-            write: StateWriter<T>;
-            erase: StateEraser;
-        };
-        /**
-         * Manually computed type to output a dictionary of { StoreName: Amity.Store<Model> }
-         * with proper typing based on T
-         * @hidden
-         */
-        type StoreCollection<T extends Amity.Domain[]> = {
-            [K in T[number]]: Store<Amity.Model[K]>;
-        };
-    }
-}
-//# sourceMappingURL=store.d.ts.map

package/dist/@types/core/store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/@types/core/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAA;AAET,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,KAAK,CAAC;QACd;;;WAGG;QACH,KAAK,WAAW,CAAC,CAAC,SAAS,EAAE,IAAI,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;QAExD;;;WAGG;QACH,KAAK,WAAW,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,IAAI,CAAA;QAErE;;;WAGG;QACH,KAAK,WAAW,GAAG,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAA;QAEjD;;;;;;;;;;;WAWG;QACH,KAAK,KAAK,CAAC,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI;YAC/B,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;YACpB,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;YACrB,KAAK,EAAE,WAAW,CAAA;SACnB,CAAA;QAED;;;;WAIG;QACH,KAAK,eAAe,CAClB,CAAC,SAAS,KAAK,CAAC,MAAM,EAAE,IACtB;aACD,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SACxC,CAAA;KACF;CACF"}

package/dist/client/api/clearCache.d.ts

@@ -1,15 +0,0 @@
-/**
- * ```js
- * import { clearCache } from '@amityco/ts-sdk'
- * clearCache()
- * ```
- *
- * Resets the state of the given {@link Amity.Store} names within
- * the {@link Amity.Cache} object of a {@link Amity.Client} instance
- *
- * @param stores an array of the stores names to be wiped
- *
- * @category Client API
- */
-export declare const clearCache: (stores?: Amity.Domain[]) => void;
-//# sourceMappingURL=clearCache.d.ts.map

package/dist/client/api/clearCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clearCache.d.ts","sourceRoot":"","sources":["../../../src/client/api/clearCache.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,YACb,MAAM,MAAM,EAAE,SAMvB,CAAA"}

package/dist/client/api/enableCache.d.ts

@@ -1,15 +0,0 @@
-import { createCache } from '~/core/cache';
-/**
- * ```js
- * import { enableCache } from '@amityco/ts-sdk'
- * enableCache()
- * ```
- *
- * Adds a new {@link Amity.Cache} object to an {@link Amity.Client} instance
- *
- * @param stores a partial dictionary of stores to be used for caching
- *
- * @category Client API
- */
-export declare const enableCache: (stores?: Parameters<typeof createCache>[0]) => void;
-//# sourceMappingURL=enableCache.d.ts.map

package/dist/client/api/enableCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"enableCache.d.ts","sourceRoot":"","sources":["../../../src/client/api/enableCache.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG1C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,YACd,WAAW,kBAAkB,CAAC,CAAC,CAAC,CAAC,SAiB1C,CAAA"}

package/dist/core/cache/drop.d.ts

@@ -1,11 +0,0 @@
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param keys A collection of unique keys for the store
- * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
- *
- * @category Cache
- */
-export declare const dropFromCache: <T extends keyof Amity.Model>(name: T, partial: Amity.Minimal[T] & Partial<Amity.Model[T]>) => never[] | undefined;
-//# sourceMappingURL=drop.d.ts.map

package/dist/core/cache/drop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../src/core/cache/drop.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,oHAWzB,CAAA"}

package/dist/core/cache/index.d.ts

@@ -1,19 +0,0 @@
-export * from './pull';
-export * from './push';
-export * from './drop';
-export * from './sync';
-export * from './ingest';
-export * from './mutate';
-export * from './merge';
-/**
- * Creates a cache instance. The cache instance will handle stores
- * given to it as input, and will be used as the first source of cached data
- * in the SDK.
- *
- * @param stores A partial collection of stores
- * @returns A cache instance
- *
- * @category Cache
- */
-export declare const createCache: (stores: Partial<Amity.StoreCollection<Amity.Domain[]>>) => Amity.Cache;
-//# sourceMappingURL=index.d.ts.map

package/dist/core/cache/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/cache/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,QAAQ,CAAA;AACtB,cAAc,QAAQ,CAAA;AACtB,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AAEvB;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,WACd,QAAQ,MAAM,eAAe,CAAC,MAAM,MAAM,EAAE,CAAC,CAAC,KACrD,WAGF,CAAA"}

package/dist/core/cache/ingest.d.ts

@@ -1,10 +0,0 @@
-/**
- * Ingest a payload (v3) into the cache
- *
- * @param payload a "backend v3" payload object
- * @param order the order of the keys to process (in case of need)
- *
- * @category Cache
- */
-export declare const ingestInCache: (payload?: Record<string, any[]>, order?: string[]) => void;
-//# sourceMappingURL=ingest.d.ts.map

package/dist/core/cache/ingest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ingest.d.ts","sourceRoot":"","sources":["../../../src/core/cache/ingest.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,aACf,OAAO,MAAM,EAAE,GAAG,EAAE,CAAC,2BAU/B,CAAA"}

package/dist/core/cache/merge.d.ts

@@ -1,10 +0,0 @@
-/**
- * Apply partial mutation to objects in the cache
- *
- * @param name The name of the store to query
- * @param mutation A partial view of the object to update
- *
- * @category Cache
- */
-export declare const mergeInCache: <T extends keyof Amity.Model>(name: T, mutation: Amity.Minimal[T] & Partial<Amity.Model[T]>) => void;
-//# sourceMappingURL=merge.d.ts.map

package/dist/core/cache/merge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/core/cache/merge.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,sGAMxB,CAAA"}

package/dist/core/cache/mutate.d.ts

@@ -1,10 +0,0 @@
-/**
- * Apply partial mutation to objects in the cache
- *
- * @param name The name of the store to query
- * @param mutation A partial view of the object to update
- *
- * @category Cache
- */
-export declare const mutateCache: <T extends keyof Amity.Model>(name: T, key: string, mutator: (model: Amity.Model[T]) => Amity.Model[T] | undefined) => Amity.Model[T] | undefined;
-//# sourceMappingURL=mutate.d.ts.map

package/dist/core/cache/mutate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutate.d.ts","sourceRoot":"","sources":["../../../src/core/cache/mutate.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,8CAEjB,MAAM,+FAWZ,CAAA"}

package/dist/core/cache/pull.d.ts

@@ -1,11 +0,0 @@
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param keys A collection of unique keys for the store
- * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
- *
- * @category Cache
- */
-export declare const pullFromCache: <K extends keyof Amity.Model>(name: K, ...keys: string[]) => Amity.Model[K][] | undefined;
-//# sourceMappingURL=pull.d.ts.map

package/dist/core/cache/pull.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../../src/core/cache/pull.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,kDAA8C,MAAM,EAAE,iCAmB/E,CAAA"}

package/dist/core/cache/push.d.ts

@@ -1,10 +0,0 @@
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param models A collection of models t store
- *
- * @category Cache
- */
-export declare const pushToCache: <T extends keyof Amity.Model>(name: T, ...models: Amity.Model[T][]) => void;
-//# sourceMappingURL=push.d.ts.map

package/dist/core/cache/push.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../../../src/core/cache/push.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,6EA4BvB,CAAA"}

package/dist/core/cache/sync.d.ts

@@ -1,10 +0,0 @@
-/**
- * Sync-up local ids of objects in the cache
- *
- * @param original The object holding the localId to keep
- * @param replacement The object holding the localId to discard
- *
- * @category Cache
- */
-export declare const syncInCache: <T extends keyof Amity.Model>(original: Amity.Model[T], replacement: Amity.Model[T]) => void;
-//# sourceMappingURL=sync.d.ts.map

package/dist/core/cache/sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../src/core/cache/sync.ts"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,8FAyBvB,CAAA"}

package/dist/core/model/toRecord.d.ts

@@ -1,10 +0,0 @@
-/**
- * converts an array looking collection to an object collection, grouped by localId
- *
- * @param array array of {@link Amity.Syncable}
- * @returns array converted to object, grouped by localId
- *
- * @hidden
- */
-export declare const toRecord: <T extends Amity.Syncable>(array: T[]) => Record<string, T>;
-//# sourceMappingURL=toRecord.d.ts.map

package/dist/core/model/toRecord.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toRecord.d.ts","sourceRoot":"","sources":["../../../src/core/model/toRecord.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,6DAEpB,CAAA"}

package/dist/core/query/decorate.d.ts

@@ -1,23 +0,0 @@
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param timestamp the given timestamp
- */
-export declare const decoratePayload: (payload: Record<string, object[]>, timestamp?: number, keyMapping?: Record<string, Amity.Domain>) => void;
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param timestamp the given timestamp
- */
-export declare const decorateModels: <T extends Amity.User | Amity.File<any> | Amity.Role | Amity.Channel<any> | Amity.Membership<"channel"> | Amity.Message<any> | Amity.Community | Amity.Membership<"community"> | Amity.Post<any> | Amity.Comment<any> | Amity.Stream>(models: T[], timestamp?: number, type?: keyof Amity.Model | undefined) => void;
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param syncedAt the given timestamp
- * @param type An opportunity to manually pass the type. If undefined, it will be smartly computed
- */
-export declare const decorateModel: <T extends Amity.User | Amity.File<any> | Amity.Role | Amity.Channel<any> | Amity.Membership<"channel"> | Amity.Message<any> | Amity.Community | Amity.Membership<"community"> | Amity.Post<any> | Amity.Comment<any> | Amity.Stream>(model: T, timestamp?: number, type?: keyof Amity.Model | undefined) => void;
-//# sourceMappingURL=decorate.d.ts.map

package/dist/core/query/decorate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decorate.d.ts","sourceRoot":"","sources":["../../../src/core/query/decorate.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,YACjB,OAAO,MAAM,EAAE,MAAM,EAAE,CAAC,cACtB,MAAM,eACL,OAAO,MAAM,EAAE,MAAM,MAAM,CAAC,SAQzC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,iQAEd,MAAM,+CAIlB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,8PAEb,MAAM,+CAWlB,CAAA"}

package/dist/core/stores/index.d.ts

@@ -1,3 +0,0 @@
-export * from './memory';
-export * from './persistent';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/stores/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/stores/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA"}

package/dist/core/stores/memory.d.ts

@@ -1,30 +0,0 @@
-/**
- * Minimal store implementation.
- *
- * Beware, the state is mutable! it is your responsibility
- * handle the state's mutations correctly. We do so in
- * order for users with mutable/observable stacks to be able
- * to decorate the state with their favorite libraries.
- *
- * @param defaultValue the hydration state value of the store
- * @returns A store instance with an "in memory" storage strategy
- *
- * @category Storage
- * @hidden
- */
-export declare const memoryStore: <T extends {}>(defaultValue?: Record<string, T>) => Amity.Store<T>;
-/**
- * ```js
- * import { memoryStores } from '@amityco/core/cache/store/volatile'
- * const stores = imemoryStores('user', 'file')
- * ```
- *
- * Builds a collection of in memory stores based on the available store names
- *
- * @param names collection of store names
- * @returns a dictionary of { storeName: storeInstance } according to the given names
- *
- * @category Storage
- */
-export declare const memoryStores: <T extends (keyof Amity.Model)[]>(...names: T) => Amity.StoreCollection<T>;
-//# sourceMappingURL=memory.d.ts.map

package/dist/core/stores/memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/core/stores/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,oEAsBvB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,4EAOxB,CAAA"}

package/dist/core/stores/persistent.d.ts

@@ -1,13 +0,0 @@
-/**
- * Persistent store implementation.
- *
- * @param persistentKey the name of the store in persistent storage
- * @param defaultValue the hydration state value of the store
- * @param debounceTime a delay to avoid spamming the persistent storage while writing,
- * @returns A store instance with an "persistent" storage strategy
- *
- * @category Storage
- * @hidden
- */
-export declare const persistentStore: <T extends {}>(persistentKey: string, defaultValue?: Record<string, T>, debounceTime?: number) => Promise<Amity.Store<T>>;
-//# sourceMappingURL=persistent.d.ts.map

package/dist/core/stores/persistent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"persistent.d.ts","sourceRoot":"","sources":["../../../src/core/stores/persistent.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,gCACX,MAAM,qFA4CtB,CAAA"}

package/src/@types/core/store.ts

@@ -1,52 +0,0 @@
-export {}
-
-declare global {
-  namespace Amity {
-    /**
-     * Represents what needs to be done to read the state of a store
-     * @hidden
-     */
-    type StateReader<T extends {}> = () => Record<string, T>
-
-    /**
-     * Represents what needs to be done to write in the state of a store.
-     * @hidden
-     */
-    type StateWriter<T extends {}> = (payload: Record<string, T>) => void
-
-    /**
-     * Represents what needs to be done to erase records in the state of a store.
-     * @hidden
-     */
-    type StateEraser = (...payload: string[]) => void
-
-    /**
-     * Every object which has a read:StateReader function and a write:StateWriter function can be
-     * considered as a valid store. This opens the door for open and generic storage implementations.
-     * We can imagine linking this to React Context, Redux, MobX, VueX, any local database...
-     *
-     * Below "defaultStore" is a minimal "in memory + mutable" storage implementation, which is the
-     * bare minimum required to make the cache implementation working.
-     *
-     * Further storage strategies (offline, immutables, etc...) could be provided as
-     * core or community plugins.
-     * @hidden
-     */
-    type Store<T extends {} = any> = {
-      read: StateReader<T>
-      write: StateWriter<T>
-      erase: StateEraser
-    }
-
-    /**
-     * Manually computed type to output a dictionary of { StoreName: Amity.Store<Model> }
-     * with proper typing based on T
-     * @hidden
-     */
-    type StoreCollection<
-      T extends Amity.Domain[],
-    > = {
-      [K in T[number]]: Store<Amity.Model[K]>
-    }
-  }
-}

package/src/client/api/clearCache.ts

@@ -1,23 +0,0 @@
-import { getActiveClient } from './activeClient'
-
-/**
- * ```js
- * import { clearCache } from '@amityco/ts-sdk'
- * clearCache()
- * ```
- *
- * Resets the state of the given {@link Amity.Store} names within
- * the {@link Amity.Cache} object of a {@link Amity.Client} instance
- *
- * @param stores an array of the stores names to be wiped
- *
- * @category Client API
- */
-export const clearCache = (
-  stores: Amity.Domain[] = ['user', 'file', 'channel', 'message', 'community', 'post', 'comment']
-) => {
-  const client = getActiveClient()
-  client.log('client/api/enableCache')
-
-  stores.forEach(store => client.cache?.[store]?.erase())
-}

package/src/client/api/enableCache.ts

@@ -1,36 +0,0 @@
-import { getActiveClient } from './activeClient'
-
-import { createCache } from '~/core/cache'
-import { memoryStores } from '~/core/stores'
-
-/**
- * ```js
- * import { enableCache } from '@amityco/ts-sdk'
- * enableCache()
- * ```
- *
- * Adds a new {@link Amity.Cache} object to an {@link Amity.Client} instance
- *
- * @param stores a partial dictionary of stores to be used for caching
- *
- * @category Client API
- */
-export const enableCache = (
-  stores: Parameters<typeof createCache>[0] = memoryStores(
-    'user',
-    'file',
-    'channel',
-    'message',
-    'community',
-    'post',
-    'comment',
-    'communityUsers',
-    'channelUsers',
-    'stream',
-  ),
-) => {
-  const client = getActiveClient()
-  client.log('client/api/enableCache')
-
-  client.cache = createCache(stores)
-}

package/src/core/cache/drop.ts

@@ -1,24 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient'
-import { getResolver } from '../model/idResolvers'
-
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param keys A collection of unique keys for the store
- * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
- *
- * @category Cache
- */
-export const dropFromCache = <T extends Amity.Domain>(name: T, partial: Amity.Minimal[T] & Partial<Amity.Model[T]>) => {
-  const { cache } = getActiveClient()
-  const store = cache?.[name] as unknown as Amity.Store<Amity.Model[T]>
-
-  if (!cache || !store) return []
-
-  const modelId = getResolver(name)(partial)
-  const localId = cache.lookup[`${name}#${modelId}`]
-
-  delete cache.lookup[`${name}#${modelId}`]
-  store.erase(localId)
-}

package/src/core/cache/index.ts

@@ -1,24 +0,0 @@
-export * from './pull'
-export * from './push'
-export * from './drop'
-export * from './sync'
-export * from './ingest'
-export * from './mutate'
-export * from './merge'
-
-/**
- * Creates a cache instance. The cache instance will handle stores
- * given to it as input, and will be used as the first source of cached data
- * in the SDK.
- *
- * @param stores A partial collection of stores
- * @returns A cache instance
- *
- * @category Cache
- */
-export const createCache = (
-  stores: Partial<Amity.StoreCollection<Amity.Domain[]>>
-): Amity.Cache => {
-  const lookup: Record<string, string> = {}
-  return { lookup, ...stores }
-}

package/src/core/cache/ingest.ts

@@ -1,24 +0,0 @@
-import { pushToCache } from './push'
-
-import { storeInterests } from '../model/idResolvers'
-
-/**
- * Ingest a payload (v3) into the cache
- *
- * @param payload a "backend v3" payload object
- * @param order the order of the keys to process (in case of need)
- *
- * @category Cache
- */
-export const ingestInCache = (
-  payload: Record<string, any[]> = {},
-  order = Object.keys(payload),
-) => {
-  order
-    .forEach(key => {
-      const name = storeInterests[key]
-      if (!name) return
-
-      pushToCache(name, ...payload[key])
-    })
-}

package/src/core/cache/merge.ts

@@ -1,19 +0,0 @@
-import { getResolver } from '../model/idResolvers'
-
-import { mutateCache } from './mutate'
-
-/**
- * Apply partial mutation to objects in the cache
- *
- * @param name The name of the store to query
- * @param mutation A partial view of the object to update
- *
- * @category Cache
- */
-export const mergeInCache = <T extends Amity.Domain>(
-  name: T,
-  mutation: Amity.Minimal[T] & Partial<Amity.Model[T]>
-) => {
-  const key = getResolver(name)(mutation)
-  mutateCache(name, key, model => ({ ...model, ...mutation }))
-}