@amityco/ts-sdk 7.4.1-fd0f791a.0 → 7.5.1-12f08f0.0

package/dist/index.cjs.js

@@ -151,8 +151,8 @@ exports.JoinResultStatusEnum = void 0;
 
 function getVersion() {
     try {
-        // the string ''v7.4.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.4.0-cjs';
+        // the string ''v7.5.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.5.0-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -7586,11 +7586,11 @@ const joinRequestLinkedObject = (joinRequest) => {
                 return undefined;
             return userLinkedObject(user);
         }, cancel: async () => {
-            await cancelJoinRequest(joinRequest);
+            cancelJoinRequest(joinRequest);
         }, approve: async () => {
-            await approveJoinRequest(joinRequest);
+            approveJoinRequest(joinRequest);
         }, reject: async () => {
-            await rejectJoinRequest(joinRequest);
+            rejectJoinRequest(joinRequest);
         } });
 };
 
@@ -7644,6 +7644,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`);
@@ -7651,10 +7652,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[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]) };
@@ -7728,12 +7736,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) {
@@ -7773,12 +7781,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),
@@ -7786,7 +7794,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);
@@ -8038,9 +8046,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 }) {
@@ -8228,41 +8236,6 @@ const rejectInvitation = async (invitationId) => {
 };
 /* end_public_function */
 
-/* begin_public_function
-  id: invitation.cancel
-*/
-/**
- * ```js
- * import { cancelInvitation } from '@amityco/ts-sdk'
- * const isCanceled = await cancelInvitation(invitationId)
- * ```
- *
- * Cancels a {@link Amity.Invitation} object
- *
- * @param invitationId the {@link Amity.Invitation} to cancel
- * @returns A success boolean if the {@link Amity.Invitation} was canceled
- *
- * @category Invitation API
- * @async
- */
-const cancelInvitation = async (invitationId) => {
-    var _a;
-    const client = getActiveClient();
-    client.log('invitation/cancelInvitation', invitationId);
-    const { data } = await client.http.delete(`/api/v1/invitations/${invitationId}`);
-    const invitation = (_a = pullFromCache([
-        'invitation',
-        'get',
-        invitationId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    if (invitation) {
-        dropFromCache(['invitation', 'get', invitationId]);
-        fireEvent('local.invitation.deleted', [invitation]);
-    }
-    return data.success;
-};
-/* end_public_function */
-
 const prepareMyInvitationsPayload = (rawPayload) => {
     return Object.assign(Object.assign({}, rawPayload), { users: rawPayload.users.map(convertRawUserToInternalUser), invitations: rawPayload.invitations.map(convertRawInvitationToInternalInvitation) });
 };
@@ -8293,11 +8266,9 @@ const invitationLinkedObject = (invitation) => {
             }
             return undefined;
         }, accept: async () => {
-            await acceptInvitation(invitation._id);
+            acceptInvitation(invitation._id);
         }, reject: async () => {
-            await rejectInvitation(invitation._id);
-        }, cancel: async () => {
-            await cancelInvitation(invitation._id);
+            rejectInvitation(invitation._id);
         } });
 };
 
@@ -8618,9 +8589,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: async () => 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);
@@ -19578,10 +19547,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,
         },
     });
@@ -20446,6 +20416,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'
@@ -20932,7 +20915,8 @@ var index$d = /*#__PURE__*/Object.freeze({
   onCommunityJoined: onCommunityJoined,
   onCommunityLeft: onCommunityLeft,
   onLocalCommunityJoined: onLocalCommunityJoined,
-  onLocalCommunityLeft: onLocalCommunityLeft
+  onLocalCommunityLeft: onLocalCommunityLeft,
+  onLocalCommunityJoin: onLocalCommunityJoin
 });
 
 class SearchCommunityLiveCollectionController extends LiveCollectionController {
@@ -21156,6 +21140,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 }) {
@@ -21279,6 +21267,7 @@ const getCommunity = (communityId, callback) => {
         onCommunityUserBanned,
         onCommunityUserUnbanned,
         onCommunityUserChanged,
+        convertEventPayload(onLocalCommunityJoin, 'targetId', 'community'),
     ]);
 };
 /* end_public_function */
@@ -21795,6 +21784,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";
@@ -21965,6 +22148,7 @@ var index$b = /*#__PURE__*/Object.freeze({
   getTrendingCommunities: getTrendingCommunities,
   getRecommendedCommunities: getRecommendedCommunities,
   semanticSearchCommunities: semanticSearchCommunities,
+  getJoinRequestList: getJoinRequestList,
   get AmityCommunityMemberStatusFilter () { return AmityCommunityMemberStatusFilter; }
 });