@wenzyx1/bails 1.0.0

package/lib/Socket/username.mjs

@@ -0,0 +1,132 @@
+import { executeWMexQuery } from './mex.mjs';
+import WAUSyncDefault from '../WAUSync/index.js';
+
+const { USyncQuery, USyncUser } = WAUSyncDefault;
+
+/**
+ * Ported from xata-bail's lib/Socket/username.js.
+ * Adapted for edgar-bail: instead of building its own socket chain via
+ * makeNewsletterSocket(config), this layer takes an already-built `sock`
+ * (the output of edgar's existing, unmodified synchronous chain) and adds
+ * username-related methods on top of it.
+ */
+
+export const USERNAME_QUERY_IDS = {
+	CHECK: '26124072630599520', // UsernameCheck
+	CHECK_MULTI: '27134626522840290', // UsernameCheckMulti
+	SET: '27108705368767936', // UsernameSet
+	GET: '32618050064506056', // UsernameGet
+	GET_RECOMMENDATIONS: '26077456248616956', // UsernameGetRecommendationsQuery
+	PIN_SET: '25529696019976770' // UsernamePinSet
+};
+
+export const USERNAME_CHECK_RESULT = {
+	SUCCESS: 'SUCCESS',
+	INVALID: 'INVALID'
+};
+
+export const USERNAME_SOURCE = {
+	FB: 'FB',
+	IG: 'IG',
+	USER_INPUT: 'USER_INPUT',
+	SUGGESTION: 'SUGGESTION'
+};
+
+export const makeUsernameSocketLayer = (sock) => {
+	const { query, generateMessageTag, executeUSyncQuery } = sock;
+
+	const mexQuery = (variables, queryId, dataPath) =>
+		executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
+
+	const checkUsername = async (username, includeSuggestions = true) => {
+		const data = await mexQuery(
+			{ username, include_suggestions: includeSuggestions },
+			USERNAME_QUERY_IDS.CHECK,
+			'xwa2_username_check'
+		);
+		if (data?.result === USERNAME_CHECK_RESULT.SUCCESS) {
+			return { available: true, username };
+		}
+		return {
+			available: false,
+			username,
+			suggestions: data?.suggestions ?? [],
+			rejectionReasons: data?.rejection_reasons ?? [],
+			suggestionsEligible: data?.suggestions_eligible ?? true
+		};
+	};
+
+	const setUsername = async (username, options = {}) => {
+		const { source = USERNAME_SOURCE.USER_INPUT, sessionId, pin } = options;
+		const variables = {
+			username,
+			reserved: false,
+			source,
+			...(sessionId ? { session_id: sessionId } : {}),
+			...(pin ? { pin } : {})
+		};
+		return mexQuery(variables, USERNAME_QUERY_IDS.SET, 'xwa2_username_set');
+	};
+
+	const deleteUsername = async () => {
+		return mexQuery({ username: null }, USERNAME_QUERY_IDS.SET, 'xwa2_username_delete');
+	};
+
+	const getMyUsername = async () => {
+		const data = await mexQuery({}, USERNAME_QUERY_IDS.GET, 'xwa2_username_get');
+		return data?.username ?? null;
+	};
+
+	const setUsernamePin = async pin => {
+		return mexQuery({ pin }, USERNAME_QUERY_IDS.PIN_SET, 'xwa2_username_pin_set');
+	};
+
+	const findUserByUsername = async (username, pin) => {
+		const usyncQuery = new USyncQuery().withContactProtocol();
+		const user = new USyncUser().withUsername(username);
+		if (pin) user.withUsernameKey(pin);
+		usyncQuery.withUser(user);
+		const result = await executeUSyncQuery(usyncQuery);
+		if (!result?.list?.length) return null;
+		const entry = result.list[0];
+		return {
+			jid: entry.id,
+			contact: entry.contact ?? false
+		};
+	};
+
+	const fetchContactUsernames = async (...jids) => {
+		const usyncQuery = new USyncQuery().withUsernameProtocol();
+		for (const jid of jids) {
+			usyncQuery.withUser(new USyncUser().withId(jid));
+		}
+		const result = await executeUSyncQuery(usyncQuery);
+		return result?.list ?? [];
+	};
+
+	const checkUsernameMulti = async usernames => {
+		return mexQuery({ usernames }, USERNAME_QUERY_IDS.CHECK_MULTI, 'xwa2_username_check_multi');
+	};
+
+	const getUsernameRecommendations = async (source = null) => {
+		const variables = {};
+		if (source) variables.source = source;
+		return mexQuery(variables, USERNAME_QUERY_IDS.GET_RECOMMENDATIONS, 'xwa2_username_get_recommendations');
+	};
+
+	return {
+		...sock,
+		checkUsername,
+		checkUsernameMulti,
+		setUsername,
+		deleteUsername,
+		getMyUsername,
+		getUsernameRecommendations,
+		setUsernamePin,
+		findUserByUsername,
+		fetchContactUsernames,
+		USERNAME_QUERY_IDS,
+		USERNAME_CHECK_RESULT,
+		USERNAME_SOURCE
+	};
+};

