@zapo-js/fake-server 0.3.0 → 1.0.0

package/dist/esm/api/PreKeyDispenser.js

@@ -0,0 +1,93 @@
+import { buildNotification } from '../protocol/push/notification.js';
+export class PreKeyDispenser {
+    constructor() {
+        this.capturedPreKeyBundle = null;
+        this.preKeyDispenserCursor = 0;
+        this.preKeyDispenserMisses = 0;
+        this.nextPreKeyNotificationId = 1;
+        this.preKeyBundleWaiters = new Set();
+    }
+    captureBundle(bundle) {
+        this.capturedPreKeyBundle = bundle;
+        this.preKeyDispenserCursor = 0;
+        this.preKeyDispenserMisses = 0;
+        for (const waiter of this.preKeyBundleWaiters) {
+            waiter.resolve(bundle);
+        }
+        this.preKeyBundleWaiters.clear();
+    }
+    awaitPreKeyBundle(timeoutMs = 15000) {
+        if (this.capturedPreKeyBundle) {
+            return Promise.resolve(this.capturedPreKeyBundle);
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve: (bundle) => {
+                    clearTimeout(waiter.timer);
+                    this.preKeyBundleWaiters.delete(waiter);
+                    resolve(bundle);
+                },
+                reject: (error) => {
+                    clearTimeout(waiter.timer);
+                    this.preKeyBundleWaiters.delete(waiter);
+                    reject(error);
+                },
+                timer: setTimeout(() => {
+                    this.preKeyBundleWaiters.delete(waiter);
+                    reject(new Error(`awaitPreKeyBundle timed out after ${timeoutMs}ms`));
+                }, timeoutMs)
+            };
+            this.preKeyBundleWaiters.add(waiter);
+        });
+    }
+    capturedPreKeyBundleSnapshot() {
+        return this.capturedPreKeyBundle;
+    }
+    dispenseOneTimePreKey() {
+        const bundle = this.capturedPreKeyBundle;
+        if (!bundle) {
+            this.preKeyDispenserMisses += 1;
+            return null;
+        }
+        if (this.preKeyDispenserCursor >= bundle.preKeys.length) {
+            this.preKeyDispenserMisses += 1;
+            return null;
+        }
+        const entry = bundle.preKeys[this.preKeyDispenserCursor];
+        this.preKeyDispenserCursor += 1;
+        return { keyId: entry.keyId, publicKey: entry.publicKey };
+    }
+    preKeysAvailable() {
+        const bundle = this.capturedPreKeyBundle;
+        if (!bundle)
+            return 0;
+        return Math.max(0, bundle.preKeys.length - this.preKeyDispenserCursor);
+    }
+    preKeyDispenserMissesSnapshot() {
+        return this.preKeyDispenserMisses;
+    }
+    async triggerPreKeyUpload(pipeline, options = {}) {
+        const opts = typeof options === 'number' ? { timeoutMs: options } : options;
+        const timeoutMs = opts.timeoutMs ?? 15000;
+        if (!opts.force && this.capturedPreKeyBundle) {
+            return this.capturedPreKeyBundle;
+        }
+        if (opts.force) {
+            this.capturedPreKeyBundle = null;
+            this.preKeyDispenserCursor = 0;
+        }
+        const bundlePromise = this.awaitPreKeyBundle(timeoutMs);
+        const id = `prekey-low-${this.nextPreKeyNotificationId++}`;
+        await pipeline.sendStanza(buildNotification({
+            id,
+            type: 'encrypt',
+            content: [
+                {
+                    tag: 'count',
+                    attrs: { value: '0' }
+                }
+            ]
+        }));
+        return bundlePromise;
+    }
+}

package/dist/esm/api/Scenario.js

@@ -0,0 +1,32 @@
+export class Scenario {
+    constructor(server) {
+        this.server = server;
+    }
+    onIq(matcher) {
+        return new IqExpectation(this.server, matcher);
+    }
+    afterAuth(listener) {
+        this.server.onAuthenticatedPipeline(listener);
+    }
+}
+export class IqExpectation {
+    constructor(server, matcher) {
+        this.server = server;
+        this.matcher = matcher;
+    }
+    respondWith(response) {
+        this.server.registerIqHandler(this.matcher, () => response);
+        return this;
+    }
+    respond(responder) {
+        this.server.registerIqHandler(this.matcher, responder);
+        return this;
+    }
+    respondOnce(response) {
+        const unregister = this.server.registerIqHandler(this.matcher, async (iq) => {
+            unregister();
+            return typeof response === 'function' ? response(iq) : response;
+        });
+        return this;
+    }
+}

