@nerxa/socketon 0.0.0-stage → 1.21.1

package/src/Utils/use-postgres-auth-state.js

@@ -0,0 +1,79 @@
+import { loadOptionalModule, makeAuthStateFromStore } from './auth-store.js';
+const quoteIdentifier = (name) => {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`table name must be a plain identifier, got ${JSON.stringify(name)}`);
+    }
+    return `"${name}"`;
+};
+export async function usePostgresAuthState(opts = {}) {
+    const table = quoteIdentifier(opts.table ?? 'baileys_auth');
+    const session = opts.session ?? 'default';
+    let pool = opts.pool;
+    let owned = false;
+    if (!pool) {
+        if (!opts.connectionString && !opts.config) {
+            throw new Error('usePostgresAuthState needs a pool, a connectionString, or a config');
+        }
+        const pg = await loadOptionalModule('pg', 'usePostgresAuthState');
+        pool = new pg.Pool(opts.config ?? { connectionString: opts.connectionString });
+        owned = true;
+    }
+    await pool.query(`CREATE TABLE IF NOT EXISTS ${table} (
+        session TEXT NOT NULL,
+        type TEXT NOT NULL,
+        id TEXT NOT NULL,
+        value TEXT NOT NULL,
+        PRIMARY KEY (session, type, id)
+    )`);
+    const store = {
+        read: async (type, id) => {
+            const result = await pool.query(`SELECT value FROM ${table} WHERE session = $1 AND type = $2 AND id = $3`, [session, type, id]);
+            return result.rows[0]?.value ?? null;
+        },
+        readMany: async (type, ids) => {
+            if (!ids.length) {
+                return {};
+            }
+            const result = await pool.query(`SELECT id, value FROM ${table} WHERE session = $1 AND type = $2 AND id = ANY($3)`, [session, type, ids]);
+            const rows = {};
+            for (const row of result.rows) {
+                rows[row.id] = row.value;
+            }
+            return rows;
+        },
+        write: async (type, id, value) => {
+            await pool.query(`INSERT INTO ${table} (session, type, id, value) VALUES ($1, $2, $3, $4)
+                ON CONFLICT (session, type, id) DO UPDATE SET value = EXCLUDED.value`, [session, type, id, value]);
+        },
+        apply: async (writes, removals) => {
+            const client = await pool.connect();
+            try {
+                await client.query('BEGIN');
+                for (const entry of writes) {
+                    await client.query(`INSERT INTO ${table} (session, type, id, value) VALUES ($1, $2, $3, $4)
+                        ON CONFLICT (session, type, id) DO UPDATE SET value = EXCLUDED.value`, [session, entry.type, entry.id, entry.value]);
+                }
+                for (const entry of removals) {
+                    await client.query(`DELETE FROM ${table} WHERE session = $1 AND type = $2 AND id = $3`, [session, entry.type, entry.id]);
+                }
+                await client.query('COMMIT');
+            }
+            catch (err) {
+                await client.query('ROLLBACK');
+                throw err;
+            }
+            finally {
+                client.release();
+            }
+        },
+        clear: async () => {
+            await pool.query(`DELETE FROM ${table} WHERE session = $1`, [session]);
+        },
+        close: async () => {
+            if (owned) {
+                await pool.end();
+            }
+        }
+    };
+    return makeAuthStateFromStore(store);
+}

package/src/Utils/use-redis-auth-state.d.ts

@@ -0,0 +1,19 @@
+export interface RedisAuthStateOptions {
+    client?: any;
+    uri?: string;
+    config?: any;
+    prefix?: string;
+    session?: string;
+}
+export function useRedisAuthState(opts?: RedisAuthStateOptions): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<void>;
+    clearAuth: () => Promise<void>;
+    close: () => Promise<void>;
+}>;

package/src/Utils/use-redis-auth-state.js