package/lib/Socket/usync.d.ts

@@ -0,0 +1,36 @@
+import { Boom } from '@hapi/boom';
+import { SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { USyncQuery } from '../WAUSync';
+export declare const makeUSyncSocket: (config: SocketConfig) => {
+    executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>;
+    type: "md";
+    ws: import("./Client").WebSocketClient;
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): (() => void);
+        buffer(): void;
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>);
+        flush(force?: boolean): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<any>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: BinaryNode) => Promise<void>;
+    logout: (msg?: string) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | Boom, msg: string) => void;
+    uploadPreKeys: (count?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
+};

package/lib/Socket/usync.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUSyncSocket = void 0;
+const boom_1 = require("@hapi/boom");
+const WABinary_1 = require("../WABinary");
+const socket_1 = require("./socket");
+const makeUSyncSocket = (config) => {
+    const sock = (0, socket_1.makeSocket)(config);
+    const { generateMessageTag, query, } = sock;
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.Boom('USyncQuery must have at least one protocol');
+        }
+        // todo: validate users, throw WARNING on no valid users
+        // variable below has only validated users
+        const validUsers = usyncQuery.users;
+        const userNodes = validUsers.map((user) => {
+            return {
+                tag: 'user',
+                attrs: {
+                    jid: !user.phone ? user.id : undefined,
+                },
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
+            };
+        });
+        const listNode = {
+            tag: 'list',
+            attrs: {},
+            content: userNodes
+        };
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        };
+        const iq = {
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'usync',
+            },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0',
+                    },
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
+                }
+            ],
+        };
+        const result = await query(iq);
+        return usyncQuery.parseUSyncQueryResult(result);
+    };
+    return {
+        ...sock,
+        executeUSyncQuery,
+    };
+};
+exports.makeUSyncSocket = makeUSyncSocket;

package/lib/Store/index.d.ts

@@ -0,0 +1,3 @@
+import makeCacheManagerAuthState from './make-cache-manager-store';
+import makeInMemoryStore from './make-in-memory-store';
+export { makeInMemoryStore, makeCacheManagerAuthState };

package/lib/Store/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCacheManagerAuthState = exports.makeInMemoryStore = void 0;
+const make_cache_manager_store_1 = __importDefault(require("./make-cache-manager-store"));
+exports.makeCacheManagerAuthState = make_cache_manager_store_1.default;
+const make_in_memory_store_1 = __importDefault(require("./make-in-memory-store"));
+exports.makeInMemoryStore = make_in_memory_store_1.default;

package/lib/Store/keyed-db.d.ts

@@ -0,0 +1,30 @@
+export interface Comparable {
+    key: (value: any) => string | number;
+    compare: (k1: string | number, k2: string | number) => number;
+}
+export default class KeyedDB<T = any> {
+    key: Comparable;
+    idGetter: (value: T) => string;
+    dict: { [id: string]: T };
+    array: T[];
+    constructor(key: Comparable, id?: (value: T) => string);
+    get length(): number;
+    get first(): T | undefined;
+    get last(): T | undefined;
+    toJSON(): T[];
+    insert(...values: T[]): void;
+    upsert(...values: T[]): T[];
+    insertIfAbsent(...values: T[]): T[];
+    deleteById(id: string, assertPresent?: boolean): T | null | undefined;
+    delete(value: T): T | null;
+    slice(start?: number, end?: number): KeyedDB<T>;
+    clear(): void;
+    get(id: string): T | undefined;
+    all(): T[];
+    update(id: string, update: (value: T) => void): number | undefined;
+    updateKey(value: T, update: (value: T) => void): number | undefined;
+    filter(predicate: (value: T, index: number) => boolean): KeyedDB<T>;
+    paginatedByValue(value: T | null | undefined, limit: number, predicate?: (value: T, index: number) => boolean, mode?: 'before' | 'after'): T[];
+    paginated(cursor: string | number | null | undefined, limit: number, predicate?: (value: T, index: number) => boolean, mode?: 'before' | 'after'): T[];
+    firstIndex(value: T): number;
+}

