zapo-js 0.1.1 → 0.1.2

package/dist/esm/retry/tracker.js

@@ -0,0 +1,56 @@
+import { RETRY_OUTBOUND_TTL_MS } from './constants.js';
+import { encodeRetryReplayPayload } from './outbound.js';
+import { toError } from '../util/primitives.js';
+export function createOutboundRetryTracker(options) {
+    const { retryStore, logger } = options;
+    const retryTtlMs = retryStore.getTtlMs?.() ?? RETRY_OUTBOUND_TTL_MS;
+    const safeUpsertRetryOutboundRecord = async (record) => {
+        try {
+            await retryStore.upsertOutboundMessage(record);
+        }
+        catch (error) {
+            logger.warn('failed to persist retry outbound message record', {
+                messageId: record.messageId,
+                to: record.toJid,
+                mode: record.replayMode,
+                message: toError(error).message
+            });
+            return false;
+        }
+        return true;
+    };
+    return {
+        track: async (hint, publish) => {
+            const nowMs = Date.now();
+            const expiresAtMs = nowMs + retryTtlMs;
+            const hintedMessageId = hint.messageIdHint?.trim();
+            const replayMode = hint.replayPayload.mode;
+            const resolvedToJid = hint.toJid ?? (replayMode === 'opaque_node' ? '' : hint.replayPayload.to);
+            const replayPayload = encodeRetryReplayPayload(hint.replayPayload);
+            let hintedPersisted = false;
+            const createRetryOutboundRecord = (messageId, createdAtMs, updatedAtMs, expiresAtMs) => ({
+                messageId,
+                toJid: resolvedToJid,
+                participantJid: hint.participantJid,
+                recipientJid: hint.recipientJid,
+                messageType: hint.type,
+                replayMode,
+                replayPayload,
+                state: 'pending',
+                createdAtMs,
+                updatedAtMs,
+                expiresAtMs
+            });
+            if (hintedMessageId) {
+                hintedPersisted = await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(hintedMessageId, nowMs, nowMs, expiresAtMs));
+            }
+            const result = await publish();
+            if (hintedPersisted && hintedMessageId && result.id === hintedMessageId) {
+                return result;
+            }
+            const persistedNowMs = Date.now();
+            await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(result.id, hintedMessageId ? nowMs : persistedNowMs, persistedNowMs, persistedNowMs + retryTtlMs));
+            return result;
+        }
+    };
+}

package/dist/esm/signal/api/SignalDeviceSyncApi.js

