@amityco/ts-sdk 0.0.1-beta.30 → 0.0.1-beta.31

package/dist/index.cjs.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var jsBase64 = require('js-base64');
-var mitt = require('mitt');
 var AsyncStorage = require('@react-native-async-storage/async-storage');
+var mitt = require('mitt');
 var debug = require('debug');
 var axios = require('axios');
 var HttpAgent = require('agentkeepalive');
@@ -13,8 +13,8 @@ var nativeIdGenerator = require('react-native-uuid');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
 var AsyncStorage__default = /*#__PURE__*/_interopDefaultLegacy(AsyncStorage);
+var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
 var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var HttpAgent__default = /*#__PURE__*/_interopDefaultLegacy(HttpAgent);
@@ -75,6 +75,24 @@ const VideoSize = Object.freeze({
     ORIGINAL: 'original',
 });
 
+const MessageContentType = Object.freeze({
+    TEXT: 'text',
+    IMAGE: 'image',
+    FILE: 'file',
+    VIDEO: 'video',
+    AUDIO: 'audio',
+    CUSTOM: 'custom',
+});
+
+const PostContentType = Object.freeze({
+    TEXT: 'text',
+    IMAGE: 'image',
+    FILE: 'file',
+    VIDEO: 'video',
+    LIVESTREAM: 'liveStream',
+    POLL: 'poll',
+});
+
 var _a$1;
 /* eslint-disable no-undef */
 const theGlobal = 
@@ -350,6 +368,78 @@ const PAYLOAD2MODEL = {
     followCounts: 'followCount',
 };
 
+// cache constants
+const CACHE_KEY_GET = 'get';
+const CACHE_KEY_TOMBSTONE = 'dead';
+const CACHE_LIFESPAN = 1 * 60 * 1000; // 1 minute
+const CACHE_LIFESPAN_TOMBSTONE = 3 * 60 * 1000; // 3 minutes
+/**
+ * Shallow-clones an object and sort its keys
+ *
+ * @param source a plain object to clone
+ * @returns a clone of source, with keys sorted with default javascript sorting
+ *
+ * @category Cache
+ * @hidden
+ */
+const normalize = (source) => Object.keys(source)
+    .sort()
+    .reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: source[key] })), {});
+/**
+ * Encodes a given {@link Amity.CacheKey} to a plain string
+ *
+ * @param key the key to encode
+ * @returns an encoded string
+ *
+ * @category Cache
+ * @hidden
+ */
+const encodeKey = (key) => JSON.stringify(key, (_, val) => (typeof val === 'object' ? normalize(val) : val));
+/**
+ * Decodes a string back into a {@link Amity.CacheKey}
+
+ *
+ * @param key the string key to decode
+ * @returns a plain Amity.CacheKey object.
+ *
+ * @category Cache
+ * @hidden
+ */
+const decodeKey = (key) => JSON.parse(key);
+/**
+ * Performs a recursive partial deep equal check on two objects.
+ *
+ * @param predicate the reference object containing the partial information
+ * @param candidate the object to check against
+ * @returns true if the candidate contains all the values of the predicate
+ *
+ * @category Cache
+ */
+const partialMatch = (predicate, candidate) => {
+    if (predicate === candidate)
+        return true;
+    // if one or the other is nullish, there can't be equality
+    if (!predicate || !candidate)
+        return false;
+    // we only perform recursive check on objects
+    if (typeof predicate !== 'object') {
+        return false;
+    }
+    // recursively call for partial match based on the predicate
+    return Object.keys(predicate).every(key => partialMatch(predicate[key], candidate[key]));
+};
+/**
+ * checks if passed error code is included in
+ * Tombstone errors list
+ *
+ * @param errorCode as {@link Amity.ServerError}
+ * @returns success boolean if the given errorCode
+ * is included in Tombstone errors list
+ *
+ * @category Cache
+ */
+const checkIfShouldGoesToTombstone = (errorCode) => [400400 /* Amity.ServerError.ITEM_NOT_FOUND */, 400300 /* Amity.ServerError.FORBIDDEN */].includes(errorCode);
+
 /* eslint-disable no-use-before-define */
 /**
  * Type guard to check and cast that a given async function is has the ".locally" property
@@ -408,7 +498,7 @@ const isLocal = (model) => {
  *
  * @hidden
  */