package/lib/Store/keyed-db.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Local, dependency-free reimplementation of `@adiwajshing/keyed-db` (v0.2.4).
+ * The original package on npm has not been updated in 5+ years — this file
+ * replaces it 1:1 (same method names, same signatures, same behaviour) so
+ * nothing else in this codebase needs to change.
+ *
+ * key: { key: (value) => Comparable, compare: (a, b) => number }
+ * id:  (value) => string   (optional — defaults to key.key(value).toString())
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+
+function binarySearch(array, comparator) {
+    // returns the first index i for which comparator(array[i]) <= 0
+    let low = 0;
+    let high = array.length;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (comparator(array[mid]) > 0) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return low;
+}
+
+class KeyedDB {
+    /**
+     * @param key Object describing how to sort & key items: { key, compare }
+     * @param id The unique ID getter for the items (optional)
+     */
+    constructor(key, id) {
+        this.key = key;
+        this.idGetter = id || (v => this.key.key(v).toString());
+        this.dict = {};
+        this.array = [];
+    }
+    get length() {
+        return this.array.length;
+    }
+    get first() {
+        return this.array[0];
+    }
+    get last() {
+        return this.array[this.array.length - 1];
+    }
+    toJSON() {
+        return this.array;
+    }
+    /** Inserts items into the DB in klogN time. */
+    insert(...values) {
+        values.forEach(v => this._insertSingle(v));
+    }
+    /**
+     * Upserts items into the DB.
+     * If a duplicate is found, it is deleted first and then the new one is inserted.
+     * @returns list of updated (previously-existing) values
+     */
+    upsert(...values) {
+        const updates = [];
+        values.forEach(v => {
+            if (!v)
+                return;
+            const deleted = this.deleteById(this.idGetter(v), false);
+            this._insertSingle(v);
+            deleted && updates.push(v);
+        });
+        return updates;
+    }
+    /** Inserts items only if they are not already present in the DB */
+    insertIfAbsent(...values) {
+        const insertions = [];
+        values.forEach(v => {
+            if (!v)
+                return;
+            const presentValue = this.get(this.idGetter(v));
+            if (presentValue)
+                return;
+            const presentKey = this.firstIndex(v);
+            if (this.array[presentKey] && this.key.key(this.array[presentKey]) === this.key.key(v))
+                return;
+            this.insert(v);
+            insertions.push(v);
+        });
+        return insertions;
+    }
+    /** Deletes an item indexed by the ID */
+    deleteById(id, assertPresent = true) {
+        const value = this.get(id);
+        if (!value) {
+            if (assertPresent)
+                throw new Error(`Value not found`);
+            else
+                return;
+        }
+        return this.delete(value);
+    }
+    delete(value) {
+        const index = this.firstIndex(value);
+        if (index < 0 || index >= this.array.length || this.key.key(value) !== this.key.key(this.array[index])) {
+            return null;
+        }
+        delete this.dict[this.idGetter(value)];
+        return this.array.splice(index, 1)[0];
+    }
+    slice(start, end) {
+        const db = new KeyedDB(this.key, this.idGetter);
+        db.array = this.array.slice(start, end);
+        db.array.forEach(item => db.dict[this.idGetter(item)] = item);
+        return db;
+    }
+    /** Clears the DB */
+    clear() {
+        this.array = [];
+        this.dict = {};
+    }
+    get(id) {
+        return this.dict[id];
+    }
+    all() {
+        return this.array;
+    }
+    /**
+     * Updates a value specified by the ID and repositions it in the DB if
+     * the sort key changed.
+     */
+    update(id, update) {
+        const value = this.get(id);
+        if (value) {
+            const idx = this.firstIndex(value);
+            if (idx >= 0 && idx < this.array.length && this.idGetter(this.array[idx]) === id) {
+                const oldKey = this.key.key(value);
+                update(value);
+                const newKey = this.key.key(value);
+                if (newKey !== oldKey) {
+                    delete this.dict[id];
+                    this.array.splice(idx, 1);
+                    this._insertSingle(value);
+                    return 2;
+                }
+                return 1;
+            }
+        }
+    }
+    /** @deprecated see `update` */
+    updateKey(value, update) {
+        return this.update(this.idGetter(value), update);
+    }
+    filter(predicate) {
+        const db = new KeyedDB(this.key, this.idGetter);
+        db.array = this.array.filter((value, index) => {
+            if (predicate(value, index)) {
+                db.dict[this.idGetter(value)] = value;
+                return true;
+            }
+            return false;
+        });
+        return db;
+    }
+    paginatedByValue(value, limit, predicate, mode = 'after') {
+        return this.paginated(value && this.key.key(value), limit, predicate, mode);
+    }
+    paginated(cursor, limit, predicate, mode = 'after') {
+        let index = mode === 'after' ? 0 : this.array.length;
+        if (cursor !== null && typeof cursor !== 'undefined') {
+            index = binarySearch(this.array, v => this.key.compare(cursor, this.key.key(v)));
+            if (index < 0)
+                index = 0;
+            if (this.array[index] && this.key.key(this.array[index]) === cursor)
+                index += (mode === 'after' ? 1 : 0);
+        }
+        return this._filtered(index, limit, mode, predicate);
+    }
+    _insertSingle(value) {
+        if (!value)
+            throw new Error('falsey value');
+        const valueID = this.idGetter(value);
+        if (this.get(valueID)) {
+            throw new Error('duplicate ID being inserted: ' + valueID);
+        }
+        if (this.array.length > 0) {
+            const index = this.firstIndex(value);
+            if (index >= this.array.length)
+                this.array.push(value);
+            else if (index < 0)
+                this.array.unshift(value);
+            else if (this.key.key(value) !== this.key.key(this.array[index]))
+                this.array.splice(index, 0, value);
+            else
+                throw new Error(`duplicate key: ${this.key.key(value)}, of inserting: ${valueID}, present: ${this.idGetter(this.array[index])}`);
+        }
+        else {
+            this.array.push(value);
+        }
+        this.dict[valueID] = value;
+    }
+    _filtered(start, count, mode, predicate) {
+        let arr;
+        if (mode === 'after') {
+            if (predicate) {
+                arr = [];
+                for (const item of this.array.slice(start)) {
+                    predicate(item, start + arr.length) && arr.push(item);
+                    if (arr.length >= count)
+                        break;
+                }
+            }
+            else
+                arr = this.array.slice(start, start + count);
+        }
+        else if (mode === 'before') {
+            if (predicate) {
+                arr = [];
+                for (let i = start - 1; i >= 0; i--) {
+                    const item = this.array[i];
+                    predicate(item, start + arr.length) && arr.unshift(item);
+                    if (arr.length >= count)
+                        break;
+                }
+            }
+            else
+                arr = this.array.slice(Math.max(start - count, 0), start);
+        }
+        return arr;
+    }
+    firstIndex(value) {
+        const valueKey = this.key.key(value);
+        return binarySearch(this.array, v => this.key.compare(valueKey, this.key.key(v)));
+    }
+}
+exports.default = KeyedDB;