@@ -0,0 +1,89 @@
+import { loadOptionalModule, makeAuthStateFromStore } from './auth-store.js';
+const resolveCommand = (client, names) => {
+    for (const name of names) {
+        if (typeof client[name] === 'function') {
+            return name;
+        }
+    }
+    throw new Error(`redis client exposes none of: ${names.join(', ')}`);
+};
+export async function useRedisAuthState(opts = {}) {
+    const session = opts.session ?? 'default';
+    const prefix = opts.prefix ?? 'baileys_auth';
+    let client = opts.client;
+    let owned = false;
+    if (!client) {
+        if (!opts.uri) {
+            throw new Error('useRedisAuthState needs a client or a uri');
+        }
+        const Redis = await loadOptionalModule('ioredis', 'useRedisAuthState');
+        client = new Redis(opts.uri, opts.config);
+        owned = true;
+    }
+    if (typeof client.connect === 'function' && client.isOpen === false) {
+        await client.connect();
+    }
+    const commands = {
+        hget: resolveCommand(client, ['hGet', 'hget']),
+        hmget: resolveCommand(client, ['hmGet', 'hmget']),
+        hset: resolveCommand(client, ['hSet', 'hset']),
+        hdel: resolveCommand(client, ['hDel', 'hdel']),
+        del: resolveCommand(client, ['del', 'DEL']),
+        keys: resolveCommand(client, ['keys', 'KEYS'])
+    };
+    const hashKey = (type) => `${prefix}:${session}:${type}`;
+    const store = {
+        read: async (type, id) => {
+            const value = await client[commands.hget](hashKey(type), id);
+            return value ?? null;
+        },
+        readMany: async (type, ids) => {
+            if (!ids.length) {
+                return {};
+            }
+            const values = await client[commands.hmget](hashKey(type), ids);
+            const rows = {};
+            ids.forEach((id, index) => {
+                const value = values?.[index];
+                if (value !== null && value !== undefined) {
+                    rows[id] = value;
+                }
+            });
+            return rows;
+        },
+        write: async (type, id, value) => {
+            await client[commands.hset](hashKey(type), id, value);
+        },
+        apply: async (writes, removals) => {
+            const chain = typeof client.multi === 'function' ? client.multi() : null;
+            if (chain) {
+                for (const entry of writes) {
+                    chain[commands.hset](hashKey(entry.type), entry.id, entry.value);
+                }
+                for (const entry of removals) {
+                    chain[commands.hdel](hashKey(entry.type), entry.id);
+                }
+                await chain.exec();
+                return;
+            }
+            for (const entry of writes) {
+                await client[commands.hset](hashKey(entry.type), entry.id, entry.value);
+            }
+            for (const entry of removals) {
+                await client[commands.hdel](hashKey(entry.type), entry.id);
+            }
+        },
+        clear: async () => {
+            const found = await client[commands.keys](`${prefix}:${session}:*`);
+            if (found?.length) {
+                await client[commands.del](found);
+            }
+        },
+        close: async () => {
+            if (owned) {
+                await (client.quit?.() ?? client.disconnect?.());
+            }
+        }
+    };
+    return makeAuthStateFromStore(store);
+}

package/src/Utils/use-single-file-auth-state.d.ts

@@ -0,0 +1,10 @@
+export function useSingleFileAuthState(fileName: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => {};
+            set: (data: any) => void;
+        };
+    };
+    saveCreds: () => void;
+}>;

package/src/Utils/use-single-file-auth-state.js

