Free, Open Source, Self-Hosted WhatsApp API Gateway
TypeScript apibotgatewayself-hostedwhatsappwhatsapp-apiwhatsapp-automationwhatsapp-botwhatsapp-gatewaywhatsapp-gateway-apiwhatsapp-webwhatsapp-web-api
import { Boom } from '@hapi/boom';
import type { Client } from 'whatsapp-web.js';
import type { WASocket } from '@whiskeysockets/baileys';
import { BaileysChannels, type BaileysChannelsHost } from './baileys-channels';
import { WwebjsChannels } from './wwebjs-channels';
import { EngineNotSupportedError } from '../../common/errors/engine-not-supported.error';
import { EngineRefusedError } from '../../common/errors/engine-refused.error';
import { EngineTransportError } from '../../common/errors/engine-transport.error';
import { createLogger } from '../../common/services/logger.service';
import { type WwebjsEngineHost } from './wwebjs-host';
/**
* Demote a channel admin back to a subscriber — the fifth of the 29.5.3 backlog.
*
* **There is no promote counterpart to pair this with, on either library.** Baileys exposes
* `newsletterDemote`, `newsletterChangeOwner` and `newsletterAdminCount` but no promote, and
* whatsapp-web.js has no `promoteChannelAdmin` at all. So the demote-only surface is the complete
* upstream capability rather than a half-wired one: an admin is promoted from the WhatsApp app and
* can then be demoted through this API.
*
* **Only Baileys can actually deliver it.** `Client.demoteChannelAdmin` exists and is typed
* `Promise<boolean>`, but its page body calls
* `window.require('WAWebDemoteNewsletterAdminAction').demoteNewsletterAdmin` — an export WhatsApp
* Web no longer provides. Measured live on Web `2.3000.1044824727-alpha` (unpinned): a `TypeError`
* reaching the caller as a bare 500, while `muteChannel` answered 200 twice on the same session, so
* the page and its module registry were healthy. The wwjs adapter therefore answers 501 rather than
* wiring a call that cannot work — see the matrix note on phantom support.
*
* Baileys resolves `void` through `executeWMexQuery`, so a refusal arrives as a Boom on the w:mex
* channel and a silent socket arrives as nothing at all. Both get the same treatment the other
* channel writes already have.
*/
const logger = createLogger('channel-admin-demote.spec');
const CHANNEL = '120363000000000000@newsletter';
const USER = '[email protected]';
const never = (): Promise<never> => new Promise<never>(() => undefined);
function wwebjs(client: Record<string, jest.Mock>): WwebjsChannels {
const host = {
ensureReady: jest.fn(),
getClient: () => client as unknown as Client,
logger,
} as unknown as WwebjsEngineHost;
return new WwebjsChannels(host);
}
/** `toEngineJid` mirrors the real session store: neutral `@c.us` becomes engine `@s.whatsapp.net`. */
function baileys(sock: Record<string, jest.Mock>, budgetMs = 500): BaileysChannels {
const host = {
ensureReady: () => undefined,
getSocket: () => sock as unknown as WASocket,
toEngineJid: (jid: string) => jid.replace('@c.us', '@s.whatsapp.net'),
} as unknown as BaileysChannelsHost;
return new BaileysChannels(host, budgetMs);
}
describe('WwebjsChannels.demoteChannelAdmin', () => {
it('answers 501 rather than calling a library method whose page module is gone', async () => {
const demoteChannelAdmin = jest.fn();
await expect(wwebjs({ demoteChannelAdmin }).demoteChannelAdmin(CHANNEL, USER)).rejects.toBeInstanceOf(
EngineNotSupportedError,
);
});
// The load-bearing half: wiring the call would produce a phantom-support row — the matrix claiming
// the capability while every request failed with a bare 500 (`TypeError: window.require(...)
// .demoteNewsletterAdmin is not a function`, measured live on Web 2.3000.1044824727-alpha).
it('does not reach the library at all, so a caller gets a verdict instead of a crash', async () => {
const demoteChannelAdmin = jest.fn();
await expect(wwebjs({ demoteChannelAdmin }).demoteChannelAdmin(CHANNEL, USER)).rejects.toThrow();
expect(demoteChannelAdmin).not.toHaveBeenCalled();
});
});
describe('BaileysChannels.demoteChannelAdmin', () => {
// The channel id needs no mapping — `@newsletter` in both dialects — but the USER jid does, which
// is why this delegate gained a mapper the other channel writes never needed.
it('maps the user id to the engine dialect and leaves the channel id alone', async () => {
const newsletterDemote = jest.fn().mockResolvedValue(undefined);
await expect(baileys({ newsletterDemote }).demoteChannelAdmin(CHANNEL, USER)).resolves.toBeUndefined();
expect(newsletterDemote).toHaveBeenCalledWith(CHANNEL, '[email protected]');
});
// The shape executeWMexQuery really throws: `Boom(msg, { statusCode: errorCode, data: firstError })`
// where `firstError` is the GraphQL error NODE — an OBJECT. A numeric `data` is the IQ channel's
// shape and would exercise a different branch of wmexRefusalCode than this path can reach.
it('maps a w:mex refusal to a refusal', async () => {
const newsletterDemote = jest.fn().mockRejectedValue(
new Boom('GraphQL server error: not-authorized', {
statusCode: 403,
data: { message: 'not-authorized', error_code: 403 },
}),
);
await expect(baileys({ newsletterDemote }).demoteChannelAdmin(CHANNEL, USER)).rejects.toBeInstanceOf(
EngineRefusedError,
);
});
it('reports an unanswered query instead of a bare 500', async () => {
await expect(
baileys({ newsletterDemote: jest.fn(never) }, 15).demoteChannelAdmin(CHANNEL, USER),
).rejects.toBeInstanceOf(EngineTransportError);
});
});