package/dist/esm/api/ServerRegistries.js

@@ -0,0 +1,261 @@
+import { FAKE_DEFAULT_PRIVACY_SETTINGS } from '../protocol/iq/privacy.js';
+export function toUserJidPart(deviceJid) {
+    const atIdx = deviceJid.indexOf('@');
+    if (atIdx < 0)
+        return deviceJid;
+    const userPart = deviceJid.slice(0, atIdx);
+    const server = deviceJid.slice(atIdx + 1);
+    const colonIdx = userPart.indexOf(':');
+    const baseUser = colonIdx < 0 ? userPart : userPart.slice(0, colonIdx);
+    return `${baseUser}@${server}`;
+}
+export function toDeviceIdPart(deviceJid) {
+    const atIdx = deviceJid.indexOf('@');
+    if (atIdx < 0)
+        return 0;
+    const userPart = deviceJid.slice(0, atIdx);
+    const colonIdx = userPart.indexOf(':');
+    if (colonIdx < 0)
+        return 0;
+    const parsed = Number.parseInt(userPart.slice(colonIdx + 1), 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+export class ServerRegistries {
+    constructor() {
+        this.peerRegistry = new Map();
+        this.deviceIdsByUser = new Map();
+        this.groupRegistry = new Map();
+        this.privacySettings = FAKE_DEFAULT_PRIVACY_SETTINGS;
+        this.blocklistJids = new Set();
+        this.profilePicturesByJid = new Map();
+        this.businessProfilesByJid = new Map();
+        this.latestStatusText = null;
+        this.issuedPrivacyTokens = new Map();
+        this.abPropsInput = {};
+        this.groupOpListeners = new Set();
+        this.privacySetListeners = new Set();
+        this.blocklistChangeListeners = new Set();
+        this.profilePictureSetListeners = new Set();
+        this.statusSetListeners = new Set();
+        this.logoutListeners = new Set();
+        this.privacyTokenIssueListeners = new Set();
+        this.dirtyBitsClearListeners = new Set();
+    }
+    onOutboundGroupOp(listener) {
+        this.groupOpListeners.add(listener);
+        return () => {
+            this.groupOpListeners.delete(listener);
+        };
+    }
+    onOutboundPrivacySet(listener) {
+        this.privacySetListeners.add(listener);
+        return () => {
+            this.privacySetListeners.delete(listener);
+        };
+    }
+    onOutboundBlocklistChange(listener) {
+        this.blocklistChangeListeners.add(listener);
+        return () => {
+            this.blocklistChangeListeners.delete(listener);
+        };
+    }
+    onOutboundProfilePictureSet(listener) {
+        this.profilePictureSetListeners.add(listener);
+        return () => {
+            this.profilePictureSetListeners.delete(listener);
+        };
+    }
+    onOutboundStatusSet(listener) {
+        this.statusSetListeners.add(listener);
+        return () => {
+            this.statusSetListeners.delete(listener);
+        };
+    }
+    onLogout(listener) {
+        this.logoutListeners.add(listener);
+        return () => {
+            this.logoutListeners.delete(listener);
+        };
+    }
+    onOutboundPrivacyTokenIssue(listener) {
+        this.privacyTokenIssueListeners.add(listener);
+        return () => {
+            this.privacyTokenIssueListeners.delete(listener);
+        };
+    }
+    onOutboundDirtyBitsClear(listener) {
+        this.dirtyBitsClearListeners.add(listener);
+        return () => {
+            this.dirtyBitsClearListeners.delete(listener);
+        };
+    }
+    privacyTokensIssuedSnapshot() {
+        return new Map(this.issuedPrivacyTokens);
+    }
+    privacySettingsSnapshot() {
+        return this.privacySettings;
+    }
+    blocklistSnapshot() {
+        return [...this.blocklistJids].sort();
+    }
+    latestStatusSnapshot() {
+        return this.latestStatusText;
+    }
+    groupRegistrySnapshot() {
+        const out = new Map();
+        for (const [groupJid, metadata] of this.groupRegistry) {
+            out.set(groupJid, {
+                groupJid: metadata.groupJid,
+                subject: metadata.subject,
+                description: metadata.description,
+                creator: metadata.creator,
+                creationSeconds: metadata.creationSeconds,
+                participants: metadata.participants
+            });
+        }
+        return out;
+    }
+    setProfilePictureRecord(jid, picture) {
+        this.profilePicturesByJid.set(jid, picture);
+    }
+    setBusinessProfileRecord(jid, profile) {
+        this.businessProfilesByJid.set(jid, profile);
+    }
+    setAbProps(input) {
+        this.abPropsInput = input;
+    }
+    setPrivacyDisallowedList(category, jids) {
+        this.privacySettings = {
+            ...this.privacySettings,
+            disallowed: {
+                ...this.privacySettings.disallowed,
+                [category]: [...jids]
+            }
+        };
+    }
+    createFakeGroup(input) {
+        if (input.participants.length === 0) {
+            throw new Error('createFakeGroup requires at least one participant');
+        }
+        const creator = input.creator ?? toUserJidPart(input.participants[0].jid);
+        const mutable = {
+            groupJid: input.groupJid,
+            subject: input.subject ?? 'Fake Group',
+            description: input.description,
+            creator,
+            creationSeconds: input.creationSeconds ?? Math.floor(Date.now() / 1000),
+            participants: [...input.participants]
+        };
+        this.groupRegistry.set(input.groupJid, mutable);
+        return {
+            groupJid: mutable.groupJid,
+            subject: mutable.subject,
+            description: mutable.description,
+            creator: mutable.creator,
+            creationSeconds: mutable.creationSeconds,
+            participants: mutable.participants
+        };
+    }
+    mutatePrivacySettings(category, value) {
+        const next = {
+            ...this.privacySettings,
+            settings: {
+                ...this.privacySettings.settings,
+                [category]: value
+            }
+        };
+        this.privacySettings = next;
+    }
+    mutateBlocklist(action, jid) {
+        if (action === 'block') {
+            this.blocklistJids.add(jid);
+        }
+        else {
+            this.blocklistJids.delete(jid);
+        }
+    }
+    notifyGroupOp(op) {
+        for (const listener of this.groupOpListeners) {
+            try {
+                listener(op);
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    registerPeer(peer) {
+        this.peerRegistry.set(peer.jid, peer);
+        const userJid = toUserJidPart(peer.jid);
+        const deviceId = toDeviceIdPart(peer.jid);
+        const ids = this.deviceIdsByUser.get(userJid);
+        if (ids) {
+            ids.push(deviceId);
+            ids.sort((a, b) => a - b);
+        }
+        else {
+            this.deviceIdsByUser.set(userJid, [deviceId]);
+        }
+    }
+    lookupDeviceIdsForUser(userJid) {
+        return this.deviceIdsByUser.get(userJid) ?? [];
+    }
+    notifyProfilePictureSet(op) {
+        for (const listener of this.profilePictureSetListeners) {
+            try {
+                listener(op);
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    notifyStatusSet(text) {
+        for (const listener of this.statusSetListeners) {
+            try {
+                listener({ text });
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    notifyLogout() {
+        for (const listener of this.logoutListeners) {
+            try {
+                listener();
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    notifyPrivacyTokenIssue(token) {
+        for (const listener of this.privacyTokenIssueListeners) {
+            try {
+                listener(token);
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    notifyDirtyBitsClear(op) {
+        for (const listener of this.dirtyBitsClearListeners) {
+            try {
+                listener(op);
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    handleProfilePictureSet(targetJid, newId) {
+        this.profilePicturesByJid.set(targetJid, {
+            id: newId,
+            url: `https://fake-media.local/profile/${targetJid}/${newId}.jpg`,
+            directPath: `/profile/${targetJid}/${newId}.jpg`,
+            type: 'image'
+        });
+    }
+}