@@ -1,8 +1,9 @@
-import { randomInt } from 'node:crypto';
-import { WA_DEFAULTS, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
+import { WA_DEFAULTS, WA_NODE_TAGS, WA_USYNC_CONTEXTS } from '../../protocol/constants.js';
 import { parseSignalAddressFromJid, splitJid } from '../../protocol/jid.js';
+import { buildUsyncIq } from '../../transport/node/builders/usync.js';
 import { findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
-import { assertIqResult, buildIqNode } from '../../transport/node/query.js';
+import { assertIqResult } from '../../transport/node/query.js';
+import { createUsyncSidGenerator } from '../../transport/node/usync.js';
 export class SignalDeviceSyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -11,6 +12,7 @@ export class SignalDeviceSyncApi {
         this.defaultTimeoutMs =
             options.defaultTimeoutMs ?? WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
+        this.generateSid = options.generateSid ?? createUsyncSidGenerator();
     }
     async syncDeviceList(userJids, timeoutMs = this.defaultTimeoutMs) {
         const normalizedUsers = this.normalizeUsers(userJids);
@@ -23,12 +25,18 @@ export class SignalDeviceSyncApi {
             ? await this.collectUsersToQuery(normalizedUsers, nowMs, cachedByUser, this.deviceListStore)
             : normalizedUsers;
         if (usersToQuery.length === 0) {
-            return normalizedUsers.map((jid) => ({
-                jid,
-                deviceJids: cachedByUser.get(jid) ?? []
-            }));
+            const fromCache = new Array(normalizedUsers.length);
+            for (let index = 0; index < normalizedUsers.length; index += 1) {
+                const jid = normalizedUsers[index];
+                fromCache[index] = {
+                    jid,
+                    deviceJids: cachedByUser.get(jid) ?? []
+                };
+            }
+            return fromCache;
         }
-        const request = this.makeDeviceSyncRequest(usersToQuery);
+        const sid = await this.generateSid();
+        const request = this.makeDeviceSyncRequest(usersToQuery, sid);
         this.logger.debug('signal device sync request', {
             users: usersToQuery.length,
             timeoutMs
@@ -37,23 +45,82 @@ export class SignalDeviceSyncApi {
         const parsed = this.parseDeviceSyncResponse(response, usersToQuery);
         if (this.deviceListStore) {
             const updatedAtMs = Date.now();
-            await this.deviceListStore.upsertUserDevicesBatch(parsed.map((entry) => ({
-                userJid: entry.jid,
-                deviceJids: entry.deviceJids,
-                updatedAtMs
-            })));
-        }
-        const parsedByUser = new Map(parsed.map((entry) => [entry.jid, entry.deviceJids]));
-        const merged = normalizedUsers.map((jid) => ({
-            jid,
-            deviceJids: parsedByUser.get(jid) ?? cachedByUser.get(jid) ?? []
-        }));
+            const batch = new Array(parsed.length);
+            for (let index = 0; index < parsed.length; index += 1) {
+                const entry = parsed[index];
+                batch[index] = {
+                    userJid: entry.jid,
+                    deviceJids: entry.deviceJids,
+                    updatedAtMs
+                };
+            }
+            await this.deviceListStore.upsertUserDevicesBatch(batch);
+        }
+        const parsedByUser = new Map();
+        for (let index = 0; index < parsed.length; index += 1) {
+            const entry = parsed[index];
+            parsedByUser.set(entry.jid, entry.deviceJids);
+        }
+        const merged = new Array(normalizedUsers.length);
+        let totalDevices = 0;
+        for (let index = 0; index < normalizedUsers.length; index += 1) {
+            const jid = normalizedUsers[index];
+            const deviceJids = parsedByUser.get(jid) ?? cachedByUser.get(jid) ?? [];
+            totalDevices += deviceJids.length;
+            merged[index] = {
+                jid,
+                deviceJids
+            };
+        }
         this.logger.debug('signal device sync success', {
             users: merged.length,
-            devices: merged.reduce((total, entry) => total + entry.deviceJids.length, 0)
+            devices: totalDevices
         });
         return merged;
     }
+    async queryLidsByPhoneJids(phoneJids, timeoutMs = this.defaultTimeoutMs) {
+        const normalizedPhoneJids = this.normalizeUsers(phoneJids);
+        if (normalizedPhoneJids.length === 0) {
+            return [];
+        }
+        const sid = await this.generateSid();
+        const request = this.makeLidSyncRequest(normalizedPhoneJids, sid);
+        this.logger.debug('signal lid sync request', {
+            users: normalizedPhoneJids.length,
+            timeoutMs
+        });
+        const response = await this.query(request, timeoutMs);
+        const parsed = this.parseLidSyncResponse(response, normalizedPhoneJids);
+        const parsedByPhoneJid = new Map();
+        for (let index = 0; index < parsed.length; index += 1) {
+            const entry = parsed[index];
+            const phoneJid = entry.phoneJid ?? entry.jid;
+            parsedByPhoneJid.set(phoneJid, {
+                phoneJid,
+                lidJid: entry.lidJid,
+                exists: entry.exists
+            });
+        }
+        const result = new Array(normalizedPhoneJids.length);
+        let found = 0;
+        for (let index = 0; index < normalizedPhoneJids.length; index += 1) {
+            const phoneJid = normalizedPhoneJids[index];
+            const resolved = parsedByPhoneJid.get(phoneJid) ?? {
+                phoneJid,
+                lidJid: null,
+                exists: false
+            };
+            if (resolved.exists) {
+                found += 1;
+            }
+            result[index] = resolved;
+        }
+        this.logger.debug('signal lid sync success', {
+            users: result.length,
+            found
+        });
+        return result;
+    }
     async collectUsersToQuery(normalizedUsers, nowMs, cachedByUser, store) {
         const records = await store.getUserDevicesBatch(normalizedUsers, nowMs);
         const usersToQuery = [];
@@ -68,41 +135,59 @@ export class SignalDeviceSyncApi {
         }
         return usersToQuery;
     }
-    makeDeviceSyncRequest(userJids) {
-        return buildIqNode('get', this.hostDomain, WA_XMLNS.USYNC, [
-            {
-                tag: WA_NODE_TAGS.USYNC,
-                attrs: {
-                    sid: this.makeSid(),
-                    index: '0',
-                    last: 'true',
-                    mode: WA_NODE_TAGS.QUERY,
-                    context: 'interactive'
-                },
+    makeDeviceSyncRequest(userJids, sid) {
+        const users = new Array(userJids.length);
+        for (let index = 0; index < userJids.length; index += 1) {
+            users[index] = {
+                jid: userJids[index]
+            };
+        }
+        return buildUsyncIq({
+            sid,
+            hostDomain: this.hostDomain,
+            context: WA_USYNC_CONTEXTS.INTERACTIVE,
+            queryProtocolNodes: [
+                {
+                    tag: WA_NODE_TAGS.DEVICES,
+                    attrs: {
+                        version: '2'
+                    }
+                }
+            ],
+            users
+        });
+    }
+    makeLidSyncRequest(userJids, sid) {
+        const users = new Array(userJids.length);
+        for (let index = 0; index < userJids.length; index += 1) {
+            const jid = userJids[index];
+            users[index] = {
+                jid,
                 content: [
                     {
-                        tag: WA_NODE_TAGS.QUERY,
-                        attrs: {},
-                        content: [
-                            {
-                                tag: WA_NODE_TAGS.DEVICES,
-                                attrs: {
-                                    version: '2'
-                                }
-                            }
-                        ]
-                    },
-                    {
-                        tag: WA_NODE_TAGS.LIST,
+                        tag: WA_NODE_TAGS.CONTACT,
                         attrs: {},
-                        content: userJids.map((jid) => ({
-                            tag: WA_NODE_TAGS.USER,
-                            attrs: { jid }
-                        }))
+                        content: splitJid(jid).user
                     }
                 ]
-            }
-        ]);
+            };
+        }
+        return buildUsyncIq({
+            sid,
+            hostDomain: this.hostDomain,
+            context: WA_USYNC_CONTEXTS.INTERACTIVE,
+            queryProtocolNodes: [
+                {
+                    tag: WA_NODE_TAGS.CONTACT,
+                    attrs: {}
+                },
+                {
+                    tag: WA_NODE_TAGS.LID,
+                    attrs: {}
+                }
+            ],
+            users
+        });
     }
     parseDeviceSyncResponse(node, requestedUsers) {
         assertIqResult(node, 'signal device sync');
@@ -116,22 +201,95 @@ export class SignalDeviceSyncApi {
         }
         const requestedSet = new Set(requestedUsers);
         const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
-        return userNodes.flatMap((userNode) => {
+        const parsed = [];
+        for (let index = 0; index < userNodes.length; index += 1) {
+            const userNode = userNodes[index];
             const userJid = userNode.attrs.jid;
             if (!userJid) {
-                return [];
+                continue;
             }
             const normalizedUserJid = this.normalizeUserJid(userJid);
             if (!requestedSet.has(normalizedUserJid)) {
-                return [];
+                continue;
             }
-            return [
-                {
+            parsed.push({
+                jid: normalizedUserJid,
+                deviceJids: this.parseUserDeviceJids(userNode, normalizedUserJid)
+            });
+        }
+        return parsed;
+    }
+    parseLidSyncResponse(node, requestedUsers) {
+        assertIqResult(node, 'signal lid sync');
+        const usyncNode = findNodeChild(node, WA_NODE_TAGS.USYNC);
+        if (!usyncNode) {
+            throw new Error('signal lid sync response missing usync node');
+        }
+        const listNode = findNodeChild(usyncNode, WA_NODE_TAGS.LIST);
+        if (!listNode) {
+            throw new Error('signal lid sync response missing list node');
+        }
+        const requestedSet = new Set(requestedUsers);
+        const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
+        const parsed = [];
+        for (let index = 0; index < userNodes.length; index += 1) {
+            const userNode = userNodes[index];
+            const userJid = userNode.attrs.jid;
+            if (!userJid) {
+                continue;
+            }
+            const normalizedUserJid = this.normalizeUserJid(userJid);
+            const normalizedPhoneJid = userNode.attrs.pn_jid
+                ? this.normalizeUserJid(userNode.attrs.pn_jid)
+                : null;
+            const wasRequested = requestedSet.has(normalizedUserJid) ||
+                (normalizedPhoneJid !== null && requestedSet.has(normalizedPhoneJid));
+            if (!wasRequested) {
+                continue;
+            }
+            const lidNode = findNodeChild(userNode, WA_NODE_TAGS.LID);
+            const contactNode = findNodeChild(userNode, WA_NODE_TAGS.CONTACT);
+            if (!lidNode) {
+                parsed.push(this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null));
+                continue;
+            }
+            const errorNode = findNodeChild(lidNode, WA_NODE_TAGS.ERROR);
+            if (errorNode) {
+                this.logger.warn('signal lid sync user error', {
                     jid: normalizedUserJid,
-                    deviceJids: this.parseUserDeviceJids(userNode, normalizedUserJid)
-                }
-            ];
-        });
+                    code: errorNode.attrs.code,
+                    text: errorNode.attrs.text
+                });
+                parsed.push(this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, null));
+                continue;
+            }
+            const lidJid = lidNode.attrs.val ? this.normalizeUserJid(lidNode.attrs.val) : null;
+            parsed.push(this.buildLidSyncResult(normalizedUserJid, normalizedPhoneJid, contactNode, lidJid));
+        }
+        return parsed;
+    }
+    buildLidSyncResult(jid, phoneJid, contactNode, lidJid) {
+        return {
+            jid,
+            lidJid,
+            phoneJid,
+            exists: this.parseLidSyncContactExists(contactNode, jid, lidJid !== null)
+        };
+    }
+    parseLidSyncContactExists(contactNode, userJid, defaultExists) {
+        if (!contactNode) {
+            return defaultExists;
+        }
+        const errorNode = findNodeChild(contactNode, WA_NODE_TAGS.ERROR);
+        if (errorNode) {
+            this.logger.warn('signal lid sync contact error', {
+                jid: userJid,
+                code: errorNode.attrs.code,
+                text: errorNode.attrs.text
+            });
+            return false;
+        }
+        return contactNode.attrs.type === 'in';
     }
     parseUserDeviceJids(userNode, userJid) {
         const devicesNode = findNodeChild(userNode, WA_NODE_TAGS.DEVICES);
@@ -151,35 +309,44 @@ export class SignalDeviceSyncApi {
         if (!deviceListNode) {
             return [];
         }
-        return [
-            ...new Set(getNodeChildrenByTag(deviceListNode, 'device')
-                .map((deviceNode) => {
-                const parsedId = deviceNode.attrs.id
-                    ? Number.parseInt(deviceNode.attrs.id, 10)
-                    : Number.NaN;
-                return Number.isSafeInteger(parsedId) && parsedId >= 0
-                    ? this.toDeviceJid(userJid, parsedId)
-                    : null;
-            })
-                .filter((jid) => jid !== null))
-        ];
+        const parsedUser = splitJid(userJid);
+        const dedup = new Set();
+        for (const deviceNode of getNodeChildrenByTag(deviceListNode, 'device')) {
+            const parsedId = deviceNode.attrs.id
+                ? Number.parseInt(deviceNode.attrs.id, 10)
+                : Number.NaN;
+            if (!Number.isSafeInteger(parsedId) || parsedId < 0) {
+                continue;
+            }
+            dedup.add(this.toDeviceJid(parsedUser.user, parsedUser.server, parsedId));
+        }
+        const deviceJids = [];
+        for (const jid of dedup.values()) {
+            deviceJids.push(jid);
+        }
+        return deviceJids;
     }
     normalizeUsers(userJids) {
-        return [...new Set(userJids.map((jid) => this.normalizeUserJid(jid)))];
+        const normalized = [];
+        const dedup = new Set();
+        for (let index = 0; index < userJids.length; index += 1) {
+            const normalizedJid = this.normalizeUserJid(userJids[index]);
+            if (dedup.has(normalizedJid)) {
+                continue;
+            }
+            dedup.add(normalizedJid);
+            normalized.push(normalizedJid);
+        }
+        return normalized;
     }
     normalizeUserJid(jid) {
-        const { user } = parseSignalAddressFromJid(jid);
-        const { server } = splitJid(jid);
-        return `${user}@${server}`;
+        const address = parseSignalAddressFromJid(jid);
+        return `${address.user}@${address.server}`;
     }
-    toDeviceJid(userJid, deviceId) {
-        const parsed = splitJid(userJid);
+    toDeviceJid(user, server, deviceId) {
         if (deviceId === 0) {
-            return `${parsed.user}@${parsed.server}`;
+            return `${user}@${server}`;
         }
-        return `${parsed.user}:${deviceId}@${parsed.server}`;
-    }
-    makeSid() {
-        return `${Date.now()}.${randomInt(1000000)}`;
+        return `${user}:${deviceId}@${server}`;
     }
 }

package/dist/esm/signal/api/SignalDigestSyncApi.js

@@ -161,7 +161,12 @@ export class SignalDigestSyncApi {
         const signedKeyId = parseUint(decodeExactLength(signedKeyIdNode.content, 'signal digest skey.id', SIGNAL_KEY_ID_LENGTH), 'signal digest skey.id');
         const signedKeyPublicKey = decodeExactLength(signedKeyValueNode.content, 'signal digest skey.value', SIGNAL_KEY_DATA_LENGTH);
         const signedKeySignature = decodeExactLength(signedKeySignatureNode.content, 'signal digest skey.signature', SIGNAL_SIGNATURE_LENGTH);
-        const preKeyIds = getNodeChildren(listNode).map((child, index) => parseUint(decodeExactLength(child.content, `signal digest list[${index}]`, SIGNAL_KEY_ID_LENGTH), `signal digest list[${index}]`));
+        const preKeyIds = [];
+        const listChildren = getNodeChildren(listNode);
+        for (let index = 0; index < listChildren.length; index += 1) {
+            const child = listChildren[index];
+            preKeyIds.push(parseUint(decodeExactLength(child.content, `signal digest list[${index}]`, SIGNAL_KEY_ID_LENGTH), `signal digest list[${index}]`));
+        }
         const hash = decodeNodeContentBase64OrBytes(hashNode.content, 'signal digest hash');
         return {
             registrationId,

package/dist/esm/signal/api/SignalIdentitySyncApi.js

@@ -4,6 +4,7 @@ import { normalizeDeviceJid, parseSignalAddressFromJid } from '../../protocol/ji
 import { decodeExactLength, parseUint } from '../api/codec.js';
 import { SIGNAL_KEY_BUNDLE_TYPE_LENGTH, SIGNAL_KEY_DATA_LENGTH } from '../api/constants.js';
 import { findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+import { assertIqResult } from '../../transport/node/query.js';
 export class SignalIdentitySyncApi {
     constructor(options) {
         this.logger = options.logger;
@@ -14,10 +15,28 @@ export class SignalIdentitySyncApi {
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
     }
     async syncIdentityKeys(targetJids, timeoutMs = this.defaultTimeoutMs) {
-        const normalizedTargets = [...new Set(targetJids.map((jid) => normalizeDeviceJid(jid)))];
+        const normalizedTargets = [];
+        const dedup = new Set();
+        for (let index = 0; index < targetJids.length; index += 1) {
+            const normalized = normalizeDeviceJid(targetJids[index]);
+            if (dedup.has(normalized)) {
+                continue;
+            }
+            dedup.add(normalized);
+            normalizedTargets.push(normalized);
+        }
         if (normalizedTargets.length === 0) {
             return [];
         }
+        const users = new Array(normalizedTargets.length);
+        for (let index = 0; index < normalizedTargets.length; index += 1) {
+            users[index] = {
+                tag: WA_NODE_TAGS.USER,
+                attrs: {
+                    jid: normalizedTargets[index]
+                }
+            };
+        }
         this.logger.debug('signal identity sync request', {
             targets: normalizedTargets.length,
             timeoutMs
@@ -33,20 +52,22 @@ export class SignalIdentitySyncApi {
                 {
                     tag: WA_NODE_TAGS.IDENTITY,
                     attrs: {},
-                    content: normalizedTargets.map((jid) => ({
-                        tag: WA_NODE_TAGS.USER,
-                        attrs: { jid }
-                    }))
+                    content: users
                 }
             ]
         }, timeoutMs);
         const entries = this.parseIdentitySyncResponse(response, normalizedTargets);
         const { signalStore } = this;
         if (signalStore && entries.length > 0) {
-            await signalStore.setRemoteIdentities(entries.map((entry) => ({
-                address: parseSignalAddressFromJid(entry.jid),
-                identityKey: toSerializedPubKey(entry.identity)
-            })));
+            const identities = new Array(entries.length);
+            for (let index = 0; index < entries.length; index += 1) {
+                const entry = entries[index];
+                identities[index] = {
+                    address: parseSignalAddressFromJid(entry.jid),
+                    identityKey: toSerializedPubKey(entry.identity)
+                };
+            }
+            await signalStore.setRemoteIdentities(identities);
         }
         this.logger.debug('signal identity sync success', {
             requested: normalizedTargets.length,
@@ -55,31 +76,19 @@ export class SignalIdentitySyncApi {
         return entries;
     }
     parseIdentitySyncResponse(node, requestedJids) {
-        if (node.tag !== WA_NODE_TAGS.IQ) {
-            throw new Error(`invalid identity sync response tag: ${node.tag}`);
-        }
-        if (node.attrs.type === WA_IQ_TYPES.ERROR) {
-            const errorNode = findNodeChild(node, WA_NODE_TAGS.ERROR);
-            if (!errorNode) {
-                throw new Error(`identity sync iq error for ${node.attrs.id ?? 'unknown id'}`);
-            }
-            const code = errorNode.attrs.code ?? 'unknown';
-            const text = errorNode.attrs.text ?? errorNode.attrs.type ?? 'unknown';
-            throw new Error(`identity sync iq error (${code} ${text})`);
-        }
-        if (node.attrs.type !== WA_IQ_TYPES.RESULT) {
-            throw new Error(`invalid identity sync response type: ${node.attrs.type ?? 'unknown'}`);
-        }
+        assertIqResult(node, 'identity sync');
         const listNode = findNodeChild(node, WA_NODE_TAGS.LIST);
         if (!listNode) {
             throw new Error('identity sync response missing list node');
         }
         const requested = new Set(requestedJids);
         const userNodes = getNodeChildrenByTag(listNode, WA_NODE_TAGS.USER);
-        return userNodes.flatMap((userNode) => {
+        const parsed = [];
+        for (let index = 0; index < userNodes.length; index += 1) {
+            const userNode = userNodes[index];
             const jid = userNode.attrs.jid ? normalizeDeviceJid(userNode.attrs.jid) : '';
             if (!jid || !requested.has(jid)) {
-                return [];
+                continue;
             }
             const errorNode = findNodeChild(userNode, WA_NODE_TAGS.ERROR);
             if (errorNode) {
@@ -88,7 +97,7 @@ export class SignalIdentitySyncApi {
                     code: errorNode.attrs.code,
                     text: errorNode.attrs.text
                 });
-                return [];
+                continue;
             }
             const identityNode = findNodeChild(userNode, WA_NODE_TAGS.IDENTITY);
             if (!identityNode) {
@@ -99,13 +108,19 @@ export class SignalIdentitySyncApi {
             const parsedType = typeNode
                 ? parseUint(decodeExactLength(typeNode.content, 'identity sync type', SIGNAL_KEY_BUNDLE_TYPE_LENGTH), 'identity sync type')
                 : undefined;
-            return [
-                {
+            if (parsedType === undefined) {
+                parsed.push({
                     jid,
-                    identity,
-                    ...(parsedType !== undefined ? { type: parsedType } : {})
-                }
-            ];
-        });
+                    identity
+                });
+                continue;
+            }
+            parsed.push({
+                jid,
+                identity,
+                type: parsedType
+            });
+        }
+        return parsed;
     }
 }