@@ -0,0 +1,108 @@
+import { readFile, rename, stat, writeFile } from 'fs/promises';
+import { DEFAULT_CACHE_TTLS } from '../Defaults/index.js';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+import { LRUCache } from 'lru-cache';
+import { Mutex } from 'async-mutex';
+
+const FLUSH_TIMEOUT_MS = 3000;
+
+export const useSingleFileAuthState = async (fileName) => {
+    const cache = new LRUCache({
+        max: 20000,
+        ttl: 1000 * DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        updateAgeOnGet: false,
+        updateAgeOnHas: false,
+        ttlAutopurge: true
+    });
+
+    const mutex = new Mutex();
+    let fileData = {};
+    let isLoaded = false;
+    let flushTimeout = null;
+    const loadKey = async () => {
+        return await mutex.runExclusive(async () => {
+            if (isLoaded)
+                return;
+            try {
+                const data = JSON.parse(await readFile(fileName, 'utf-8'), BufferJSON.reviver);
+                fileData = data || {};
+                for (const [keyName, value] of Object.entries(fileData)) {
+                    cache.set(keyName, value);
+                }
+            }
+            catch {
+                fileData = {};
+            }
+            isLoaded = true;
+        });
+    };
+    const flushKey = () => {
+        if (flushTimeout)
+            return;
+        flushTimeout = setTimeout(async () => {
+            flushTimeout = null;
+            await mutex.runExclusive(async () => {
+                try {
+                    const tempFile = fileName + '.temp';
+                    await writeFile(tempFile, JSON.stringify(fileData, BufferJSON.replacer));
+                    await rename(tempFile, fileName);
+                }
+                catch { }
+            });
+        }, FLUSH_TIMEOUT_MS);
+    };
+    const writeKey = (keyName, value) => {
+        cache.set(keyName, value);
+        fileData[keyName] = value;
+        flushKey();
+    };
+    const removeKey = (keyName) => {
+        cache.delete(keyName);
+        delete fileData[keyName];
+        flushKey();
+    };
+    const fileInfo = await stat(fileName).catch(() => null);
+    if (!fileInfo) {
+        await writeFile(fileName, '{}');
+    }
+    else if (!fileInfo.isFile()) {
+        throw new Error(`found something that is not a file at ${fileName}, either delete it or specify a different location`);
+    }
+    await loadKey();
+    const creds = fileData['creds'] || initAuthCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const keyName = type + id;
+                        let value = cache.get(keyName);
+                        if (value === undefined && fileData[keyName] !== undefined) {
+                            value = fileData[keyName];
+                            cache.set(keyName, value);
+                        }
+                        if (type === 'app-state-sync-key' && value) {
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }
+                    return data;
+                },
+                set: (data) => {
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const keyName = category + id;
+                            const value = data[category][id];
+                            value ? writeKey(keyName, value) : removeKey(keyName);
+                        }
+                    }
+                }
+            }
+        },
+        saveCreds: () => writeKey('creds', creds)
+    };
+};

package/src/Utils/use-sqlite-auth-state.d.ts

@@ -0,0 +1,12 @@
+export function useSqliteAuthState(opts: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<void>;
+    clearAuth: () => Promise<void>;
+    close: () => Promise<void>;
+}>;

package/src/Utils/use-sqlite-auth-state.js