package/lib/Store/make-cache-manager-store.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticationCreds } from '../Types';
+declare const makeCacheManagerAuthState: (store: Storage, sessionKey: string) => Promise<{
+    clearState: () => Promise<void>;
+    saveCreds: () => Promise<void>;
+    state: {
+        creds: AuthenticationCreds;
+        keys: {
+            get: (type: string, ids: string[]) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+}>;
+export default makeCacheManagerAuthState;

package/lib/Store/make-cache-manager-store.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cache_manager_1 = require("cache-manager");
+const WAProto_1 = require("../../WAProto");
+const Utils_1 = require("../Utils");
+const logger_1 = __importDefault(require("../Utils/logger"));
+const makeCacheManagerAuthState = async (store, sessionKey) => {
+    const defaultKey = (file) => `${sessionKey}:${file}`;
+    const databaseConn = await (0, cache_manager_1.caching)(store);
+    const writeData = async (file, data) => {
+        let ttl = undefined;
+        if (file === 'creds') {
+            ttl = 63115200; // 2 years
+        }
+        await databaseConn.set(defaultKey(file), JSON.stringify(data, Utils_1.BufferJSON.replacer), ttl);
+    };
+    const readData = async (file) => {
+        try {
+            const data = await databaseConn.get(defaultKey(file));
+            if (data) {
+                return JSON.parse(data, Utils_1.BufferJSON.reviver);
+            }
+            return null;
+        }
+        catch (error) {
+            logger_1.default.error(error);
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            return await databaseConn.del(defaultKey(file));
+        }
+        catch (_a) {
+            logger_1.default.error(`Error removing ${file} from session ${sessionKey}`);
+        }
+    };
+    const clearState = async () => {
+        try {
+            const result = await databaseConn.store.keys(`${sessionKey}*`);
+            await Promise.all(result.map(async (key) => await databaseConn.del(key)));
+        }
+        catch (err) {
+        }
+    };
+    const creds = (await readData('creds')) || (0, Utils_1.initAuthCreds)();
+    return {
+        clearState,
+        saveCreds: () => writeData('creds', creds),
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const key = `${category}-${id}`;
+                            tasks.push(value ? writeData(key, value) : removeData(key));
+                        }
+                    }
+                    await Promise.all(tasks);
+                },
+            }
+        }
+    };
+};
+exports.default = makeCacheManagerAuthState;