@softtynet/zca-js 2.2.8 → 2.2.10

package/dist/apis/group/getRelatedFriendGroup.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getRelatedFriendGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/group/related`);
+    /**
+     * Get related friend group
+     *
+     * @param friendId friend ids
+     *
+     * @note this API is used for zBusiness
+     * @throws {ZaloApiError}
+     */
+    return async function getRelatedFriendGroup(friendId) {
+        const friendIds = Array.isArray(friendId) ? friendId : [friendId];
+        const params = {
+            friend_ids: JSON.stringify(friendIds),
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/inviteUserToGroups.d.ts

@@ -0,0 +1,10 @@
+export type InviteUserToGroupsResponse = {
+    grid_message_map: {
+        [groupId: string]: {
+            error_code: number;
+            error_message: string;
+            data: string | null;
+        };
+    };
+};
+export declare const inviteUserToGroupsFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (userId: string, groupId: string | string[]) => Promise<InviteUserToGroupsResponse>;

package/dist/apis/group/inviteUserToGroups.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const inviteUserToGroupsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/invite/multi`);
+    /**
+     * Invite user to group
+     *
+     * @param groupId group ID(s)
+     * @param memberId member ID
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function inviteUserToGroups(userId, groupId) {
+        const params = {
+            grids: Array.isArray(groupId) ? groupId : [groupId],
+            member: userId,
+            memberType: -1,
+            srcInteraction: 2,
+            clientLang: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/joinGroupInviteBox.d.ts

@@ -0,0 +1,2 @@
+export type JoinGroupInviteBoxResponse = "";
+export declare const joinGroupInviteBoxFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string) => Promise<"">;

package/dist/apis/group/joinGroupInviteBox.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const joinGroupInviteBoxFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/inv-box/join`);
+    /**
+     * Join group invite box
+     *
+     * @param groupId - The group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function joinGroupInviteBox(groupId) {
+        const params = {
+            grid: groupId,
+            lang: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/joinGroupLink.d.ts

@@ -0,0 +1,2 @@
+export type JoinGroupLinkResponse = "";
+export declare const joinGroupLinkFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (link: string) => Promise<"">;

package/dist/apis/group/joinGroupLink.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const joinGroupLinkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/join`);
+    /**
+     * Join group via invite link
+     *
+     * @note Zalo might throw an error with code 240 if the group enabled membership approval, 178 if you are already a member.
+     *
+     * @param link - The link join group
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function joinGroupLink(link) {
+        const params = {
+            link: link,
+            clientLang: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/leaveGroup.d.ts

@@ -0,0 +1,4 @@
+export type LeaveGroupResponse = {
+    memberError: unknown[];
+};
+export declare const leaveGroupFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string, silent?: boolean) => Promise<LeaveGroupResponse>;

package/dist/apis/group/leaveGroup.js

@@ -0,0 +1,33 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const leaveGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/leave`);
+    /**
+     * Leave group
+     *
+     * @param groupId - groupId to leave
+     * @param silent - Turn on/off silent leave group
+     *
+     * @note Zalo might throw an error with code 166 if you are not a member of the group
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function leaveGroup(groupId, silent = false) {
+        const requestParams = {
+            grids: [groupId], // API only supports leaving one group at a time
+            imei: ctx.imei,
+            silent: silent ? 1 : 0,
+            language: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/removeGroupBlockedMember.d.ts

@@ -0,0 +1,2 @@
+export type RemoveGroupBlockedMemberResponse = "";
+export declare const removeGroupBlockedMemberFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (memberId: string | string[], groupId: string) => Promise<"">;

package/dist/apis/group/removeGroupBlockedMember.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const removeGroupBlockedMemberFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/blockedmems/remove`);
+    /**
+     * Remove group blocked member
+     *
+     * @param memberId member id(s)
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeGroupBlockedMember(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/removeGroupDeputy.d.ts

@@ -0,0 +1,2 @@
+export type RemoveGroupDeputyResponse = "";
+export declare const removeGroupDeputyFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (memberId: string | string[], groupId: string) => Promise<"">;

package/dist/apis/group/removeGroupDeputy.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const removeGroupDeputyFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/admins/remove`);
+    /**
+     * Remove group deputy
+     *
+     * @param memberId user Id or list of user Ids
+     * @param groupId group Id
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function removeGroupDeputy(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/removeUserFromGroup.d.ts

@@ -0,0 +1,4 @@
+export type RemoveUserFromGroupResponse = {
+    errorMembers: string[];
+};
+export declare const removeUserFromGroupFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (memberId: string | string[], groupId: string) => Promise<RemoveUserFromGroupResponse>;

package/dist/apis/group/removeUserFromGroup.js

@@ -0,0 +1,34 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const removeUserFromGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/kickout`);
+    /**
+     * Remove user from existing group
+     *
+     * @param memberId User ID or list of user IDs to remove
+     * @param groupId Group ID
+     *
+     * @note Zalo might throw an error with code 165 if the user is not in the group, 166 if you don't have enough permissions or is not in the group
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function removeUserFromGroup(memberId, groupId) {
+        if (!Array.isArray(memberId))
+            memberId = [memberId];
+        const params = {
+            grid: groupId,
+            members: memberId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/reviewPendingMemberRequest.d.ts

@@ -0,0 +1,14 @@
+export type ReviewPendingMemberRequestPayload = {
+    members: string | string[];
+    isApprove: boolean;
+};
+export declare enum ReviewPendingMemberRequestStatus {
+    SUCCESS = 0,
+    NOT_IN_PENDING_LIST = 170,
+    ALREADY_IN_GROUP = 178,
+    INSUFFICIENT_PERMISSION = 166
+}
+export type ReviewPendingMemberRequestResponse = {
+    [memberId: string]: ReviewPendingMemberRequestStatus;
+};
+export declare const reviewPendingMemberRequestFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (payload: ReviewPendingMemberRequestPayload, groupId: string) => Promise<ReviewPendingMemberRequestResponse>;

package/dist/apis/group/reviewPendingMemberRequest.js

@@ -0,0 +1,38 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export var ReviewPendingMemberRequestStatus;
+(function (ReviewPendingMemberRequestStatus) {
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["SUCCESS"] = 0] = "SUCCESS";
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["NOT_IN_PENDING_LIST"] = 170] = "NOT_IN_PENDING_LIST";
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["ALREADY_IN_GROUP"] = 178] = "ALREADY_IN_GROUP";
+    ReviewPendingMemberRequestStatus[ReviewPendingMemberRequestStatus["INSUFFICIENT_PERMISSION"] = 166] = "INSUFFICIENT_PERMISSION";
+})(ReviewPendingMemberRequestStatus || (ReviewPendingMemberRequestStatus = {}));
+export const reviewPendingMemberRequestFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/pending-mems/review`);
+    /**
+     * Review pending member(s) request
+     *
+     * @param payload - The payload containing data to review the pending member(s) request
+     * @param groupId - The id of the group to review the pending member(s) request
+     *
+     * @note Only the group leader and deputy group leader can review
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function reviewPendingMemberRequest(payload, groupId) {
+        if (!Array.isArray(payload.members))
+            payload.members = [payload.members];
+        const params = {
+            grid: groupId,
+            members: payload.members,
+            isApprove: payload.isApprove ? 1 : 0, // 1: approve, 0: reject
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/updateGroupSettings.d.ts

@@ -0,0 +1,40 @@
+export type UpdateGroupSettingsOptions = {
+    /**
+     * Disallow group members to change the group name and avatar
+     */
+    blockName?: boolean;
+    /**
+     * Highlight messages from owner/admins
+     */
+    signAdminMsg?: boolean;
+    /**
+     * Don't pin messages, notes, and polls to the top of a conversation
+     */
+    setTopicOnly?: boolean;
+    /**
+     * Allow new members to read most recent messages
+     */
+    enableMsgHistory?: boolean;
+    /**
+     * Membership approval
+     */
+    joinAppr?: boolean;
+    /**
+     * Disallow group members to create notes & reminders
+     */
+    lockCreatePost?: boolean;
+    /**
+     * Disallow group members to create polls
+     */
+    lockCreatePoll?: boolean;
+    /**
+     * Disallow group members to send messages
+     */
+    lockSendMsg?: boolean;
+    /**
+     * Disallow group members to view full member list (community only)
+     */
+    lockViewMember?: boolean;
+};
+export type UpdateGroupSettingsResponse = "";
+export declare const updateGroupSettingsFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: UpdateGroupSettingsOptions, groupId: string) => Promise<"">;