@@ -0,0 +1,120 @@
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+async function loadBetterSqlite3() {
+    try {
+
+        const mod = (await import('better-sqlite3'));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for `useSqliteAuthState`. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+const CREDS_ROW_KEY = '__creds__';
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS creds (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS signal_keys (
+  type TEXT NOT NULL,
+  id TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (type, id)
+);
+CREATE INDEX IF NOT EXISTS signal_keys_type_idx ON signal_keys(type);
+`;
+export async function useSqliteAuthState(opts) {
+    let db;
+    let owned = false;
+    if (opts.database) {
+        db = opts.database;
+    }
+    else {
+        const Database = await loadBetterSqlite3();
+        db = new Database(opts.dbPath);
+        owned = true;
+    }
+
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.exec(CREATE_SCHEMA_SQL);
+    const stmts = {
+        credsSelect: db.prepare('SELECT value FROM creds WHERE key = ?'),
+        credsUpsert: db.prepare('INSERT INTO creds (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value'),
+        keySelect: db.prepare('SELECT value FROM signal_keys WHERE type = ? AND id = ?'),
+        keyUpsert: db.prepare('INSERT INTO signal_keys (type, id, value) VALUES (?, ?, ?) ON CONFLICT(type, id) DO UPDATE SET value = excluded.value'),
+        keyDelete: db.prepare('DELETE FROM signal_keys WHERE type = ? AND id = ?'),
+        keyListIds: db.prepare('SELECT id FROM signal_keys WHERE type = ?'),
+        keyList: db.prepare('SELECT id, value FROM signal_keys WHERE type = ?'),
+        clearKeys: db.prepare('DELETE FROM signal_keys'),
+        clearCreds: db.prepare('DELETE FROM creds')
+    };
+    const loadCreds = () => {
+        const row = stmts.credsSelect.get(CREDS_ROW_KEY);
+        if (!row)
+            return initAuthCreds();
+        return JSON.parse(row.value, BufferJSON.reviver);
+    };
+    const persistCreds = (creds) => {
+        stmts.credsUpsert.run(CREDS_ROW_KEY, JSON.stringify(creds, BufferJSON.replacer));
+    };
+    const creds = loadCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const row = stmts.keySelect.get(type, id);
+                        if (row) {
+                            let value = JSON.parse(row.value, BufferJSON.reviver);
+                            if (type === 'app-state-sync-key' && value) {
+                                value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            data[id] = value;
+                        }
+                    }
+                    return data;
+                },
+                set: async (data) => {
+                    const writeTx = db.transaction(() => {
+                        for (const category in data) {
+                            for (const id in data[category]) {
+                                const value = data[category][id];
+                                if (value) {
+                                    const stringified = JSON.stringify(value, BufferJSON.replacer);
+                                    stmts.keyUpsert.run(category, id, stringified);
+                                }
+                                else {
+                                    stmts.keyDelete.run(category, id);
+                                }
+                            }
+                        }
+                    });
+                    writeTx();
+                }
+            }
+        },
+        saveCreds: async () => {
+            persistCreds(creds);
+        },
+        clearAuth: async () => {
+            const wipe = db.transaction(() => {
+                stmts.clearKeys.run();
+                stmts.clearCreds.run();
+            });
+            wipe();
+        },
+        close: async () => {
+            if (owned) {
+                db.close();
+            }
+        }
+    };
+}

package/src/Utils/useNekoDBAuth.d.ts

@@ -0,0 +1,19 @@
+export declare function useNekoDBAuth(
+    db: any,
+    collectionName?: string
+): Promise<{
+    state: {
+        creds: any
+        keys: {
+            get: (
+                type: string,
+                ids: string[]
+            ) => Promise<Record<string, any>>
+            set: (
+                data: Record<string, Record<string, any>>
+            ) => Promise<void>
+        }
+    }
+    saveCreds: () => Promise<void>
+    clearAuth: () => Promise<void>
+}>

package/src/Utils/useNekoDBAuth.js

@@ -0,0 +1,111 @@
+import { proto } from '../../WAProto/index.js'
+import { initAuthCreds } from './auth-utils.js'
+import { BufferJSON } from './generics.js'
+
+export async function useNekoDBAuth(db, collectionName = 'baileys_luna_auth') {
+    if (!db || typeof db.collection !== 'function') {
+        throw new Error(
+            'useNekoDBAuth: argumen pertama harus instance NekoDB yang terkoneksi'
+        )
+    }
+
+    const col = db.collection(collectionName).helper()
+
+    const writeData = async (data, key) => {
+        const value = JSON.stringify(data, BufferJSON.replacer)
+
+        await col.upsert(
+            { k: key },
+            {
+                k: key,
+                v: value
+            }
+        )
+    }
+
+    const readData = async key => {
+        try {
+            const doc = await col.findOne({ k: key })
+
+            if (!doc || doc.v == null) {
+                return null
+            }
+
+            return JSON.parse(doc.v, BufferJSON.reviver)
+        } catch {
+            return null
+        }
+    }
+
+    const removeData = async key => {
+        try {
+            await col.deleteWhere({ k: key })
+        } catch {}
+    }
+
+    const creds =
+        (await readData('creds')) ||
+        initAuthCreds()
+
+    return {
+        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 =
+                                    proto.Message.AppStateSyncKeyData.fromObject(
+                                        value
+                                    )
+                            }
+
+                            data[id] = value
+                        })
+                    )
+
+                    return data
+                },
+
+                set: async data => {
+                    const tasks = []
+
+                    for (const category in data) {
+                        const entries = data[category]
+
+                        for (const id in entries) {
+                            const value = entries[id]
+                            const key = `${category}-${id}`
+
+                            tasks.push(
+                                value
+                                    ? writeData(value, key)
+                                    : removeData(key)
+                            )
+                        }
+                    }
+
+                    await Promise.all(tasks)
+                }
+            }
+        },
+
+        saveCreds: async () => {
+            await writeData(creds, 'creds')
+        },
+
+        clearAuth: async () => {
+            try {
+                await db.deleteCollection(collectionName)
+            } catch {}
+        }
+    }
+}

package/src/Utils/username.d.ts

@@ -0,0 +1,12 @@
+export declare const USERNAME_MIN_LENGTH = 3;
+export declare const USERNAME_MAX_LENGTH = 35;
+export declare const USERNAME_PIN_LENGTH = 4;
+export type UsernameValidationErrorType = 'INVALID_CHARACTER' | 'INVALID_LENGTH' | 'INVALID_NO_LETTERS' | 'INVALID_PERIODS' | 'INVALID_DOMAIN_SUFFIX' | 'INVALID_WWW_PREFIX' | 'INVALID_WORD';
+export declare const UsernameValidationError: Record<UsernameValidationErrorType, UsernameValidationErrorType>;
+export declare const stripUsernamePrefix: (username: string) => string;
+export declare const displayUsername: (username: string) => string;
+export declare const validateUsername: (username: string) => {
+    isValid: boolean;
+    errorType?: UsernameValidationErrorType;
+};
+export declare const isUsernamePin: (pin: string) => boolean;

package/src/Utils/username.js

@@ -0,0 +1,58 @@
+export const USERNAME_MIN_LENGTH = 3;
+export const USERNAME_MAX_LENGTH = 35;
+export const USERNAME_PIN_LENGTH = 4;
+const LETTERS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const DIGITS = '0123456789';
+const LETTER_SET = new Set(LETTERS.split(''));
+const ALLOWED_SET = new Set([...LETTERS.split(''), ...DIGITS.split(''), '_', '.']);
+const RESERVED_SUFFIXES = ['.com', '.org', '.net', '.int', '.edu', '.gov', '.mil', '.arpa', '.html', '.htm', '.txt', '.xml'];
+const RESERVED_WORDS = ['whatsapp', 'instagram', 'facebook', 'oculus'];
+const PIN_PATTERN = /^[0-9]{4}$/;
+export const UsernameValidationError = {
+    INVALID_CHARACTER: 'INVALID_CHARACTER',
+    INVALID_LENGTH: 'INVALID_LENGTH',
+    INVALID_NO_LETTERS: 'INVALID_NO_LETTERS',
+    INVALID_PERIODS: 'INVALID_PERIODS',
+    INVALID_DOMAIN_SUFFIX: 'INVALID_DOMAIN_SUFFIX',
+    INVALID_WWW_PREFIX: 'INVALID_WWW_PREFIX',
+    INVALID_WORD: 'INVALID_WORD'
+};
+export const stripUsernamePrefix = (username) => {
+    return typeof username === 'string' && username.startsWith('@') ? username.slice(1) : username;
+};
+export const displayUsername = (username) => {
+    return '@' + stripUsernamePrefix(username);
+};
+export const validateUsername = (username) => {
+    const value = stripUsernamePrefix(username);
+    if (typeof value !== 'string') {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_CHARACTER };
+    }
+    const characters = Array.from(value);
+    if (!characters.every(character => ALLOWED_SET.has(character))) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_CHARACTER };
+    }
+    if (value.length < USERNAME_MIN_LENGTH || value.length > USERNAME_MAX_LENGTH) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_LENGTH };
+    }
+    if (!characters.some(character => LETTER_SET.has(character))) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_NO_LETTERS };
+    }
+    if (value.startsWith('.') || value.endsWith('.') || value.includes('..')) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_PERIODS };
+    }
+    const lowered = value.toLowerCase();
+    if (lowered.startsWith('www.')) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_WWW_PREFIX };
+    }
+    if (RESERVED_SUFFIXES.some(suffix => lowered.endsWith(suffix))) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_DOMAIN_SUFFIX };
+    }
+    if (RESERVED_WORDS.some(word => lowered.includes(word))) {
+        return { isValid: false, errorType: UsernameValidationError.INVALID_WORD };
+    }
+    return { isValid: true };
+};
+export const isUsernamePin = (pin) => {
+    return typeof pin === 'string' && PIN_PATTERN.test(pin);
+};

package/src/Utils/validate-connection.d.ts

@@ -0,0 +1,43 @@
+export function generateLoginNode(userJid: any, config: any): proto.ClientPayload;
+export function generateRegistrationNode({ registrationId, signedPreKey, signedIdentityKey }: {
+    registrationId: any;
+    signedPreKey: any;
+    signedIdentityKey: any;
+}, config: any): proto.ClientPayload;
+export function configureSuccessfulPairing(stanza: any, { advSecretKey, signedIdentityKey, signalIdentities }: {
+    advSecretKey: any;
+    signedIdentityKey: any;
+    signalIdentities: any;
+}): {
+    creds: {
+        account: proto.ADVSignedDeviceIdentity;
+        me: {
+            id: any;
+            name: any;
+            lid: any;
+        };
+        signalIdentities: any[];
+        platform: any;
+    };
+    reply: {
+        tag: string;
+        attrs: {
+            to: string;
+            type: string;
+            id: any;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: {
+                tag: string;
+                attrs: {
+                    'key-index': string;
+                };
+                content: any;
+            }[];
+        }[];
+    };
+};
+export function encodeSignedDeviceIdentity(account: any, includeSignatureKey: any): any;
+import { proto } from '../../WAProto/index.js';