@amityco/ts-sdk 7.22.0 → 7.22.1-6865c1e9.0

package/dist/index.cjs.js

@@ -267,6 +267,7 @@ function getVersion() {
 const VERSION = getVersion();
 
 const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+const COLLECTION_DEFAULT_PAGINATION_SIZE = 20;
 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!';
@@ -279,6 +280,9 @@ const DAY = 24 * HOUR;
 const WEEK = 7 * DAY;
 const YEAR = 365 * DAY;
 const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;
+const API_ENDPOINTS = {
+    forYouFeed: '/api/v1/feeds/for-you',
+};
 
 // cache constants
 const CACHE_KEY_GET = 'get';
@@ -708,6 +712,7 @@ const idResolvers = {
     event: ({ eventId }) => eventId,
     eventResponse: ({ userId }) => userId,
     product: ({ productId }) => productId,
+    feedMetadata: ({ postId }) => postId,
 };
 /**
  * Retrieve the id resolver matching a domain name
@@ -768,6 +773,7 @@ const PAYLOAD2MODEL = {
     viewers: 'viewer',
     eventResponses: 'eventResponse',
     products: 'product',
+    feedMetadata: 'feedMetadata',
 };
 /** hidden */
 const isOutdated = (prevData, nextData) => {
@@ -7844,6 +7850,30 @@ class AnalyticsEventCapturer {
             activityType: "view" /* Amity.AnalyticEventActivityType.View */,
         });
     }
+    markPostAsMeaningfullyViewed(postId, feedRenderPosition) {
+        var _a;
+        const cached = (_a = pullFromCache(['feedMetadata', 'get', postId])) === null || _a === void 0 ? void 0 : _a.data;
+        const metadata = {};
+        if (feedRenderPosition !== undefined)
+            metadata.feedRenderPosition = feedRenderPosition;
+        if (cached) {
+            metadata.feedSnapshotPosition = cached.feedSnapshotPosition;
+            metadata.feedInjectionType = cached.feedInjectionType;
+            metadata.feedRelevanceScore = cached.feedRelevanceScore;
+            metadata.feedPopularityScore = cached.feedPopularityScore;
+            metadata.feedFreshnessScore = cached.feedFreshnessScore;
+            metadata.feedAffinityScore = cached.feedAffinityScore;
+            metadata.feedFinalScore = cached.feedFinalScore;
+            metadata.feedMmrPenalty = cached.feedMmrPenalty;
+        }
+        this.markAs({
+            uniqueId: `${postId}.meaningfulView`,
+            contentId: postId,
+            contentType: "post" /* Amity.AnalyticEventContentType.Post */,
+            activityType: "meaningfulView" /* Amity.AnalyticEventActivityType.MeaningfulView */,
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        });
+    }
     markStory(story, activityType) {
         if (!story.expiresAt)
             return;
@@ -7983,6 +8013,12 @@ class AnalyticsEngine {
             this._eventCapturer.markPostAsViewed(postId);
         }
     }