-const isFresh = (model, lifeSpan = 0) => {
+const isFresh = (model, lifeSpan = CACHE_LIFESPAN) => {
     var _a;
     return Date.now() - ((_a = model === null || model === void 0 ? void 0 : model.cachedAt) !== null && _a !== void 0 ? _a : 0) <= lifeSpan;
 };
@@ -442,12 +532,10 @@ const createQuery = (func, ...args) => ({ func, args });
  *
  * @category Query
  */
-const queryOptions = (policy, lifeSpan = 2 * 60 * 1000) => {
+const queryOptions = (policy, lifeSpan = CACHE_LIFESPAN) => {
     if (policy === 'cache_only')
         return { lifeSpan: Infinity };
-    if (policy === 'server_only')
-        return { lifeSpan: 0 };
-    return { lifeSpan };
+    return { lifeSpan: lifeSpan < CACHE_LIFESPAN ? CACHE_LIFESPAN : lifeSpan };
 };
 /**
  * ```js
@@ -468,8 +556,9 @@ const queryOptions = (policy, lifeSpan = 2 * 60 * 1000) => {
  */
 const runQuery = ({ func, args }, callback, options = queryOptions('cache_then_server')) => {
     let local;
+    const { lifeSpan } = queryOptions('cache_then_server', options.lifeSpan);
     // offline first
-    if (isOffline(func) && options.lifeSpan !== 0) {
+    if (isOffline(func)) {
         try {
             local = isMutator(func) ? func.optimistically(...args) : func.locally(...args);
         }
@@ -480,7 +569,7 @@ const runQuery = ({ func, args }, callback, options = queryOptions('cache_then_s
                 error,
             }));
         }
-        const shouldAbort = isCachable(local) && isFresh(local, options.lifeSpan);
+        const shouldAbort = isCachable(local) && isFresh(local, lifeSpan);
         callback === null || callback === void 0 ? void 0 : callback(createSnapshot(local, {
             origin: 'local',
             loading: !(isFetcher(func) && shouldAbort),
@@ -547,54 +636,6 @@ function createSnapshot(data, options) {
     return Object.assign(Object.assign({}, options), { data });
 }
 
-// Note:
-// this file should contain a suite of filtering utilities to help the
-// local version of the query functions.
-/**
- * Filter a given collection with strict equality against a param
- *
- * @param collection the collection to filter
- * @param key the key of the collection's items to challenge
- * @param value the expected value
- * @returns a filtered collection with items only matching the criteria
- *
- * @hidden
- */
-const filterByPropEquality = (collection, key, value) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);
-const filterByPropInclusion = (collection, key, value) => (value !== undefined ? collection.filter(item => value.includes(item[key])) : collection);
-
-// Note:
-// this file should contain a suite of sorting utilities to help the
-// local version of the query functions.
-/**
- * Alphabetic sorting of objects having a displayName
- */
-const sortByDisplayName = ({ displayName: a }, { displayName: b }) => {
-    if (a === b)
-        return 0;
-    return a < b ? -1 : 1;
-};
-/**
- * Sorting a collection by their apparition order (oldest first)
- */
-const sortByChannelSegment = ({ channelSegment: a }, { channelSegment: b }) => a - b;
-/**
- * Sorting a collection by their apparition order (oldest first)
- */
-const sortBySegmentNumber = ({ segmentNumber: a }, { segmentNumber: b }) => a - b;
-/**
- * Sorting a collection by its oldest items
- */
-const sortByFirstCreated = ({ createdAt: a }, { createdAt: b }) => new Date(a).valueOf() - new Date(b).valueOf();
-/**
- * Sorting a collection by its newest items
- */
-const sortByLastCreated = ({ createdAt: a }, { createdAt: b }) => new Date(b).valueOf() - new Date(a).valueOf();
-/**
- * Sorting a collection by the items with most recent activity
- */
-const sortByLastActivity = ({ lastActivity: a }, { lastActivity: b }) => new Date(b).valueOf() - new Date(a).valueOf();
-
 /* eslint-disable max-classes-per-file */
 /**
  * Generic ASC error
@@ -684,265 +725,70 @@ const setActiveClient = (client) => {
     activeClient = client;
 };
 
-/* eslint-disable @typescript-eslint/ban-types */
-let tasks = [];
-let timer;
 /**
- * Add a function to run just before the next tick
+ * ```js
+ * import { enableCache } from '@amityco/ts-sdk'
+ * enableCache()
+ * ```
  *
- * @param task function to schedule for later execution
+ * Adds a new {@link Amity.Cache} object to
+ * an {@link Amity.Client} instance
+ *
+ * @param prevState a previous state of cache instance (useful for SSR)
+ * @param persistIf a function to determine if an entry inserted in cache
+ * is destined to be also saved in the persistent storage when
+ * calling {@link backupCache}
+ *
+ * @category Cache API
  */
-const scheduleTask = (task) => {
-    clearTimeout(timer);
-    tasks.push(task);
-    timer = setTimeout(() => {
-        tasks.forEach(fn => fn());
-        tasks = [];
-    }, 0);
+const enableCache = (prevState = {}, persistIf) => {
+    const client = getActiveClient();
+    if (client.cache)
+        return;
+    client.log('cache/api/enableCache');
+    client.cache = { data: prevState, persistIf };
 };
 
-/* eslint-disable @typescript-eslint/no-unused-vars */
-// need to sync up the list
-const WS_EVENTS = [
-    'disconnected',
-    'error',
-    'connect_error',
-    'reconnect_error',
-    'reconnect_failed',
-    'v3.channel.didCreate',
-    'v3.channel.didUpdate',
-    'v3.channel.didDelete',
-    'v3.channel.didJoin',
-    'v3.channel.didLeave',
-    'v3.channel.didAddUsers',
-    'v3.channel.didRemoveUsers',
-    'v3.channel.didBan',
-    'v3.channel.didUnban',
-    'v3.message.didCreate',
-    'v3.message.didUpdate',
-    'v3.message.didDelete',
-];
-const MQTT_EVENTS = [
-    'connect',
-    'message',
-    'disconnect',
-    'error',
-    'close',
-    'end',
-    'reconnect',
-];
-/** @hidden */
-const createEventEmitter = () => {
-    return mitt__default["default"]();
-};
 /**
- * Wraps the websocket events into the client's event emitter for
- * abstraction of transport.
+ * ```js
+ * import { disableCache } from '@amityco/ts-sdk'
+ * disableCache()
+ * ```
  *
- * @param ws A websocket connection to listen from
- * @param emitter An event emitter to wire the events to
+ * Wipes the existing {@link Amity.Cache} object attached to
+ * an {@link Amity.Client} instance
  *
- * @category Transport
- * @hidden
+ * @category Cache API
  */
-const proxyWebsocketEvents = (ws, emitter) => {
-    WS_EVENTS.forEach(event => {
-        ws.on(event, (param) => emitter.emit(event, param));
-    });
-};
-const proxyMqttEvents = (mqttClient, emitter) => {
-    MQTT_EVENTS.forEach(event => {
-        mqttClient.on(event, (...params) => emitter.emit(event, params.length === 1 ? params[0] : params));
-    });
-    // @ts-ignore
-    mqttClient.on('message', (topic, payload) => {
-        const message = JSON.parse(payload.toString());
-        emitter.emit(message.eventType, message.data);
-    });
-};
+const disableCache = () => {
+    const client = getActiveClient();
+    if (!client.cache)
+        return;
+    client.log('cache/api/disableCache');
+    // we do this so that testing if cache is enabled
+    // is only `if (client.cache)
+    delete client.cache;
+};
+
 /**
- * Standardize the subscription of SSE through web sockets
+ * ```js
+ * import { restoreCache } from '@amityco/ts-sdk'
+ * const success = await restoreCache()
+ * ```
  *
- * @param client The current client for which to subscribe the event to
- * @param namespace A unique name for the logger
- * @param event The websocket event name
- * @param fn A wrapper for the callback.
- * @returns A dispose function to unsubscribe to the event
+ * Reads a previously saved {@link Amity.Cache} from a persistent storage,
+ * and inserts it into the current {@link Amity.Cache} instance.
  *
- * @category Transport
- * @hidden
- */
-const createEventSubscriber = (client, namespace, event, fn) => {
-    const { log, emitter } = client;
-    const timestamp = Date.now();
-    log(`${namespace}(tmpid: ${timestamp}) > listen`);
-    const handler = (...payload) => {
-        log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload);
-        fn(...payload);
-    };
-    emitter.on(event, handler);
-    return () => {
-        log(`${namespace}(tmpid: ${timestamp}) > dispose`);
-        emitter.off(event, handler);
-    };
-};
-/**
- * Wrapper around dispatch event
- *
- * @hidden
- */
-const fireEvent = (event, payload) => {
-    const { emitter } = getActiveClient();
-    scheduleTask(() => {
-        emitter.emit(event, payload);
-    });
-};
-
-let activeUser = null;
-/**
- * for internal use
- */
-const getActiveUser = () => {
-    if (!activeUser) {
-        throw new ASCError('Connect client first', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "fatal" /* Amity.ErrorLevel.FATAL */);
-    }
-    return activeUser;
-};
-const setActiveUser = (user) => {
-    activeUser = {
-        _id: user._id,
-        userId: user.userId,
-        path: user.path,
-    };
-};
-
-exports.SubscriptionLevels = void 0;
-(function (SubscriptionLevels) {
-    SubscriptionLevels["COMMUNITY"] = "community";
-    SubscriptionLevels["POST"] = "post";
-    SubscriptionLevels["COMMENT"] = "comment";
-    SubscriptionLevels["POST_AND_COMMENT"] = "post_and_comment";
-    SubscriptionLevels["USER"] = "user";
-})(exports.SubscriptionLevels || (exports.SubscriptionLevels = {}));
-const getCommunityUserTopic = (path, level) => {
-    switch (level) {
-        case 'post':
-            return `${path}/post/+`;
-        case 'comment':
-            return `${path}/post/+/comment/+`;
-        case 'post_and_comment':
-            return `${path}/post/#`;
-        default:
-            return path;
-    }
-};
-const getCommunityTopic = ({ path }, level = exports.SubscriptionLevels.COMMUNITY) => getCommunityUserTopic(path, level);
-const getUserTopic = ({ path }, level = exports.SubscriptionLevels.USER) => getCommunityUserTopic(level === exports.SubscriptionLevels.USER ? path : path.replace(/^(\w*)/, '$1/social'), level);
-const getPostTopic = ({ path }, level = exports.SubscriptionLevels.POST) => {
-    switch (level) {
-        case 'comment':
-            return `${path}/comment/+`;
-        default:
-            return path;
-    }
-};
-const getCommentTopic = ({ path }) => {
-    return path;
-};
-const getMyFollowersTopic = () => {
-    const user = getActiveUser();
-    const [networkId] = user.path.split('/user/');
-    return `${networkId}/membership/${user._id}/+/+`;
-};
-const getMyFollowingsTopic = () => {
-    const user = getActiveUser();
-    const [networkId] = user.path.split('/user/');
-    return `${networkId}/membership/+/${user._id}/+`;
-};
-/** @hidden */
-const getNetworkTopic = () => {
-    const user = getActiveUser();
-    const [networkId] = user.path.split('/user/');
-    return networkId;
-};
-let mqttAccessToken;
-let mqttUserId;
-function subscribeTopic(topic, callback) {
-    const { mqtt, emitter, accessToken } = getActiveClient();
-    const user = getActiveUser();
-    if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
-        mqttAccessToken = accessToken;
-        mqttUserId = user._id;
-        mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId });
-        proxyMqttEvents(mqtt, emitter);
-    }
-    return mqtt.subscribe(topic, callback);
-}
-
-/**
- * ```js
- * import { enableCache } from '@amityco/ts-sdk'
- * enableCache()
- * ```
- *
- * Adds a new {@link Amity.Cache} object to
- * an {@link Amity.Client} instance
- *
- * @param prevState a previous state of cache instance (useful for SSR)
- * @param persistIf a function to determine if an entry inserted in cache
- * is destined to be also saved in the persistent storage when
- * calling {@link backupCache}
- *
- * @category Cache API
- */
-const enableCache = (prevState = {}, persistIf) => {
-    const client = getActiveClient();
-    if (client.cache)
-        return;
-    client.log('cache/api/enableCache');
-    client.cache = { data: prevState, persistIf };
-};
-
-/**
- * ```js
- * import { disableCache } from '@amityco/ts-sdk'
- * disableCache()
- * ```
- *
- * Wipes the existing {@link Amity.Cache} object attached to
- * an {@link Amity.Client} instance
- *
- * @category Cache API
- */
-const disableCache = () => {
-    const client = getActiveClient();
-    if (!client.cache)
-        return;
-    client.log('cache/api/disableCache');
-    // we do this so that testing if cache is enabled
-    // is only `if (client.cache)
-    delete client.cache;
-};
-
-/**
- * ```js
- * import { restoreCache } from '@amityco/ts-sdk'
- * const success = await restoreCache()
- * ```
- *
- * Reads a previously saved {@link Amity.Cache} from a persistent storage,
- * and inserts it into the current {@link Amity.Cache} instance.
- *
- * The strategy for persistent storage will depend on the runtime,
- * which is supported by @react-native-async-storage/async-storage.
- *
- * The current userId will be appended to the given storageKey to ensures
- * the cached data concerns only the current user.
- *
- * @param storageKey the name of the persistent storage
- * @returns a success boolean if the cache was dumped to persistent storage
- *
- * @category Cache API
+ * The strategy for persistent storage will depend on the runtime,
+ * which is supported by @react-native-async-storage/async-storage.
+ *
+ * The current userId will be appended to the given storageKey to ensures
+ * the cached data concerns only the current user.
+ *
+ * @param storageKey the name of the persistent storage
+ * @returns a success boolean if the cache was dumped to persistent storage
+ *
+ * @category Cache API
  */
 const restoreCache = async (storageKey = 'amitySdk') => {
     var _a;
@@ -1030,62 +876,6 @@ const wipeCache = async (storageKey = 'amitySdk') => {
     return true;
 };
 
-/**
- * Shallow-clones an object and sort its keys
- *
- * @param source a plain object to clone
- * @returns a clone of source, with keys sorted with default javascript sorting
- *
- * @category Cache
- * @hidden
- */
-const normalize = (source) => Object.keys(source)
-    .sort()
-    .reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: source[key] })), {});
-/**
- * Encodes a given {@link Amity.CacheKey} to a plain string
- *
- * @param key the key to encode
- * @returns an encoded string
- *
- * @category Cache
- * @hidden
- */
-const encodeKey = (key) => JSON.stringify(key, (_, val) => (typeof val === 'object' ? normalize(val) : val));
-/**
- * Decodes a string back into a {@link Amity.CacheKey}
-
- *
- * @param key the string key to decode
- * @returns a plain Amity.CacheKey object.
- *
- * @category Cache
- * @hidden
- */
-const decodeKey = (key) => JSON.parse(key);
-/**
- * Performs a recursive partial deep equal check on two objects.
- *
- * @param predicate the reference object containing the partial information
- * @param candidate the object to check against
- * @returns true if the candidate contains all the values of the predicate
- *
- * @category Cache
- */
-const partialMatch = (predicate, candidate) => {
-    if (predicate === candidate)
-        return true;
-    // if one or the other is nullish, there can't be equality
-    if (!predicate || !candidate)
-        return false;
-    // we only perform recursive check on objects
-    if (typeof predicate !== 'object') {
-        return false;
-    }
-    // recursively call for partial match based on the predicate
-    return Object.keys(predicate).every(key => partialMatch(predicate[key], candidate[key]));
-};
-
 /**
  * ```js
  * import { queryCache } from '@amityco/ts-sdk'
@@ -1182,86 +972,368 @@ const pushToCache = (key, data, options = { cachedAt: Date.now() }) => {
  *
  * Merges a new {@link Amity.Cache} object to an {@link Amity.Client} instance
  *
- * @param key the key matching the object to retrieve from cache
- * @param mutation either a plain object to shallow merge, or a function.
- * @returns a success boolean if the object was updated
+ * @param key the key matching the object to retrieve from cache
+ * @param mutation either a plain object to shallow merge, or a function.
+ * @returns a success boolean if the object was updated
+ *
+ * @category Cache API
+ */
+const mergeInCache = (key, mutation, options) => {
+    const { log, cache } = getActiveClient();
+    if (!cache)
+        return false;
+    log('cache/api/mergeInCache', { key, mutation });
+    const oldVal = pullFromCache(key);
+    if (!oldVal)
+        return false;
+    const newVal = typeof mutation === 'function' ? mutation(oldVal.data) : Object.assign(Object.assign({}, oldVal.data), mutation);
+    pushToCache(key, newVal, options);
+    return true;
+};
+
+/**
+ * ```js
+ * import { upsertInCache } from '@amityco/ts-sdk'
+ * upsertInCache<Amity.User>(["user", "foobar"], user)
+ * ```
+ *
+ * Insert or update any provided value as {@link Amity.CacheEntry} for
+ * the matching {@link Amity.CacheKey}
+ *
+ * @param key the key to save the object to
+ * @param data the object to save
+ * @param options customisation object around cache behavior (default gives a 2mn lifespan)
+ * @returns a success boolean if the object was saved in cache
+ *
+ * @category Cache API
+ * @hidden
+ */
+const upsertInCache = (key, data, options = { cachedAt: Date.now() }) => {
+    const { log, cache } = getActiveClient();
+    if (!cache)
+        return false;
+    log('cache/api/upsertInCache', { key, data, options });
+    const cached = pullFromCache(key);
+    return cached ? mergeInCache(key, data, options) : pushToCache(key, data, options);
+};
+
+/**
+ * ```js
+ * import { dropFromCache } from '@amityco/ts-sdk'
+ * const success = dropFromCache(['user', 'foobar'])
+ * ```
+ *
+ * Removes an existing {@link Amity.CacheEntry} from the {@link Amity.Client}'s
+ * {@link Amity.Cache} from a given {@link Amity.CacheKey}
+ *
+ * @param key The key of the object to delete
+ * @param exact If false, the function will delete all keys satisfying the given key
+ * @returns A success boolean if the object was deleted
+ *
+ * @category Cache API
+ */
+const dropFromCache = (key, exact = false) => {
+    const { log, cache } = getActiveClient();
+    if (!cache)
+        return false;
+    log('cache/api/dropFromCache', { key, exact });
+    if (!exact) {
+        return Object.keys(cache.data)
+            .map(stringKey => decodeKey(stringKey))
+            .filter(candidate => partialMatch(key, candidate))
+            .map(filteredKey => dropFromCache(filteredKey, true))
+            .every(returned => returned);
+    }
+    const encodedKey = encodeKey(key);
+    if (encodedKey in cache.data) {
+        delete cache.data[encodedKey];
+        return true;
+    }
+    return false;
+};
+
+// Note:
+// this file should contain a suite of filtering utilities to help the
+// local version of the query functions.
+/**
+ * Filter a given collection with strict equality against a param
+ *
+ * @param collection the collection to filter
+ * @param key the key of the collection's items to challenge
+ * @param value the expected value
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+const filterByPropEquality = (collection, key, value) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);
+const filterByPropInclusion = (collection, key, value) => (value !== undefined ? collection.filter(item => value.includes(item[key])) : collection);
+/**
+ * Filter a channel collection by membership of the userId
+ *
+ * @param collection the channel collection to filter
+ * @param membership the membership to be filtered by
+ * @param userId user id to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+const filterByChannelMembership = (collection, membership, userId) => {
+    if (membership === 'all') {
+        return collection;
+    }
+    return collection.filter(c => {
+        var _a;
+        // get resolver for the channel by user
+        const channelUserCacheKey = getResolver('channelUsers')({
+            channelId: c.channelId,
+            userId,
+        });
+        const channelUser = (_a = pullFromCache([
+            'channelUsers',
+            'get',
+            channelUserCacheKey,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        // if channel user is defined for user, user is a member
+        if (membership === 'member' && channelUser) {
+            return true;
+        }
+        // if channel user by user id not found, user is not a member of that
+        // channel
+        if (membership === 'notMember' && !channelUser) {
+            return true;
+        }
+        return false;
+    });
+};
+
+// Note:
+// this file should contain a suite of sorting utilities to help the
+// local version of the query functions.
+/**
+ * Alphabetic sorting of objects having a displayName
+ */
+const sortByDisplayName = ({ displayName: a }, { displayName: b }) => {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+};
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+const sortByChannelSegment = ({ channelSegment: a }, { channelSegment: b }) => a - b;
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+const sortBySegmentNumber = ({ segmentNumber: a }, { segmentNumber: b }) => a - b;
+/**
+ * Sorting a collection by its oldest items
+ */
+const sortByFirstCreated = ({ createdAt: a }, { createdAt: b }) => new Date(a).valueOf() - new Date(b).valueOf();
+/**
+ * Sorting a collection by its newest items
+ */
+const sortByLastCreated = ({ createdAt: a }, { createdAt: b }) => new Date(b).valueOf() - new Date(a).valueOf();
+/**
+ * Sorting a collection by the items with most recent activity
+ */
+const sortByLastActivity = ({ lastActivity: a }, { lastActivity: b }) => new Date(b).valueOf() - new Date(a).valueOf();
+
+/* eslint-disable @typescript-eslint/ban-types */
+let tasks = [];
+let timer;
+/**
+ * Add a function to run just before the next tick
+ *
+ * @param task function to schedule for later execution
+ */
+const scheduleTask = (task) => {
+    clearTimeout(timer);
+    tasks.push(task);
+    timer = setTimeout(() => {
+        tasks.forEach(fn => fn());
+        tasks = [];
+    }, 0);
+};
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// need to sync up the list
+const WS_EVENTS = [
+    'disconnected',
+    'error',
+    'connect_error',
+    'reconnect_error',
+    'reconnect_failed',
+    'v3.channel.didCreate',
+    'v3.channel.didUpdate',
+    'v3.channel.didDelete',
+    'v3.channel.didJoin',
+    'v3.channel.didLeave',
+    'v3.channel.didAddUsers',
+    'v3.channel.didRemoveUsers',
+    'v3.channel.didBan',
+    'v3.channel.didUnban',
+    'v3.message.didFetch',
+    'v3.message.didCreate',
+    'v3.message.didUpdate',
+    'v3.message.didDelete',
+];
+const MQTT_EVENTS = [
+    'connect',
+    'message',
+    'disconnect',
+    'error',
+    'close',
+    'end',
+    'reconnect',
+];
+/** @hidden */
+const createEventEmitter = () => {
+    return mitt__default["default"]();
+};
+/**
+ * Wraps the websocket events into the client's event emitter for
+ * abstraction of transport.
+ *
+ * @param ws A websocket connection to listen from
+ * @param emitter An event emitter to wire the events to
+ *
+ * @category Transport
+ * @hidden
+ */
+const proxyWebsocketEvents = (ws, emitter) => {
+    WS_EVENTS.forEach(event => {
+        ws.on(event, (param) => emitter.emit(event, param));
+    });
+};
+const proxyMqttEvents = (mqttClient, emitter) => {
+    MQTT_EVENTS.forEach(event => {
+        mqttClient.on(event, (...params) => emitter.emit(event, params.length === 1 ? params[0] : params));
+    });
+    // @ts-ignore
+    mqttClient.on('message', (topic, payload) => {
+        const message = JSON.parse(payload.toString());
+        emitter.emit(message.eventType, message.data);
+    });
+};
+/**
+ * Standardize the subscription of SSE through web sockets
+ *
+ * @param client The current client for which to subscribe the event to
+ * @param namespace A unique name for the logger
+ * @param event The websocket event name
+ * @param fn A wrapper for the callback.
+ * @returns A dispose function to unsubscribe to the event
  *
- * @category Cache API
+ * @category Transport
+ * @hidden
  */
