@amityco/ts-sdk 7.4.1-0e170b02.0 → 7.4.1-108e44a8.0

package/dist/index.cjs.js

@@ -650,6 +650,7 @@ const PAYLOAD2MODEL = {
     pins: 'pin',
     notificationTrayItems: 'notificationTrayItem',
     invitations: 'invitation',
+    joinRequests: 'joinRequest',
 };
 /** hidden */
 const isOutdated = (prevData, nextData) => {
@@ -7482,11 +7483,8 @@ const approveJoinRequest = async (joinRequest) => {
     const client = getActiveClient();
     client.log('joinRequest/approveJoinRequest', joinRequest.joinRequestId);
     const { data } = await client.http.post(`/api/v4/communities/${joinRequest.targetId}/join/approve`, {
-        params: {
-            userId: joinRequest.userId,
-        },
+        userId: joinRequest.requestorInternalId,
     });
-    // TODO : Check cache id
     const joinRequestCache = (_a = pullFromCache([
         'joinRequest',
         'get',
@@ -7523,11 +7521,7 @@ const cancelJoinRequest = async (joinRequest) => {
     var _a;
     const client = getActiveClient();
     client.log('joinRequest/cancelJoinRequest', joinRequest.joinRequestId);
-    const { data } = await client.http.delete(`/api/v4/communities/${joinRequest.targetId}/join`, {
-        params: {
-            userId: joinRequest.userId,
-        },
-    });
+    const { data } = await client.http.delete(`/api/v4/communities/${joinRequest.targetId}/join`);
     const joinRequestCache = (_a = pullFromCache([
         'joinRequest',
         'get',
@@ -7562,7 +7556,9 @@ const rejectJoinRequest = async (joinRequest) => {
     var _a;
     const client = getActiveClient();
     client.log('joinRequest/rejectJoinRequest', joinRequest.joinRequestId);
-    const { data } = await client.http.post(`/api/v4/communities/${joinRequest.targetId}/join/reject`);
+    const { data } = await client.http.post(`/api/v4/communities/${joinRequest.targetId}/join/reject`, {
+        userId: joinRequest.requestorInternalId,
+    });
     const joinRequestCache = (_a = pullFromCache([
         'joinRequest',
         'get',
@@ -7580,17 +7576,16 @@ const rejectJoinRequest = async (joinRequest) => {
 
 const joinRequestLinkedObject = (joinRequest) => {
     return Object.assign(Object.assign({}, joinRequest), { get user() {
-            const cacheData = pullFromCache(['user', 'get', joinRequest.userId]);
-            if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data)
-                return userLinkedObject(cacheData.data);
-            return undefined;
-        }, cancel: async () => {
-            await cancelJoinRequest(joinRequest);
-        }, approve: async () => {
-            await approveJoinRequest(joinRequest);
-        }, reject: async () => {
-            await rejectJoinRequest(joinRequest);
-        } });
+            var _a;
+            const user = (_a = pullFromCache([
+                'user',
+                'get',
+                joinRequest.requestorPublicId,
+            ])) === null || _a === void 0 ? void 0 : _a.data;
+            if (!user)
+                return undefined;
+            return userLinkedObject(user);
+        }, cancel: () => cancelJoinRequest(joinRequest), approve: () => approveJoinRequest(joinRequest), reject: () => rejectJoinRequest(joinRequest) });
 };
 
 /* begin_public_function
@@ -7643,6 +7638,7 @@ const getMyJoinRequest = async (communityId) => {
  * @async
  */
 const joinRequest = async (communityId) => {
+    var _a;
     const client = getActiveClient();
     client.log('community/joinRequest', communityId);
     const { data: payload } = await client.http.post(`/api/v4/communities/${communityId}/join`);
@@ -7650,8 +7646,17 @@ const joinRequest = async (communityId) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    fireEvent('local.community.join', data.joinRequests);
-    const status = data.joinRequests.length === 0 ? "success" /* JoinResultStatusEnum.Success */ : "pending" /* JoinResultStatusEnum.Pending */;
+    const status = data.joinRequests[0].status === "approved" /* JoinRequestStatusEnum.Approved */
+        ? "success" /* JoinResultStatusEnum.Success */
+        : "pending" /* JoinResultStatusEnum.Pending */;
+    if (status === "success" /* JoinResultStatusEnum.Success */ && client.cache) {
+        const community = (_a = pullFromCache(['community', 'get', communityId])) === null || _a === void 0 ? void 0 : _a.data;
+        if (community) {
+            const updatedCommunity = Object.assign(Object.assign({}, community), { isJoined: true });
+            upsertInCache(['community', 'get', communityId], updatedCommunity);
+        }
+    }
+    fireEvent('v4.local.community.joined', data.joinRequests);
     return status === "success" /* JoinResultStatusEnum.Success */
         ? { status }
         : { status, request: joinRequestLinkedObject(data.joinRequests[0]) };
@@ -7725,12 +7730,12 @@ class QueryStreamController {
     }
 }
 
-var EnumJoinRequestAction;
+var EnumJoinRequestAction$1;
 (function (EnumJoinRequestAction) {
     EnumJoinRequestAction["OnLocalJoinRequestCreated"] = "OnLocalJoinRequestCreated";
     EnumJoinRequestAction["OnLocalJoinRequestUpdated"] = "OnLocalJoinRequestUpdated";
     EnumJoinRequestAction["OnLocalJoinRequestDeleted"] = "OnLocalJoinRequestDeleted";
-})(EnumJoinRequestAction || (EnumJoinRequestAction = {}));
+})(EnumJoinRequestAction$1 || (EnumJoinRequestAction$1 = {}));
 
 class JoinRequestsQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
@@ -7770,12 +7775,12 @@ class JoinRequestsQueryStreamController extends QueryStreamController {
             const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
             if (!collection)
                 return;
-            if (action === EnumJoinRequestAction.OnLocalJoinRequestUpdated) {
+            if (action === EnumJoinRequestAction$1.OnLocalJoinRequestUpdated) {
                 const isExist = collection.data.find(id => id === joinRequest[0].joinRequestId);
                 if (!isExist)
                     return;
             }
-            if (action === EnumJoinRequestAction.OnLocalJoinRequestCreated) {
+            if (action === EnumJoinRequestAction$1.OnLocalJoinRequestCreated) {
                 collection.data = [
                     ...new Set([
                         ...joinRequest.map(joinRequest => joinRequest.joinRequestId),
@@ -7783,7 +7788,7 @@ class JoinRequestsQueryStreamController extends QueryStreamController {
                     ]),
                 ];
             }
-            if (action === EnumJoinRequestAction.OnLocalJoinRequestDeleted) {
+            if (action === EnumJoinRequestAction$1.OnLocalJoinRequestDeleted) {
                 collection.data = collection.data.filter(id => id !== joinRequest[0].joinRequestId);
             }
             pushToCache(this.cacheKey, collection);
@@ -8035,9 +8040,9 @@ class JoinRequestsLiveCollectionController extends LiveCollectionController {
     }
     startSubscription() {
         return this.queryStreamController.subscribeRTE([
-            { fn: onJoinRequestCreated, action: EnumJoinRequestAction.OnLocalJoinRequestCreated },
-            { fn: onJoinRequestUpdated, action: EnumJoinRequestAction.OnLocalJoinRequestUpdated },
-            { fn: onJoinRequestDeleted, action: EnumJoinRequestAction.OnLocalJoinRequestDeleted },
+            { fn: onJoinRequestCreated, action: EnumJoinRequestAction$1.OnLocalJoinRequestCreated },
+            { fn: onJoinRequestUpdated, action: EnumJoinRequestAction$1.OnLocalJoinRequestUpdated },
+            { fn: onJoinRequestDeleted, action: EnumJoinRequestAction$1.OnLocalJoinRequestDeleted },
         ]);
     }
     notifyChange({ origin, loading, error }) {
@@ -8615,9 +8620,7 @@ const communityLinkedObject = (community) => {
         }, getInvitation: async () => {
             const { data } = await getInvitation('community', community.communityId);
             return data;
-        }, join: async () => {
-            return joinRequest(community.communityId);
-        }, getJoinRequests: (params, callback) => {
+        }, join: joinRequest(community.communityId), getJoinRequests: (params, callback) => {
             return getJoinRequests(Object.assign(Object.assign({}, params), { communityId: community.communityId }), callback);
         }, getMyJoinRequest: async () => {
             const { data } = await getMyJoinRequest(community.communityId);
@@ -19575,10 +19578,11 @@ const saveCommunityUsers = (communities, communityUsers) => {
 const getCommunities$1 = async (communityIds, includeDiscoverablePrivateCommunity) => {
     const client = getActiveClient();
     client.log('community/getCommunities', communityIds);
+    const encodedCommunityIds = communityIds.map(communityId => encodeURIComponent(communityId));
     // API-FIX: endpoint should not be /list, parameters should be querystring.
     const { data: payload } = await client.http.get(`/api/v3/communities/list`, {
         params: {
-            communityIds,
+            communityIds: encodedCommunityIds,
             includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity !== null && includeDiscoverablePrivateCommunity !== void 0 ? includeDiscoverablePrivateCommunity : true,
         },
     });
@@ -20443,6 +20447,19 @@ const onLocalCommunityJoined = (callback) => createLocalCommunityMemberEventSubs
 
 const onLocalCommunityLeft = (callback) => createLocalCommunityMemberEventSubscriber('local.community.left', callback);
 
+const onLocalCommunityJoin = (callback) => {
+    const client = getActiveClient();
+    const filter = async (rawPayload) => {
+        callback(rawPayload[0]);
+    };
+    const disposers = [
+        createEventSubscriber(client, 'onCommunityUpdate', 'v4.local.community.joined', filter),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
  * import { onLocalCommunityRoleRemoved } from '@amityco/ts-sdk'
@@ -20929,7 +20946,8 @@ var index$d = /*#__PURE__*/Object.freeze({
   onCommunityJoined: onCommunityJoined,
   onCommunityLeft: onCommunityLeft,
   onLocalCommunityJoined: onLocalCommunityJoined,
-  onLocalCommunityLeft: onLocalCommunityLeft
+  onLocalCommunityLeft: onLocalCommunityLeft,
+  onLocalCommunityJoin: onLocalCommunityJoin
 });
 
 class SearchCommunityLiveCollectionController extends LiveCollectionController {
@@ -21153,6 +21171,10 @@ class CommunityLiveCollectionController extends LiveCollectionController {
             { fn: onCommunityUserChanged, action: EnumCommunityMemberActions$1.OnMemberCountChanged },
             { fn: onLocalCommunityJoined, action: EnumCommunityMemberActions$1.OnCommunityJoined },
             { fn: onLocalCommunityLeft, action: EnumCommunityMemberActions$1.OnCommunityLeft },
+            {
+                fn: convertEventPayload(onLocalCommunityJoin, 'targetId', 'community'),
+                action: EnumCommunityActions$3.OnCommunityUpdated,
+            },
         ]);
     }
     notifyChange({ origin, loading, error }) {
@@ -21276,6 +21298,7 @@ const getCommunity = (communityId, callback) => {
         onCommunityUserBanned,
         onCommunityUserUnbanned,
         onCommunityUserChanged,
+        convertEventPayload(onLocalCommunityJoin, 'targetId', 'community'),
     ]);
 };
 /* end_public_function */
@@ -21792,6 +21815,200 @@ const semanticSearchCommunities = (params, callback, config) => {
     };
 };
 
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+class JoinRequestListPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, communityIds } = queryParams, params = __rest(queryParams, ["limit", "communityIds"]);
+        const options = token ? { token } : { limit };
+        const encodedChannelIds = communityIds.map(communityId => encodeURIComponent(communityId));
+        const { data: queryResponse } = await this.http.get(`/api/v4/communities/join/requests`, {
+            params: Object.assign(Object.assign({}, params), { options, communityIds: encodedChannelIds }),
+        });
+        return queryResponse;
+    }
+}
+
+var EnumJoinRequestAction;
+(function (EnumJoinRequestAction) {
+    EnumJoinRequestAction["OnLocalJoinRequestCreated"] = "OnLocalJoinRequestCreated";
+    EnumJoinRequestAction["OnLocalJoinRequestUpdated"] = "OnLocalJoinRequestUpdated";
+    EnumJoinRequestAction["OnLocalJoinRequestDeleted"] = "OnLocalJoinRequestDeleted";
+})(EnumJoinRequestAction || (EnumJoinRequestAction = {}));
+
+class JoinRequestListQueryStreamController 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.joinRequests.map(joinRequest => getResolver('joinRequest')({ joinRequestId: joinRequest._id })),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const joinRequests = (_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([
+                        ...joinRequests,
+                        ...response.joinRequests.map(joinRequest => getResolver('joinRequest')({ joinRequestId: joinRequest._id })),
+                    ]),
+                ] }));
+        }
+    }
+    reactor(action) {
+        return (joinRequest) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === EnumJoinRequestAction.OnLocalJoinRequestUpdated) {
+                const isExist = collection.data.find(id => id === joinRequest[0].joinRequestId);
+                if (!isExist)
+                    return;
+            }
+            if (action === EnumJoinRequestAction.OnLocalJoinRequestCreated) {
+                collection.data = [
+                    ...new Set([
+                        ...joinRequest.map(joinRequest => joinRequest.joinRequestId),
+                        ...collection.data,
+                    ]),
+                ];
+            }
+            if (action === EnumJoinRequestAction.OnLocalJoinRequestDeleted) {
+                collection.data = collection.data.filter(id => id !== joinRequest[0].joinRequestId);
+            }
+            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)));
+    }
+}
+
+class JoinRequestListLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['joinRequestList', 'collection', queryStreamId];
+        const paginationController = new JoinRequestListPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new JoinRequestListQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommunityJoinRequestPayload);
+        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: this.query,
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        const joinRequestResponse = response;
+        this.queryStreamController.appendToQueryStream(joinRequestResponse, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            { fn: onJoinRequestCreated, action: EnumJoinRequestAction.OnLocalJoinRequestCreated },
+            { fn: onJoinRequestUpdated, action: EnumJoinRequestAction.OnLocalJoinRequestUpdated },
+            { fn: onJoinRequestDeleted, action: EnumJoinRequestAction.OnLocalJoinRequestDeleted },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = this.applyFilter(collection.data
+            .map(id => pullFromCache(['joinRequest', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)
+            .map(joinRequestLinkedObject));
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    applyFilter(data) {
+        let joinRequest = data;
+        if (this.query.communityIds && this.query.communityIds.length > 0) {
+            joinRequest = joinRequest.filter(joinRequest => this.query.communityIds.some(id => id === joinRequest.targetId));
+        }
+        const sortFn = (() => {
+            switch (this.query.sortBy) {
+                case 'firstCreated':
+                    return sortByFirstCreated;
+                case 'lastCreated':
+                    return sortByLastCreated;
+                default:
+                    return sortByLastCreated;
+            }
+        })();
+        joinRequest = joinRequest.sort(sortFn);
+        return joinRequest;
+    }
+}
+
+/* begin_public_function
+  id: community.getJoinRequestList
+*/
+/**
+ * Get Join Requests
+ *
+ * @param params the query parameters
+ * @param callback the callback to be called when the join request are updated
+ * @returns joinRequest[]
+ *
+ * @category joinRequestList Live Collection
+ *
+ */
+const getJoinRequestList = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getJoinRequestList: (tmpid: ${timestamp}) > listen`);
+    const joinRequestListLiveCollection = new JoinRequestListLiveCollectionController(params, callback);
+    const disposers = joinRequestListLiveCollection.startSubscription();
+    const cacheKey = joinRequestListLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getJoinRequestList (tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
 var AmityCommunityMemberStatusFilter;
 (function (AmityCommunityMemberStatusFilter) {
     AmityCommunityMemberStatusFilter["ALL"] = "all";
@@ -21962,6 +22179,7 @@ var index$b = /*#__PURE__*/Object.freeze({
   getTrendingCommunities: getTrendingCommunities,
   getRecommendedCommunities: getRecommendedCommunities,
   semanticSearchCommunities: semanticSearchCommunities,
+  getJoinRequestList: getJoinRequestList,
   get AmityCommunityMemberStatusFilter () { return AmityCommunityMemberStatusFilter; }
 });