+    markPostAsMeaningfullyViewed(postId, feedRenderPosition) {
+        if (this._client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */ ||
+            this._client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            this._eventCapturer.markPostAsMeaningfullyViewed(postId, feedRenderPosition);
+        }
+    }
     markStoryAsViewed(story) {
         if (this._client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */ ||
             this._client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ // For case token_expired, we assume token is expired and gonna re-connect soon
@@ -9103,6 +9139,59 @@ var blockedUserSyncEngineOnLoginHandler = () => {
     };
 };
 
+class CursorController {
+    constructor(networkId, userId) {
+        this.networkId = networkId;
+        this.userId = userId;
+    }
+    static current() {
+        try {
+            const user = getCurrentUser();
+            if (!user)
+                return null;
+            const networkId = getNetworkId(user);
+            const { userId } = user;
+            return networkId && userId ? new CursorController(networkId, userId) : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    static isExpired(expiredAt) {
+        return Date.now() >= expiredAt;
+    }
+    static clearOnLogout() {
+        return onSessionStateChange(state => {
+            var _a;
+            if (state === "terminated" /* Amity.SessionStates.TERMINATED */)
+                (_a = CursorController.current()) === null || _a === void 0 ? void 0 : _a.clear();
+        });
+    }
+    get key() {
+        return `amity:forYouFeed:cursor:${this.networkId}:${this.userId}`;
+    }
+    async get() {
+        const raw = await getItem(this.key);
+        if (!raw)
+            return null;
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof (parsed === null || parsed === void 0 ? void 0 : parsed.cursor) !== 'string' || typeof (parsed === null || parsed === void 0 ? void 0 : parsed.expiredAt) !== 'number')
+                return null;
+            return { cursor: parsed.cursor, expiredAt: parsed.expiredAt };
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    async set(value) {
+        await setItem(this.key, JSON.stringify(value));
+    }
+    async clear() {
+        await setItem(this.key, '');
+    }
+}
+
 const EVENTS = [
     'disconnected',
     'error',
@@ -9292,7 +9381,7 @@ const setupLoginSubscriptions = (unsubWatcher) => {
     // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
     // the channel because currently backend can't handle this, so every time a user is banned from
     // a channel or the channel is deleted the channel's unread count will not be reset to zero
-    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler());
+    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler(), CursorController.clearOnLogout());
     if (client.useLegacyUnreadCount) {
         subscriptions.push(readReceiptSyncEngineOnLoginHandler());
     }
@@ -13274,7 +13363,7 @@ const getWatchSessionStorage = () => {
     return storageInstance;
 };
 
-const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDHo80SecH7FuF2\nhFYnb+l26/VN8UMLXAQFLnxciNTEwkGVFMpdezlH8rU2HtUJL4RETogbAOLVY0XM\njs6sPn8G1nALmh9qeDpUtVqFOVtBHxEZ910TLOtQiunjqJKO5nWdqZ71EC3OFluR\niGQkO84BiIFbv37ub7xl3S8XarbtKoLcyVpkDHi+1wx1pgCAn6gtBUgckPL5NR8j\nLseabl3HAXQfhTCKo4tmOFM2Dxwl1IUMmIJrJg/aIU/U0tj/1Eoo7mG0JcNWX19l\nW3EecCbi0ncCJOrkUdwlBrcjaMayaX/ubEwyUeTGiLdyc4L3GRLHjyK8xgVNXRMH\nbZWJ2a5NAgMBAAECggEASxuE+35zTFO/XydKgmvIGcWL9FbgMlXb7Vcf0nBoG945\nbiz0NVc2paraIhJXc608xbYF3qLmtAE1MVBI0ORyRdBHNxY024l/6H6SH60Ed+uI\nM4ysp5ourY6Vj+DLwpdRiI9YDjqYAQDIUmhNxJP7XPhOMoZI6st+xZQBM34ic/bv\nAMSJm9OZphSp3+qXVkFZztr2mxD2EZSJJLYxi8BCdgM2qhazalbcJ6zDKHCZWVWm\n8RRxDGldyMb/237JxETzP40tAlzOZDmBAbUgEnurDJ93RVDIE3rbZUshwgeQd18a\nem096mWgvB1AIKYgsTAR3pw+V19YWAjq/glP6fz8wQKBgQD/oQq+ukKF0PRgBeM5\ngeTjSwsdGppQLmf5ndujvoiz/TpdjDEPu6R8kigQr1rG2t4K/yfdZoI8RdmJD1al\n3Q7N9hofooSy4rj6E3txzWZCHJjHad2cnCp/O26HiReGAl7wTcfTmNdiFHhZQzm5\nJBkvWAiwuvQMNfEbnXxw6/vIDwKBgQDH7fX8gsc77JLvAWgp1MaQN/sbqVb6JeT1\nFQfR8E/WFCSmzQBtNzd5KgYuCeelwr/8DyYytvN2BzCYZXp73gI1jF3YlW5jVn74\nOY6TwQ095digwo6Z0yuxopdIOApKgAkL9PRKgNrqAf3NAyMua6lOGifzjDojC3KU\nfylQmxMn4wKBgHp2B9O/H0dEBw5JQ8W0+JX6yWQz7mEjGiR2/1W+XXb8hQ1zr709\nw1r6Gb+EghRpnZ3fBpYGGbYOMFx8wKHM+N6qW3F0ReX8v2juFGE8aRSa5oYBrWzt\nU16Idjbv8hj84cZ1PJmdyvDtpYn9rpWHOZl4rxEbPvbqkIsOMyNVqdT5AoGAOSge\nmwIIU2le2FVeohbibXiToWTYKMuMmURZ5/r72AgKMmWJKbAPe+Q3wBG01/7FRBpQ\noU8Ma0HC8s6QJbliiEyIx9JwrJWd1vkdecBHONrtA4ibm/5zD2WcOllLF+FitLhi\n3qnX6+6F0IaFGFBPJrTzlv0P4dTz/OAdv52V7GECgYEA2TttOKBAqWllgOaZOkql\nLVMJVmgR7s6tLi1+cEP8ZcapV9aRbRzTAKXm4f8AEhtlG9F9kCOvHYCYGi6JaiWJ\nZkHjeex3T+eE6Di6y5Bm/Ift5jtVhJ4jCVwHOKTMej79NPUFTJfv8hCo29haBDv6\nRXFrv+T21KCcw8k3sJeJWWQ=\n-----END PRIVATE KEY-----";
+const privateKey = "MIIEpQIBAAKCAQEAwAEc/oZgYIvKSUG/C3mONYLR4ZPgAjMEX4bJ+xqqakUDRtqlNO+eZs2blQ1Ko0DBkqPExyQezvjibH5W2UZBV5RaBTlTcNVKTToMBEGesAfaEcM3qUyQHxdbFYZv6P4sb14dcwxTQ8usmaV8ooiR1Fcaso5ZWYcZ8Hb46FbQ7OoVumsBtPWwfZ4f003o5VCl6AIM6lcLv9UDLlFVYhE+PeXpRHtfWlGqxMvqC9oinlwhL6nWv6VjQXW4nhcib72dPBzfHT7k/PMKto2SxALYdb68ENiAGuJLWi3AUHSyYCJK2w7wIlWfJUAI0v26ub10IpExr6D5QuW2577jjP93iwIDAQABAoIBAFWfqXhwIIatkFY+9Z1+ZcbDQimgsmMIsUiQaX6Lk7e0cxOj6czDlxYtVtaPiNtow2pLkjNkjkCqiP7tEHnwdK9DvylZOTa2R15NJpK3WLcTqVIGhsn/FL5owfvFah6zSsmXZParZm5zY9NZE03ALZhOB9/cz0e3kf/EbpfeL2mW7MApyiUt5i09ycchroOpcWp73ipIxvgigtZyUGFmsQicWhUs28F0D7w4Qfk76yG3nqXeb+BAMhCaIaa/k/aAxhiZG/ygEQWQrcC8gfe+jyicMAQPDEVS9YuUMGsLjIjKuVLZzp2xirQnhc2i2zVNEIvG6soprPOBEMQugzrtX5ECgYEA3b7KAbBIbDl1e4ZSCWhHdHkiWVZHaopsR/LhqDDNhXjWjq3AesgV6k0j9EdziMn/HmmOso0bz99GTV3JZf4A9ztTLumJlkHbdVtlgOqSjrFLj12rH9KXTheyIhWSpUmm8+WB1xasFbqpvJaGo7F3pd2Fqj1XR4mp5BO7c/t7LJ0CgYEA3aouEzXQ9THRKYocdfY69EI1Il1t/d/RSqqd9BxEjxBgxkM13ZiYIn/R4WW/nCUrlmhxG44Aa2Gob4Ahfsui2xKTg/g/3Zk/rAxAEGkfOLGoenaJMD41fH4wUq3FRYwkvnaMb9Hd6f/TlBHslIRa2NN58bSBGJCyBP2b59+2+EcCgYEAixDVRXvV37GlYUOa/XVdosk5Zoe6oDGRuQm0xbNdoUBoZvDHDvme7ONWEiQha/8qtVsD+CyQ7awcPfb8kK9c0bBt+bTS6d4BkTcxkEkMgtrkBVR8Nqfu5jXsLH4VCv4G61zbMhZw8+ut+az5YX2yCN7Frj9sFlxapMRPQmzMEe0CgYEAumsAzM8ZqNv4mAK65Mnr0rhLj1cbxcKRdUYACOgtEFQpzxN/HZnTeFAe5nx3pI3uFlRHq3DFEYnT6dHMWaJQmAULYpVIwMi9L6gtyJ9fzoI6uqMtxRDMUqKdaSsTGOY/kJ6KhQ/unXi1K3XXjR+yd1+C0q+HUm1+CYxvrZYLfskCgYEArsEy+IQOiqniJ0NE2vVUF+UK/IRZaic9YKcpov5Ot7Vvzm/MnnW4N1ljVskocETBWMmPUvNSExVjPebi+rxd8fa5kY8BJScPTzMFbunZn/wjtGdcM10qdlVQ9doG61A/9P3ezFKCfS4AvF/H/59LcSx2Bh28fp3/efiVIOpVd4Y=";
 /*
  * The crypto algorithm used for importing key and signing string
  */
@@ -14596,6 +14685,10 @@ const postLinkedObject = (post) => {
                 const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
                 analyticsEngineInstance.markPostAsViewed(post.postId);
             },
+            markAsMeaningfullyViewed: (feedRenderPosition) => {
+                const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
+                analyticsEngineInstance.markPostAsMeaningfullyViewed(post.postId, feedRenderPosition);
+            },
         },
         get productTags() {
             var _a, _b;
@@ -27909,13 +28002,218 @@ const getCommunityFeed = (params, callback, config) => {
 };
 /* end_public_function */
 
+/**
+ * Thrown by `getForYouFeed` when the network has the For You feature
+ * disabled. Mapped from HTTP 404 NOT_FOUND. Distinct from a generic
+ * not-found so consumers can hide the For You tab without retrying.
+ *
+ * @category Errors
+ */
+class AmityForYouFeedDisabledError extends ASCApiError {
+    constructor(message = 'For You feed is not enabled for this network') {
+        super(message, 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
+        this.type = 'AmityForYouFeedDisabledError';
+    }
+}
+
+class ForYouFeedPaginationController extends PaginationController {
+    constructor(query) {
+        super(query);
+        this.checkedDisk = false;
+        this.cursor = CursorController.current();
+    }
+    async getRequest(_queryParams, token) {
+        let effectiveToken = token;
+        const params = {
+            limit: COLLECTION_DEFAULT_PAGINATION_SIZE,
+        };
+        if (!effectiveToken && !this.checkedDisk && this.cursor) {
+            this.checkedDisk = true;
+            const stored = await this.cursor.get();
+            if (stored && !CursorController.isExpired(stored.expiredAt)) {
+                effectiveToken = stored.cursor;
+            }
+            else if (stored) {
+                await this.cursor.clear();
+            }
+        }
+        if (effectiveToken)
+            params.cursor = effectiveToken;
+        let queryResponse;
+        try {
+            ({ data: queryResponse } = await this.http.get(API_ENDPOINTS.forYouFeed, { params }));
+        }
+        catch (error) {
+            if (error instanceof ASCApiError && error.code === 400400 /* Amity.ServerError.ITEM_NOT_FOUND */) {
+                throw new AmityForYouFeedDisabledError();
+            }
+            const recoverable = error instanceof ASCApiError && error.code === 400000 /* Amity.ServerError.BAD_REQUEST */;
+            if (recoverable && effectiveToken !== undefined) {
+                if (this.cursor)
+                    await this.cursor.clear();
+                ({ data: queryResponse } = await this.http.get(API_ENDPOINTS.forYouFeed, { params: { limit: COLLECTION_DEFAULT_PAGINATION_SIZE } }));
+            }
+            else {
+                throw error;
+            }
+        }
+        await this.persistCursor(queryResponse);
+        return queryResponse;
+    }
+    async persistCursor(response) {
+        var _a, _b;
+        if (!this.cursor)
+            return;
+        const cursor = (_a = response.paging) === null || _a === void 0 ? void 0 : _a.next;
+        const expiredAtIso = (_b = response.paging) === null || _b === void 0 ? void 0 : _b.expiredAt;
+        if (!cursor || !expiredAtIso)
+            return;
+        const expiredAt = Date.parse(expiredAtIso);
+        if (Number.isNaN(expiredAt))
+            return;
+        await this.cursor.set({ cursor, expiredAt });
+    }
+}
+
+class ForYouFeedQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache)
+            ingestInCache(processedPayload, { cachedAt });
+    }
+    appendToQueryStream(response, _direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.posts.map(getResolver('post')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const posts = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...posts, ...response.posts.map(getResolver('post'))])] }));
+        }
+    }
+    reactor(action) {
+        return (post) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (post.parentPostId && !collection.data.includes(post.parentPostId))
+                return;
+            if (action === EnumPostActions.OnPostDeleted || action === EnumPostActions.OnPostDeclined) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+const FOR_YOU_FEED_CACHE_KEY = ['forYouFeed', 'collection'];
+class ForYouFeedLiveCollectionController extends LiveCollectionController {
+    constructor(callback) {
+        const queryStreamId = `for-you-feed-${getActiveClient().userId}`;
+        const query = {};
+        const paginationController = new ForYouFeedPaginationController(query);
+        super(paginationController, queryStreamId, FOR_YOU_FEED_CACHE_KEY, callback);
+        this.queryStreamController = new ForYouFeedQueryStreamController(query, this.cacheKey, this.notifyChange.bind(this), preparePostPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            pushToCache(this.cacheKey, { data: [], params: {} });
+    }
+    async persistModel(payload) {
+        await this.queryStreamController.saveToMainDB(payload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE(getGlobalFeedSubscriptions(this.cacheKey));
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = ((_b = collection.data
+            .map(id => pullFromCache(['post', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.post);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
+
+/* begin_public_function
+  id: feed.query.for_you_feed
+*/
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk'
+ *
+ * const unsub = FeedRepository.getForYouFeed(({ data, loading, error, hasNextPage, onNextPage }) => {
+ *   // render posts; call onNextPage() to load the next page (20 posts)
+ * })
+ * ```
+ *
+ * Observe the For You feed — a personalized, server-ranked
+ * {@link Amity.LiveCollection} of {@link Amity.Post}.
+ *
+ * @param callback the function to call when new data is available
+ * @returns an {@link Amity.Unsubscriber} function to stop observing
+ *
+ * @category Posts Live Collection
+ */
+const getForYouFeed = (callback) => {
+    const { log, cache } = getActiveClient();
+    if (!cache)
+        console.log(ENABLE_CACHE_MESSAGE);
+    const timestamp = Date.now();
+    log(`getForYouFeed(tmpid: ${timestamp}) > listen`);
+    const forYouFeedLiveCollection = new ForYouFeedLiveCollectionController(callback);
+    const disposers = forYouFeedLiveCollection.startSubscription();
+    const cacheKey = forYouFeedLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getForYouFeed(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
 var index$d = /*#__PURE__*/Object.freeze({
     __proto__: null,
     queryGlobalFeed: queryGlobalFeed,
     getCustomRankingGlobalFeed: getCustomRankingGlobalFeed,
     getGlobalFeed: getGlobalFeed,
     getUserFeed: getUserFeed,
-    getCommunityFeed: getCommunityFeed
+    getCommunityFeed: getCommunityFeed,
+    getForYouFeed: getForYouFeed,
+    AmityForYouFeedDisabledError: AmityForYouFeedDisabledError
 });
 
 /* begin_public_function
@@ -35707,6 +36005,7 @@ exports.getMarkerUserFeedTopic = getMarkerUserFeedTopic;
 exports.getMessageTopic = getMessageTopic;
 exports.getMyFollowersTopic = getMyFollowersTopic;
 exports.getMyFollowingsTopic = getMyFollowingsTopic;
+exports.getNetworkId = getNetworkId;
 exports.getNetworkTopic = getNetworkTopic;
 exports.getPostTopic = getPostTopic;
 exports.getRole = getRole;