-const mergeInCache = (key, mutation, options) => {
-    const { log, cache } = getActiveClient();
-    if (!cache)
-        return false;
-    log('cache/api/mergeInCache', { key, mutation });
-    const oldVal = pullFromCache(key);
-    if (!oldVal)
-        return false;
-    const newVal = typeof mutation === 'function' ? mutation(oldVal.data) : Object.assign(Object.assign({}, oldVal.data), mutation);
-    pushToCache(key, newVal, options);
-    return true;
-};
-
+const createEventSubscriber = (client, namespace, event, fn) => {
+    const { log, emitter } = client;
+    const timestamp = Date.now();
+    log(`${namespace}(tmpid: ${timestamp}) > listen`);
+    const handler = (...payload) => {
+        log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload);
+        fn(...payload);
+    };
+    emitter.on(event, handler);
+    return () => {
+        log(`${namespace}(tmpid: ${timestamp}) > dispose`);
+        emitter.off(event, handler);
+    };
+};
 /**
- * ```js
- * import { upsertInCache } from '@amityco/ts-sdk'
- * upsertInCache<Amity.User>(["user", "foobar"], user)
- * ```
- *
- * Insert or update any provided value as {@link Amity.CacheEntry} for
- * the matching {@link Amity.CacheKey}
- *
- * @param key the key to save the object to
- * @param data the object to save
- * @param options customisation object around cache behavior (default gives a 2mn lifespan)
- * @returns a success boolean if the object was saved in cache
+ * Wrapper around dispatch event
  *
- * @category Cache API
  * @hidden
  */