package/dist/apis/group/updateGroupSettings.js

@@ -0,0 +1,43 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const updateGroupSettingsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/setting/update`);
+    /**
+     * Update group settings
+     *
+     * @param options Options
+     * @param groupId Group ID
+     *
+     * @note Zalo might throw an error with code 166 if you don't have enough permissions to change the settings.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateGroupSettings(options, groupId) {
+        const params = {
+            blockName: options.blockName ? 1 : 0,
+            signAdminMsg: options.signAdminMsg ? 1 : 0,
+            // addMemberOnly: 0, // very tricky, any idea?
+            setTopicOnly: options.setTopicOnly ? 1 : 0,
+            enableMsgHistory: options.enableMsgHistory ? 1 : 0,
+            joinAppr: options.joinAppr ? 1 : 0,
+            lockCreatePost: options.lockCreatePost ? 1 : 0,
+            lockCreatePoll: options.lockCreatePoll ? 1 : 0,
+            lockSendMsg: options.lockSendMsg ? 1 : 0,
+            lockViewMember: options.lockViewMember ? 1 : 0,
+            // default values for not implemented options
+            bannFeature: 0,
+            dirtyMedia: 0,
+            banDuration: 0,
+            blocked_members: [],
+            grid: groupId,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/group/upgradeGroupToCommunity.d.ts

@@ -0,0 +1,2 @@
+export type UpgradeGroupToCommunityResponse = "";
+export declare const upgradeGroupToCommunityFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string) => Promise<"">;

package/dist/apis/group/upgradeGroupToCommunity.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const upgradeGroupToCommunityFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/upgrade/community`);
+    /**
+     * Upgrade group to community
+     *
+     * @param groupId Group ID upgrade
+     *
+     * @note Zalo account identity must be verified and the account must be over 18 to use
+     * @code 185 The limit on the number of communities that can own has been reached
+     * @throws {ZaloApiError}
+     */
+    return async function upgradeGroupToCommunity(groupId) {
+        const params = {
+            grId: groupId,
+            language: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/listen.d.ts

@@ -1,119 +1 @@
-import EventEmitter from "events";
-import { type FriendEvent } from "../models/FriendEvent.js";
-import { type GroupEvent } from "../models/GroupEvent.js";
-import type { Message, Typing } from "../models/index.js";
-import { Reaction, Undo, ThreadType } from "../models/index.js";
-import type { ContextSession } from "../context.js";
-import { type SeenMessage } from "../models/SeenMessage.js";
-import { type DeliveredMessage } from "../models/DeliveredMessage.js";
-import { ClearUnread } from "../models/ClearUnread.js";
-import { type SyncEvent } from "../models/SyncEvent.js";
-import { type CallEvent } from "../models/CallEvent.js";
-type UploadEventData = {
-    fileUrl: string;
-    fileId: string;
-};
-export type WsPayload<T = Record<string, unknown>> = {
-    version: number;
-    cmd: number;
-    subCmd: number;
-    data: T;
-};
-export type OnMessageCallback = (message: Message) => unknown;
-export type OnClosedCallback = (code: CloseReason, reason: string) => unknown;
-export type OnErrorCallback = (error: unknown) => unknown;
-export declare enum CloseReason {
-    ManualClosure = 1000,
-    AbnormalClosure = 1006,
-    DuplicateConnection = 3000,
-    KickConnection = 3003
-}
-interface ListenerEvents {
-    connected: [];
-    disconnected: [code: CloseReason, reason: string];
-    reconnecting: [code: CloseReason];
-    closed: [code: CloseReason, reason: string];
-    error: [error: unknown];
-    typing: [typing: Typing];
-    message: [message: Message];
-    old_messages: [messages: Message[], type: ThreadType, hasMore?: boolean];
-    seen_messages: [messages: SeenMessage[]];
-    delivered_messages: [messages: DeliveredMessage[]];
-    unread_cleared: [items: ClearUnread[]];
-    reaction: [reaction: Reaction];
-    old_reactions: [reactions: Reaction[], isGroup: boolean];
-    upload_attachment: [data: UploadEventData];
-    undo: [data: Undo];
-    friend_event: [data: FriendEvent];
-    group_event: [data: GroupEvent];
-    sync_event: [data: SyncEvent];
-    call_event: [data: CallEvent];
-    cipher_key: [key: string];
-    ping: [];
-    pong: [];
-}
-export declare class Listener extends EventEmitter<ListenerEvents> {
-    private ctx;
-    private urls;
-    private wsURL;
-    private cookie;
-    private userAgent;
-    private ws;
-    private retryCount;
-    private rotateCount;
-    private onConnectedCallback;
-    private onClosedCallback;
-    private onErrorCallback;
-    private onMessageCallback;
-    private cipherKey?;
-    private selfListen;
-    private pingInterval?;
-    private retryTimeout?;
-    private watchdogTimeout?;
-    private consecutive1006Count;
-    private id;
-    constructor(ctx: ContextSession, urls: string[]);
-    /**
-     * @deprecated Use `on` method instead
-     */
-    onConnected(cb: () => unknown): void;
-    /**
-     * @deprecated Use `on` method instead
-     */
-    onClosed(cb: OnClosedCallback): void;
-    /**
-     * @deprecated Use `on` method instead
-     */
-    onError(cb: OnErrorCallback): void;
-    /**
-     * @deprecated Use `on` method instead
-     */
-    onMessage(cb: OnMessageCallback): void;
-    private isRetryable;
-    private canRetry;
-    private resetRetryCount;
-    private resetWatchdog;
-    private shouldRotate;
-    private rotateEndpoint;
-    start({ retryOnClose }?: {
-        retryOnClose?: boolean;
-    }): void;
-    stop(): void;
-    sendWs(payload: WsPayload, requireId?: boolean): void;
-    /**
-     * Request old messages from Zalo WebSocket queue (`cmd 510` for User, `cmd 511` for Group).
-     * When `lastMsgId` is `null` or omitted, defaults to `"10000000000000000"` to fetch the latest offline messages.
-     *
-     * @param threadType ThreadType.User or ThreadType.Group
-     * @param lastMsgId Optional cursor message ID (`actionId`) for pagination
-     */
-    requestOldMessages(threadType: ThreadType, lastMsgId?: string | null): void;
-    /**
-     * Request old messages
-     *
-     * @param lastMsgId
-     */
-    requestOldReactions(threadType: ThreadType, lastMsgId?: string | null): void;
-    private reset;
-}
-export {};
+export * from "../realtime/index.js";