-const upsertInCache = (key, data, options = { cachedAt: Date.now() }) => {
-    const { log, cache } = getActiveClient();
-    if (!cache)
-        return false;
-    log('cache/api/upsertInCache', { key, data, options });
-    const cached = pullFromCache(key);
-    return cached ? mergeInCache(key, data, options) : pushToCache(key, data, options);
+const fireEvent = (event, payload) => {
+    const { emitter } = getActiveClient();
+    scheduleTask(() => {
+        emitter.emit(event, payload);
+    });
 };
 
+let activeUser = null;
 /**
- * ```js
- * import { dropFromCache } from '@amityco/ts-sdk'
- * const success = dropFromCache(['user', 'foobar'])
- * ```
- *
- * Removes an existing {@link Amity.CacheEntry} from the {@link Amity.Client}'s
- * {@link Amity.Cache} from a given {@link Amity.CacheKey}
- *
- * @param key The key of the object to delete
- * @param exact If false, the function will delete all keys satisfying the given key
- * @returns A success boolean if the object was deleted
- *
- * @category Cache API
+ * for internal use
  */
-const dropFromCache = (key, exact = false) => {
-    const { log, cache } = getActiveClient();
-    if (!cache)
-        return false;
-    log('cache/api/dropFromCache', { key, exact });
-    if (!exact) {
-        return Object.keys(cache.data)
-            .map(stringKey => decodeKey(stringKey))
-            .filter(candidate => partialMatch(key, candidate))
-            .map(filteredKey => dropFromCache(filteredKey, true))
-            .every(returned => returned);
-    }
-    const encodedKey = encodeKey(key);
-    if (encodedKey in cache.data) {
-        delete cache.data[encodedKey];
-        return true;
+const getActiveUser = () => {
+    if (!activeUser) {
+        throw new ASCError('Connect client first', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "fatal" /* Amity.ErrorLevel.FATAL */);
     }
-    return false;
+    return activeUser;
+};
+const setActiveUser = (user) => {
+    activeUser = {
+        _id: user._id,
+        userId: user.userId,
+        path: user.path,
+    };
 };
 
+exports.SubscriptionLevels = void 0;
+(function (SubscriptionLevels) {
+    SubscriptionLevels["COMMUNITY"] = "community";
+    SubscriptionLevels["POST"] = "post";
+    SubscriptionLevels["COMMENT"] = "comment";
+    SubscriptionLevels["POST_AND_COMMENT"] = "post_and_comment";
+    SubscriptionLevels["USER"] = "user";
+})(exports.SubscriptionLevels || (exports.SubscriptionLevels = {}));
+const getCommunityUserTopic = (path, level) => {
+    switch (level) {
+        case 'post':
+            return `${path}/post/+`;
+        case 'comment':
+            return `${path}/post/+/comment/+`;
+        case 'post_and_comment':
+            return `${path}/post/#`;
+        default:
+            return path;
+    }
+};
+const getCommunityTopic = ({ path }, level = exports.SubscriptionLevels.COMMUNITY) => getCommunityUserTopic(path, level);
+const getUserTopic = ({ path }, level = exports.SubscriptionLevels.USER) => getCommunityUserTopic(level === exports.SubscriptionLevels.USER ? path : path.replace(/^(\w*)/, '$1/social'), level);
+const getPostTopic = ({ path }, level = exports.SubscriptionLevels.POST) => {
+    switch (level) {
+        case 'comment':
+            return `${path}/comment/+`;
+        default:
+            return path;
+    }
+};
+const getCommentTopic = ({ path }) => {
+    return path;
+};
+const getMyFollowersTopic = () => {
+    const user = getActiveUser();
+    const [networkId] = user.path.split('/user/');
+    return `${networkId}/membership/${user._id}/+/+`;
+};
+const getMyFollowingsTopic = () => {
+    const user = getActiveUser();
+    const [networkId] = user.path.split('/user/');
+    return `${networkId}/membership/+/${user._id}/+`;
+};
+/** @hidden */
+const getNetworkTopic = () => {
+    const user = getActiveUser();
+    const [networkId] = user.path.split('/user/');
+    return networkId;
+};
+let mqttAccessToken;
+let mqttUserId;
+function subscribeTopic(topic, callback) {
+    const { mqtt, emitter, accessToken } = getActiveClient();
+    const user = getActiveUser();
+    if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
+        mqttAccessToken = accessToken;
+        mqttUserId = user._id;
+        mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId });
+        proxyMqttEvents(mqtt, emitter);
+    }
+    return mqtt.subscribe(topic, callback);
+}
+
 /**
  * Creates a pre-configured logger instance
  *
@@ -20578,6 +20650,61 @@ const isConnected = () => {
         client.ws.connected);
 };
 
+/**
+ * ```js
+ * import { isInTombstone } from '@amityco/ts-sdk'
+ * const user = isInTombstone(["message", "messageId"])
+ * ```
+ *
+ * Checks if the {@link Amity.TombstoneCacheOptions} exists
+ * in cache and it's not expired means it's in tombstone
+ * and we throw an Error
+ *
+ * @param model the model to check
+ * @param modelId the object id to check
+ * @returns the matching cache entry, or undefined.
+ *
+ * @category Cache API
+ */
+const isInTombstone = (model, modelId) => {
+    const { log, cache } = getActiveClient();
+    const key = [model, CACHE_KEY_TOMBSTONE, modelId];
+    if (!cache)
+        return;
+    log('cache/api/isInTombstone', key);
+    const isInTombstone = pullFromCache(key);
+    const { lifeSpan } = queryOptions('cache_then_server', CACHE_LIFESPAN_TOMBSTONE);
+    if (isInTombstone && isFresh(isInTombstone.data, lifeSpan)) {
+        throw new ASCApiError('Item not found!', 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+};
+
+/**
+ * ```js
+ * import { pushToTombstone } from '@amityco/ts-sdk'
+ * pushToTombstone(["message", "messageId"], { cachedAt: Date.now() })
+ * ```
+ *
+ * Removes an existing {@link Amity.CacheEntry} from the {@link Amity.Client}'s
+ * {@link Amity.Cache} from a given {@link Amity.CacheKey}
+ *
+ * @param model the model to remove and push to Tombstone
+ * @param modelId the related model id
+ *
+ * @category Cache API
+ * @hidden
+ */
+const pushToTombstone = (model, modelId) => {
+    const { log, cache } = getActiveClient();
+    const cacheKey = [model, CACHE_KEY_TOMBSTONE, modelId];
+    const data = { cachedAt: Date.now() };
+    if (!cache)
+        return;
+    log('cache/api/pushToTombstone', { cacheKey, data });
+    dropFromCache([model, CACHE_KEY_GET, modelId], true);
+    pushToCache(cacheKey, data);
+};
+
 /**
  * ```js
  * import { getUser } from '@amityco/ts-sdk'
@@ -20592,15 +20719,30 @@ const isConnected = () => {
  * @category User API
  * @async
  */
-const getUser = async (userId) => {
+const getUser = async (userId, isLive = false) => {
     const client = getActiveClient();
     client.log('user/getUser', userId);
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/users/${encodeURIComponent(userId)}`);
+    if (!isLive) {
+        console.log('getUser will be deprecated on 25th November 2022, please use liveUser instead.');
+    }
+    isInTombstone('user', userId);
+    let data;
+    try {
+        // API-FIX: endpoint should not be /list, parameters should be querystring.
+        const response = await client.http.get(`/api/v3/users/${encodeURIComponent(userId)}`);
+        data = response.data;
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('user', userId);
+        }
+        throw error;
+    }
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { users } = data;
+    fireEvent('user.fetched', data);
     return {
         data: users.find(user => user.userId === userId),
         cachedAt,
@@ -20650,6 +20792,7 @@ const getUsers = async (userIds) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
+    fireEvent('user.fetched', data);
     return {
         data: data.users,
         cachedAt,
@@ -20749,6 +20892,7 @@ const queryUsers = async (query = {}) => {
         const cacheKey = ['user', 'query', query];
         pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
     }
+    fireEvent('user.fetched', data);
     const prevPage = toPage(paging.previous);
     const nextPage = toPage(paging.next);
     return { data: users, cachedAt, prevPage, nextPage };
@@ -20812,12 +20956,30 @@ const updateUser = async (userId, patch) => {
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { users } = data;
+    fireEvent('user.updated', data);
     return {
         data: users.find(user => user.userId === userId),
         cachedAt,
     };
 };
 
+/**
+ * ```js
+ * import { onUserFetched } from '@amityco/ts-sdk'
+ * const dispose = onUserFetched(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+const onUserFetched = (callback) => createUserEventSubscriber('user.fetched', callback);
+
 /**
  * ```js
  * import { onUserUpdated } from '@amityco/ts-sdk'
@@ -20886,6 +21048,68 @@ const onUserUnflagged = (callback) => createUserEventSubscriber('user.unflagged'
  */
 const onUserFlagCleared = (callback) => createUserEventSubscriber('user.flagCleared', callback);
 
+const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+const COLLECTION_DEFAULT_CACHING_POLICY = 'cache_then_server';
+const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
+const LIVE_OBJECT_ENABLE_CACHE_MESSAGE = 'For using Live Object feature you need to enable Cache!';
+const UNSYNCED_OBJECT_CACHED_AT_MESSAGE = 'Observing unsynced object is not supported by Live Object.';
+const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
+
+/**
+ * ```js
+ * import { liveUser } from '@amityco/ts-sdk'
+ *
+ * let users = []
+ * const unsub = liveUser(userId, response => merge(users, response.data))
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.User}
+ *
+ * @param userId the ID of the user to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the users
+ *
+ * @category Message Live Object
+ */
+const liveUser = (userId, callback) => {
+    const { log, cache } = getActiveClient();
+    let user;
+    if (!cache) {
+        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveUser(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    const dispatcher = (data) => {
+        var _a;
+        // we check updatedAt to see if the current snapshot is new so
+        // we won't send old data back, only fresh new data
+        if (user && ((_a = data.data) === null || _a === void 0 ? void 0 : _a.updatedAt) === (user === null || user === void 0 ? void 0 : user.updatedAt) && data.origin !== 'server')
+            return;
+        callback(data);
+        user = data.data;
+    };
+    const realtimeRouter = (user, action) => {
+        dispatcher({ loading: false, data: user, origin: 'event' });
+    };
+    const onFetch = () => {
+        const query = createQuery(getUser, userId, true);
+        runQuery(query, ({ loading, data, error, origin }) => {
+            dispatcher({ loading, data, origin, error });
+            if (error) {
+                // Terminate observe functionality on error
+                disposers.forEach(fn => fn());
+            }
+        });
+    };
+    disposers.push(onUserFetched(user => realtimeRouter(user)), onUserUpdated(user => realtimeRouter(user)), onUserDeleted(user => realtimeRouter(user)), onUserFlagged(user => realtimeRouter(user)), onUserUnflagged(user => realtimeRouter(user)), onUserFlagCleared(user => realtimeRouter(user)));
+    onFetch();
+    return () => {
+        log(`liveUser(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { observeUser } from '@amityco/ts-sdk'
@@ -20905,6 +21129,7 @@ const observeUser = (userId, callback) => {
     const { log } = getActiveClient();
     const timestamp = Date.now();
     log(`observeUser(tmpid: ${timestamp}) > listen`);
+    console.log('observeUser will be deprecated on 25th November 2022, please use liveUser instead.');
     // wrapper function to make sure
     const router = (result, action) => {
         var _a, _b, _c;
@@ -21314,15 +21539,30 @@ const dispatchReactable = (referenceType, model) => {
  * @category Message API
  * @async
  */
-const getMessage = async (messageId) => {
+const getMessage = async (messageId, isLive = false) => {
     const client = getActiveClient();
     client.log('message/getMessage', messageId);
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data } = await client.http.get(`/api/v3/messages/${encodeURIComponent(messageId)}`);
+    if (!isLive) {
+        console.log('getMessage will be deprecated on 15th November 2022, please use liveMessage instead.');
+    }
+    isInTombstone('message', messageId);
+    let data;
+    try {
+        // API-FIX: endpoint should not be /list, parameters should be querystring.
+        const response = await client.http.get(`/api/v3/messages/${encodeURIComponent(messageId)}`);
+        data = response.data;
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('message', messageId);
+        }
+        throw error;
+    }
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { messages } = data;
+    fireEvent('v3.message.didFetch', { messages });
     return {
         data: messages.find(message => message.messageId === messageId),
         cachedAt,
@@ -21379,8 +21619,10 @@ const getMessages = async (messageIds) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
+    const { messages } = data;
+    fireEvent('v3.message.didFetch', { messages });
     return {
-        data: data.messages,
+        data: messages,
         cachedAt,
     };
 };
@@ -21457,6 +21699,7 @@ const queryMessages = async (query) => {
         ];
         pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
     }
+    fireEvent('v3.message.didFetch', { messages });
     const nextPage = toPage(paging.next);
     const prevPage = toPage(paging.previous);
     return { data: messages, cachedAt, prevPage, nextPage };
@@ -21522,8 +21765,8 @@ const createMessage = async (bundle) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    // no need for event, fired by server
     const { messages } = data;
+    fireEvent('v3.message.didCreate', { messages });
     return {
         data: messages[0],
         cachedAt,
@@ -21565,11 +21808,12 @@ createMessage.optimistically = (bundle) => {
     // as reused to update created and updated time, which should be the same
     const createdTime = new Date().toISOString();
     const message = Object.assign({ userId: client.userId, channelSegment: ((_b = channel === null || channel === void 0 ? void 0 : channel.data.messageCount) !== null && _b !== void 0 ? _b : 0) + 1, createdAt: createdTime, updatedAt: createdTime }, bundleWithMessageId);
-    pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 });
+    const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
+    pushToCache(['message', 'get', message.messageId], message, { cachedAt });
     fireEvent('v3.message.didCreate', { messages: [message] });
     return {
+        cachedAt,
         data: message,
-        cachedAt: -1,
     };
 };
 
@@ -21598,6 +21842,7 @@ const updateMessage = async (messageId, patch) => {
     if (client.cache)
         ingestInCache(data, { cachedAt });
     const { messages } = data;
+    fireEvent('v3.message.didUpdate', { messages });
     return {
         data: messages.find(message => message.messageId === messageId),
         cachedAt,
@@ -21657,7 +21902,7 @@ const deleteMessage = async (messageId) => {
     // API-FIX: This endpoint has not been implemented yet.
     await client.http.delete(`/api/v3/messages/${encodeURIComponent(messageId)}`);
     const deleted = await getMessage(messageId);
-    // no need for event, fired by server
+    fireEvent('v3.message.didDelete', { messages: [deleted.data] });
     return deleted.data;
 };
 /**
@@ -21844,6 +22089,7 @@ getPosts.locally = (postIds) => {
 const getPost = async (postId) => {
     const client = getActiveClient();
     client.log('post/getPost', postId);
+    isInTombstone('post', postId);
     let data;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
@@ -21851,8 +22097,8 @@ const getPost = async (postId) => {
         data = response.data;
     }
     catch (error) {
-        if ((error === null || error === void 0 ? void 0 : error.code) === 400400 /* Amity.ServerError.ITEM_NOT_FOUND */) {
-            dropFromCache(['post', 'get', postId], true);
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('post', postId);
         }
         throw error;
     }
@@ -22632,7 +22878,7 @@ const deletePost = async (postId, permanent = false) => {
     fireEvent('post.deleted', { posts: [deleted] });
     if (permanent) {
         setTimeout(() => {
-            dropFromCache(['post', 'get', postId], true);
+            pushToTombstone('post', postId);
         }, 0);
     }
     else {
@@ -23886,10 +24132,6 @@ const onReactorRemoved = (referenceType, referenceId, callback) => {
     return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
 };
 
-const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
-const COLLECTION_DEFAULT_CACHING_POLICY = 'cache_then_server';
-const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
-
 /**
  * ```js
  * import { liveReactions } from '@amityco/ts-sdk'
@@ -24166,9 +24408,24 @@ const queryChannels = async (query) => {
  * @category Channel API
  */
 queryChannels.locally = (query) => {
+    var _a, _b;
     const client = getActiveClient();
     client.log('channel/queryChannels.locally', query);
-    // TODO
+    const _c = query !== null && query !== void 0 ? query : {}, { page = { limit: 10 } } = _c, params = __rest(_c, ["page"]);
+    const cacheKey = ['channel', 'query', Object.assign(Object.assign({}, params), { options: Object.assign({}, page) })];
+    const { data, cachedAt } = (_a = pullFromCache(cacheKey)) !== null && _a !== void 0 ? _a : {};
+    if (!(data === null || data === void 0 ? void 0 : data.channels.length))
+        return;
+    const channels = data.channels
+        // ck -> cacheKey, abbrevated to avoid confusion from the above cache key
+        .map(ck => pullFromCache(['channel', 'get', ck]))
+        .filter(Boolean)
+        .map(({ data }) => data);
+    const prevPage = toPage(data === null || data === void 0 ? void 0 : data.paging.previous);
+    const nextPage = toPage(data === null || data === void 0 ? void 0 : data.paging.next);
+    return channels.length === ((_b = data === null || data === void 0 ? void 0 : data.channels) === null || _b === void 0 ? void 0 : _b.length)
+        ? { data: channels, cachedAt, prevPage, nextPage }
+        : undefined;
 };
 
 /**
@@ -24445,8 +24702,8 @@ const leaveChannel = async (channelId) => {
 const queryChannelMembers = async (query) => {
     const client = getActiveClient();
     client.log('channel/queryChannelMembers', query);
-    const _a = query !== null && query !== void 0 ? query : {}, { page, channelId } = _a, params = __rest(_a, ["page", "channelId"]);
-    const { data: queryPayload } = await client.http.get(`/api/v4/channels/${encodeURIComponent(channelId)}/users`, {
+    const _a = query !== null && query !== void 0 ? query : {}, { page = { limit: 10 } } = _a, params = __rest(_a, ["page"]);
+    const { data: queryPayload } = await client.http.get(`/api/v4/channels/${encodeURIComponent(params.channelId)}/users`, {
         params: Object.assign(Object.assign({}, params), { options: {
                 token: toToken(page, 'skiplimit'),
             } }),
@@ -24457,6 +24714,15 @@ const queryChannelMembers = async (query) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
         ingestInCache(data);
+        const cacheKey = [
+            'channelUsers',
+            'query',
+            Object.assign(Object.assign({}, params), { options: Object.assign({}, page) }),
+        ];
+        pushToCache(cacheKey, {
+            channelUsers: channelUsers.map(({ channelId, userId }) => getResolver('channelUsers')({ channelId, userId })),
+            paging,
+        });
     }
     const nextPage = toPage(paging.next);
     const prevPage = toPage(paging.previous);
@@ -24476,9 +24742,30 @@ const queryChannelMembers = async (query) => {
  * @category Post API
  */
 queryChannelMembers.locally = (query) => {
+    var _a, _b;
     const client = getActiveClient();
-    client.log('channel/queryChannelMembers', query);
-    // TODO
+    client.log('channel/queryChannelMembers.locally', query);
+    if (!client.cache)
+        return;
+    const { page = { limit: 10 } } = query, params = __rest(query, ["page"]);
+    const cacheKey = [
+        'channelUsers',
+        'query',
+        Object.assign(Object.assign({}, params), { options: Object.assign({}, page) }),
+    ];
+    const { data, cachedAt } = (_a = pullFromCache(cacheKey)) !== null && _a !== void 0 ? _a : {};
+    if (!(data === null || data === void 0 ? void 0 : data.channelUsers.length))
+        return;
+    const channelUsers = data.channelUsers
+        // ck -> cacheKey, abbrevated to avoid confusion from the above cache key
+        .map(ck => pullFromCache(['channelUsers', 'get', ck]))
+        .filter(Boolean)
+        .map(({ data }) => data);
+    const prevPage = toPage(data === null || data === void 0 ? void 0 : data.paging.previous);
+    const nextPage = toPage(data === null || data === void 0 ? void 0 : data.paging.next);
+    return channelUsers.length === ((_b = data === null || data === void 0 ? void 0 : data.channelUsers) === null || _b === void 0 ? void 0 : _b.length)
+        ? { data: channelUsers, cachedAt, prevPage, nextPage }
+        : undefined;
 };
 
 /**
@@ -24826,6 +25113,56 @@ const onChannelMemberRemoved = (callback) => {
     return createEventSubscriber(client, 'onChannelMemberRemoved', 'v3.channel.didRemoveUsers', filter);
 };
 
+/**
+ * ```js
+ * import { onChannelMemberBanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberBanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been banned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMemberBanned = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        const data = prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0], data.channelUsers.find(cu => cu.membership === 'banned'));
+    };
+    return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didBan', filter);
+};
+
+/**
+ * ```js
+ * import { onChannelMemberUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberUnbanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been unbanned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMemberUnbanned = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        const data = prepareChannelPayload(payload);
+        ingestInCache(data);
+        callback(data.channels[0], data.channelUsers.find(cu => cu.membership === 'none'));
+    };
+    return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didUnban', filter);
+};
+
 /**
  * ```js
  * import { observeChannel } from '@amityco/ts-sdk'
@@ -24920,7 +25257,7 @@ const observeChannels = (callback) => {
  * @category Channel Live Collection
  */
 const liveChannels = (params, callback, config) => {
-    const { log, cache } = getActiveClient();
+    const { log, cache, userId } = getActiveClient();
     if (!cache) {
         console.log(ENABLE_CACHE_MESSAGE);
     }
@@ -24948,6 +25285,10 @@ const liveChannels = (params, callback, config) => {
         if (params.excludeTags) {
             channels = channels.filter(c => { var _a; return !((_a = c.tags) === null || _a === void 0 ? void 0 : _a.some(t => { var _a; return (_a = params.excludeTags) === null || _a === void 0 ? void 0 : _a.includes(t); })); });
         }
+        // userId is required to be able to filter channel by current active user
+        if (params.membership && userId) {
+            channels = filterByChannelMembership(channels, params.membership, userId);
+        }
         const sortBy = params.sortBy || 'lastCreated';
         if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
             channels = channels.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
@@ -25057,7 +25398,20 @@ const liveChannelMembers = (params, callback, config) => {
             .filter(Boolean)
             .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
         channelMembers = filterByPropEquality(channelMembers, 'roles', params.roles);
-        channelMembers = filterByPropInclusion(channelMembers, 'membership', params.memberships);
+        if (params.memberships) {
+            /*
+             * even though membership includes muted as a possible value
+             * when querying the server.
+             * Muted is specified under seperarte property namely isMuted
+             * Hence why I've seperately checked for it's equality
+             */
+            if (params.memberships.some(m => ['member', 'banned'].includes(m))) {
+                channelMembers = filterByPropInclusion(channelMembers, 'membership', params.memberships);
+            }
+            if (params.memberships.includes('muted')) {
+                channelMembers = filterByPropEquality(channelMembers, 'isMuted', true);
+            }
+        }
         if (params.search) {
             const containsMatcher = new RegExp(params.search);
             channelMembers = channelMembers.filter(m => m.userId.match(containsMatcher));
@@ -25085,7 +25439,7 @@ const liveChannelMembers = (params, callback, config) => {
         if (action === 'onMemberAdded') {
             collection.data = [...new Set([channelMemberCacheId, ...collection.data])];
         }
-        else {
+        if (action === 'onMemberRemoved') {
             collection.data = collection.data.filter(m => m !== channelMemberCacheId);
         }
         pushToCache(cacheKey, collection);
@@ -25112,7 +25466,7 @@ const liveChannelMembers = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onChannelMemberAdded((_, member) => realtimeRouter(member, 'onMemberAdded')), onChannelMemberRemoved((_, member) => realtimeRouter(member, 'onMemberRemoved')));
+    disposers.push(onChannelMemberAdded((_, member) => realtimeRouter(member, 'onMemberAdded')), onChannelMemberRemoved((_, member) => realtimeRouter(member, 'onMemberRemoved')), onChannelMemberBanned((_, member) => realtimeRouter(member, 'onChannelMemberBanned')), onChannelMemberUnbanned((_, member) => realtimeRouter(member, 'onChannelMemberUnbanned')));
     onFetch();
     return () => {
         log(`liveChannelMembers(tmpid: ${timestamp}) > dispose`);
@@ -25199,82 +25553,92 @@ const onMessageDeleted = (callback) => {
 
 /**
  * ```js
- * import { observeMessage } from '@amityco/ts-sdk'
- *
- * let message = {}
- * const unsub = observeMessage(messageId, updated => message = updated)
+ * import { onMessageFetched } from '@amityco/ts-sdk'
+ * const dispose = onMessageFetched(message => {
+ *   // ...
+ * })
  * ```
  *
- * Observe all mutations on a {@link Amity.Message} given a single messageId
+ * Fired when an {@link Amity.Message} has been fetched
  *
- * @param client the client to observe the message with
- * @param messageId the ID of the message to observe
- * @param callback the function to call when new data are available
- * @param policy a query policy option for this observer
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the message
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Message Observer
+ * @category Message Events
  */
-const observeMessage = (messageId, callback, policy = 'cache_then_server') => {
-    const { log } = getActiveClient();
-    const timestamp = Date.now();
-    log(`observeMessage(tmpid: ${timestamp}) > listen`);
-    // wrapper function to make sure
-    const router = (result, action) => {
-        var _a, _b, _c;
-        // filter function
-        if (((_a = result.data) === null || _a === void 0 ? void 0 : _a.messageId) !== messageId)
-            return;
-        if (callback instanceof Function)
-            return callback(result);
-        if (action !== 'onFetch')
-            (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
-        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
-    };
-    const disposers = [];
-    disposers.push(onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')));
-    if (policy !== 'no_fetch') {
-        runQuery(createQuery(getMessage, messageId), result => result.data && router(result, 'onFetch'), queryOptions(policy));
-    }
-    return () => {
-        log(`observeMessages(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
+const onMessageFetched = (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        ingestInCache(payload);
+        callback(payload.messages[0]);
     };
+    return createEventSubscriber(client, 'message/onMessageFetched', 'v3.message.didFetch', filter);
 };
 
 /**
  * ```js
- * import { observeMessages } from '@amityco/ts-sdk'
+ * import { liveMessage } from '@amityco/ts-sdk'
  *
  * let messages = []
- * const unsub = observeMessages(channelId, message => merge(messages, message))
+ * const unsub = liveMessage(messageId, response => merge(messages, response.data))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
+ * Observe all mutation on a given {@link Amity.Message}
  *
- * @param channelId the ID of the channel where to observe the messages
+ * @param messageId the ID of the message to observe
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
  *
- * @category Message Observer
+ * @category Message Live Object
  */
-const observeMessages = (channelId, callback) => {
-    const { log } = getActiveClient();
+const liveMessage = (messageId, callback) => {
+    const { log, cache } = getActiveClient();
+    let message;
+    let isUnsyncedObject = false;
+    if (!cache) {
+        console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+    }
     const timestamp = Date.now();
-    log(`observeMessages(tmpid: ${timestamp}) > listen`);
+    log(`liveMessage(tmpid: ${timestamp}) > listen`);
     const disposers = [];
-    const router = (message, action) => {
-        var _a, _b, _c;
-        if (((_a = message.data) === null || _a === void 0 ? void 0 : _a.channelId) !== channelId)
+    const dispatcher = (data) => {
+        var _a;
+        // we check updatedAt to see if the current snapshot is new so
+        // we won't send old data back, only fresh new data
+        if (message && ((_a = data.data) === null || _a === void 0 ? void 0 : _a.updatedAt) === (message === null || message === void 0 ? void 0 : message.updatedAt) && data.origin !== 'server')
             return;
-        if (callback instanceof Function)
-            return callback(message);
-        (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, message);
-        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, message);
+        callback(data);
+        message = data.data;
     };
-    disposers.push(onMessageCreated(data => router({ data, loading: false, origin: 'event' }, 'onCreate')), onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')));
+    const realtimeRouter = (message, action) => {
+        dispatcher({ loading: false, data: message, origin: 'event' });
+    };
+    const onFetch = () => {
+        const query = createQuery(getMessage, messageId, true);
+        runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
+            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+                dispatcher({
+                    data,
+                    origin,
+                    loading: false,
+                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
+                });
+                isUnsyncedObject = true;
+                disposers.forEach(fn => fn());
+            }
+            else if (!isUnsyncedObject) {
+                dispatcher({ loading, data, origin, error });
+            }
+            if (error) {
+                // Terminate observe functionality on error
+                disposers.forEach(fn => fn());
+            }
+        });
+    };
+    disposers.push(onMessageFetched(message => realtimeRouter(message)), onMessageUpdated(message => realtimeRouter(message)), onMessageDeleted(message => realtimeRouter(message)));
+    onFetch();
     return () => {
-        log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+        log(`liveMessage(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
     };
 };
@@ -25363,7 +25727,7 @@ const liveMessages = (params, callback, config) => {
             responder(data);
         }, queryOptions(policy));
     };
-    disposers.push(onMessageCreated(message => realtimeRouter(message, 'onCreate')), onMessageDeleted(message => realtimeRouter(message, 'onDelete')), onMessageUpdated(message => realtimeRouter(message, 'onUpdate')));
+    disposers.push(onMessageFetched(message => realtimeRouter(message, 'onFetch')), onMessageCreated(message => realtimeRouter(message, 'onCreate')), onMessageDeleted(message => realtimeRouter(message, 'onDelete')), onMessageUpdated(message => realtimeRouter(message, 'onUpdate')));
     onFetch();
     return () => {
         log(`liveMessages(tmpid: ${timestamp}) > dispose`);
@@ -25371,6 +25735,89 @@ const liveMessages = (params, callback, config) => {
     };
 };
 
+/**
+ * ```js
+ * import { observeMessage } from '@amityco/ts-sdk'
+ *
+ * let message = {}
+ * const unsub = observeMessage(messageId, updated => message = updated)
+ * ```
+ *
+ * Observe all mutations on a {@link Amity.Message} given a single messageId
+ *
+ * @param client the client to observe the message with
+ * @param messageId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @param policy a query policy option for this observer
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the message
+ *
+ * @category Message Observer
+ */
+const observeMessage = (messageId, callback, policy = 'cache_then_server') => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeMessage(tmpid: ${timestamp}) > listen`);
+    console.log('observeMessage will be deprecated on 15th November 2022, please use liveMessage instead.');
+    // wrapper function to make sure
+    const router = (result, action) => {
+        var _a, _b, _c;
+        // filter function
+        if (((_a = result.data) === null || _a === void 0 ? void 0 : _a.messageId) !== messageId)
+            return;
+        if (callback instanceof Function)
+            return callback(result);
+        if (action !== 'onFetch')
+            (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, result);
+        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, result);
+    };
+    const disposers = [];
+    disposers.push(onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')));
+    if (policy !== 'no_fetch') {
+        runQuery(createQuery(getMessage, messageId), result => result.data && router(result, 'onFetch'), queryOptions(policy));
+    }
+    return () => {
+        log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { observeMessages } from '@amityco/ts-sdk'
+ *
+ * let messages = []
+ * const unsub = observeMessages(channelId, message => merge(messages, message))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
+ *
+ * @param channelId the ID of the channel where to observe the messages
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ *
+ * @category Message Observer
+ */
+const observeMessages = (channelId, callback) => {
+    const { log } = getActiveClient();
+    const timestamp = Date.now();
+    log(`observeMessages(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    const router = (message, action) => {
+        var _a, _b, _c;
+        if (((_a = message.data) === null || _a === void 0 ? void 0 : _a.channelId) !== channelId)
+            return;
+        if (callback instanceof Function)
+            return callback(message);
+        (_b = callback.onEvent) === null || _b === void 0 ? void 0 : _b.call(callback, action, message);
+        (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, message);
+    };
+    disposers.push(onMessageCreated(data => router({ data, loading: false, origin: 'event' }, 'onCreate')), onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')));
+    return () => {
+        log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 const createCommunityEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
@@ -27559,6 +28006,8 @@ exports.CommunityPostSettings = CommunityPostSettings;
 exports.ContentFeedType = ContentFeedType;
 exports.DefaultCommunityPostSetting = DefaultCommunityPostSetting;
 exports.FileType = FileType;
+exports.MessageContentType = MessageContentType;
+exports.PostContentType = PostContentType;
 exports.VERSION = VERSION$1;
 exports.VideoResolution = VideoResolution;
 exports.VideoSize = VideoSize;
@@ -27605,6 +28054,7 @@ exports.disposeStream = disposeStream;
 exports.dropFromCache = dropFromCache;
 exports.enableCache = enableCache;
 exports.fileUrlWithSize = fileUrlWithSize;
+exports.filterByChannelMembership = filterByChannelMembership;
 exports.filterByPropEquality = filterByPropEquality;
 exports.filterByPropInclusion = filterByPropInclusion;
 exports.follow = follow;
@@ -27658,9 +28108,11 @@ exports.liveChannels = liveChannels;
 exports.liveComments = liveComments;
 exports.liveFollowers = liveFollowers;
 exports.liveFollowings = liveFollowings;
+exports.liveMessage = liveMessage;
 exports.liveMessages = liveMessages;
 exports.livePosts = livePosts;
 exports.liveReactions = liveReactions;
+exports.liveUser = liveUser;
 exports.mergeInCache = mergeInCache;
 exports.observeChannel = observeChannel;
 exports.observeChannels = observeChannels;
@@ -27682,7 +28134,9 @@ exports.onChannelDeleted = onChannelDeleted;
 exports.onChannelJoined = onChannelJoined;
 exports.onChannelLeft = onChannelLeft;
 exports.onChannelMemberAdded = onChannelMemberAdded;
+exports.onChannelMemberBanned = onChannelMemberBanned;
 exports.onChannelMemberRemoved = onChannelMemberRemoved;
+exports.onChannelMemberUnbanned = onChannelMemberUnbanned;
 exports.onChannelUpdated = onChannelUpdated;
 exports.onClientBanned = onClientBanned;
 exports.onClientDisconnected = onClientDisconnected;
@@ -27711,6 +28165,7 @@ exports.onFollowerDeleted = onFollowerDeleted;
 exports.onFollowerRequested = onFollowerRequested;
 exports.onMessageCreated = onMessageCreated;
 exports.onMessageDeleted = onMessageDeleted;
+exports.onMessageFetched = onMessageFetched;
 exports.onMessageUpdated = onMessageUpdated;
 exports.onPollDeleted = onPollDeleted;
 exports.onPollUpdated = onPollUpdated;
@@ -27731,6 +28186,7 @@ exports.onStreamRecorded = onStreamRecorded;
 exports.onStreamStarted = onStreamStarted;
 exports.onStreamStopped = onStreamStopped;
 exports.onUserDeleted = onUserDeleted;
+exports.onUserFetched = onUserFetched;
 exports.onUserFlagCleared = onUserFlagCleared;
 exports.onUserFlagged = onUserFlagged;
 exports.onUserFollowed = onUserFollowed;