gifted-baileys 1.5.6 → 1.5.7

package/src/Types/Product.ts

@@ -1,85 +0,0 @@
-import { WAMediaUpload } from './Message'
-
-export type CatalogResult = {
-	data: {
-		paging: { cursors: { before: string, after: string } }
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		data: any[]
-	}
-}
-
-export type ProductCreateResult = {
-	data: { product: {} }
-}
-
-export type CatalogStatus = {
-	status: string
-	canAppeal: boolean
-}
-
-export type CatalogCollection = {
-	id: string
-	name: string
-	products: Product[]
-
-	status: CatalogStatus
-}
-
-export type ProductAvailability = 'in stock'
-
-export type ProductBase = {
-	name: string
-	retailerId?: string
-	url?: string
-	description: string
-	price: number
-	currency: string
-	isHidden?: boolean
-}
-
-export type ProductCreate = ProductBase & {
-	/** ISO country code for product origin. Set to undefined for no country */
-	originCountryCode: string | undefined
-	/** images of the product */
-	images: WAMediaUpload[]
-}
-
-export type ProductUpdate = Omit<ProductCreate, 'originCountryCode'>
-
-export type Product = ProductBase & {
-	id: string
-	imageUrls: { [_: string]: string }
-	reviewStatus: { [_: string]: string }
-	availability: ProductAvailability
-}
-
-export type OrderPrice = {
-	currency: string
-	total: number
-}
-
-export type OrderProduct = {
-	id: string
-	imageUrl: string
-	name: string
-	quantity: number
-
-	currency: string
-	price: number
-}
-
-export type OrderDetails = {
-	price: OrderPrice
-	products: OrderProduct[]
-}
-
-export type CatalogCursor = string
-
-export type GetCatalogOptions = {
-	/** cursor to start from */
-	cursor?: CatalogCursor
-	/** number of products to fetch */
-	limit?: number
-
-	jid?: string
-}

package/src/Types/Signal.ts

@@ -1,68 +0,0 @@
-import { proto } from '../../WAProto'
-
-type DecryptGroupSignalOpts = {
-	group: string
-	authorJid: string
-	msg: Uint8Array
-}
-
-type ProcessSenderKeyDistributionMessageOpts = {
-	item: proto.Message.ISenderKeyDistributionMessage
-	authorJid: string
-}
-
-type DecryptSignalProtoOpts = {
-	jid: string
-	type: 'pkmsg' | 'msg'
-	ciphertext: Uint8Array
-}
-
-type EncryptMessageOpts = {
-	jid: string
-	data: Uint8Array
-}
-
-type EncryptGroupMessageOpts = {
-	group: string
-	data: Uint8Array
-	meId: string
-}
-
-type PreKey = {
-	keyId: number
-	publicKey: Uint8Array
-}
-
-type SignedPreKey = PreKey & {
-	signature: Uint8Array
-}
-
-type E2ESession = {
-	registrationId: number
-	identityKey: Uint8Array
-	signedPreKey: SignedPreKey
-	preKey: PreKey
-}
-
-type E2ESessionOpts = {
-	jid: string
-	session: E2ESession
-}
-
-export type SignalRepository = {
-	decryptGroupMessage(opts: DecryptGroupSignalOpts): Promise<Uint8Array>
-	processSenderKeyDistributionMessage(
-		opts: ProcessSenderKeyDistributionMessageOpts
-	): Promise<void>
-	decryptMessage(opts: DecryptSignalProtoOpts): Promise<Uint8Array>
-	encryptMessage(opts: EncryptMessageOpts): Promise<{
-		type: 'pkmsg' | 'msg'
-		ciphertext: Uint8Array
-	}>
-	encryptGroupMessage(opts: EncryptGroupMessageOpts): Promise<{
-		senderKeyDistributionMessage: Uint8Array
-		ciphertext: Uint8Array
-	}>
-	injectE2ESession(opts: E2ESessionOpts): Promise<void>
-	jidToSignalProtocolAddress(jid: string): string
-}

package/src/Types/State.ts

@@ -1,29 +0,0 @@
-import { Contact } from './Contact'
-
-export type WAConnectionState = 'open' | 'connecting' | 'close'
-
-export type ConnectionState = {
-	/** connection is now open, connecting or closed */
-	connection: WAConnectionState
-	/** the error that caused the connection to close */
-	lastDisconnect?: {
-		error: Error | undefined
-		date: Date
-	}
-	/** is this a new login */
-	isNewLogin?: boolean
-	/** the current QR code */
-	qr?: string
-	/** has the device received all pending notifications while it was offline */
-	receivedPendingNotifications?: boolean
-	/** legacy connection options */
-	legacy?: {
-		phoneConnected: boolean
-		user?: Contact
-	}
-	/**
-	 * if the client is shown as an active, online client.
-	 * If this is false, the primary phone and other devices will receive notifs
-	 * */
-	isOnline?: boolean
-}

package/src/Types/index.ts

@@ -1,59 +0,0 @@
-export * from './Auth'
-export * from './GroupMetadata'
-export * from './Chat'
-export * from './Contact'
-export * from './State'
-export * from './Message'
-export * from './Newsletter'
-export * from './Socket'
-export * from './Events'
-export * from './Product'
-export * from './Call'
-export * from './Signal'
-
-import { AuthenticationState } from './Auth'
-import { SocketConfig } from './Socket'
-
-export type UserFacingSocketConfig = Partial<SocketConfig> & { auth: AuthenticationState }
-
-export enum DisconnectReason {
-    connectionClosed = 428,
-    connectionLost = 408,
-    connectionReplaced = 440,
-    timedOut = 408,
-    loggedOut = 401,
-    badSession = 500,
-    restartRequired = 515,
-    multideviceMismatch = 411,
-    forbidden = 403,
-    unavailableService = 503
-}
-
-export type WAInitResponse = {
-    ref: string
-    ttl: number
-    status: 200
-}
-
-export type WABusinessHoursConfig = {
-    day_of_week: string
-    mode: string
-    open_time?: number
-    close_time?: number
-}
-
-export type WABusinessProfile = {
-    description: string
-    email: string | undefined
-    business_hours: {
-        timezone?: string
-        config?: WABusinessHoursConfig[]
-        business_config?: WABusinessHoursConfig[]
-    }
-    website: string[]
-    category?: string
-    wid?: string
-    address?: string
-}
-
-export type CurveKeyPair = { private: Uint8Array, public: Uint8Array }

package/src/Utils/auth-utils.ts

@@ -1,222 +0,0 @@
-import { randomBytes } from 'crypto'
-import NodeCache from 'node-cache'
-import type { Logger } from 'pino'
-import { v4 as uuidv4 } from 'uuid'
-import { DEFAULT_CACHE_TTLS } from '../Defaults'
-import type { AuthenticationCreds, CacheStore, SignalDataSet, SignalDataTypeMap, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types'
-import { Curve, signedKeyPair } from './crypto'
-import { delay, generateRegistrationId } from './generics'
-
-/**
- * Adds caching capability to a SignalKeyStore
- * @param store the store to add caching to
- * @param logger to log trace events
- * @param _cache cache store to use
- */
-export function makeCacheableSignalKeyStore(
-	store: SignalKeyStore,
-	logger: Logger,
-	_cache?: CacheStore
-): SignalKeyStore {
-	const cache = _cache || new NodeCache({
-		stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
-		useClones: false,
-		deleteOnExpire: true,
-	})
-
-	function getUniqueId(type: string, id: string) {
-		return `${type}.${id}`
-	}
-
-	return {
-		async get(type, ids) {
-			const data: { [_: string]: SignalDataTypeMap[typeof type] } = { }
-			const idsToFetch: string[] = []
-			for(const id of ids) {
-				const item = cache.get<SignalDataTypeMap[typeof type]>(getUniqueId(type, id))
-				if(typeof item !== 'undefined') {
-					data[id] = item
-				} else {
-					idsToFetch.push(id)
-				}
-			}
-
-			if(idsToFetch.length) {
-				logger.trace({ items: idsToFetch.length }, 'loading from store')
-				const fetched = await store.get(type, idsToFetch)
-				for(const id of idsToFetch) {
-					const item = fetched[id]
-					if(item) {
-						data[id] = item
-						cache.set(getUniqueId(type, id), item)
-					}
-				}
-			}
-
-			return data
-		},
-		async set(data) {
-			let keys = 0
-			for(const type in data) {
-				for(const id in data[type]) {
-					cache.set(getUniqueId(type, id), data[type][id])
-					keys += 1
-				}
-			}
-
-			logger.trace({ keys }, 'updated cache')
-
-			await store.set(data)
-		},
-		async clear() {
-			cache.flushAll()
-			await store.clear?.()
-		}
-	}
-}
-
-/**
- * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
- * this allows batch read & write operations & improves the performance of the lib
- * @param state the key store to apply this capability to
- * @param logger logger to log events
- * @returns SignalKeyStore with transaction capability
- */
-export const addTransactionCapability = (
-	state: SignalKeyStore,
-	logger: Logger,
-	{ maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions
-): SignalKeyStoreWithTransaction => {
-	// number of queries made to the DB during the transaction
-	// only there for logging purposes
-	let dbQueriesInTransaction = 0
-	let transactionCache: SignalDataSet = { }
-	let mutations: SignalDataSet = { }
-
-	let transactionsInProgress = 0
-
-	return {
-		get: async(type, ids) => {
-			if(isInTransaction()) {
-				const dict = transactionCache[type]
-				const idsRequiringFetch = dict
-					? ids.filter(item => typeof dict[item] === 'undefined')
-					: ids
-				// only fetch if there are any items to fetch
-				if(idsRequiringFetch.length) {
-					dbQueriesInTransaction += 1
-					const result = await state.get(type, idsRequiringFetch)
-
-					transactionCache[type] ||= {}
-					Object.assign(
-						transactionCache[type]!,
-						result
-					)
-				}
-
-				return ids.reduce(
-					(dict, id) => {
-						const value = transactionCache[type]?.[id]
-						if(value) {
-							dict[id] = value
-						}
-
-						return dict
-					}, { }
-				)
-			} else {
-				return state.get(type, ids)
-			}
-		},
-		set: data => {
-			if(isInTransaction()) {
-				logger.trace({ types: Object.keys(data) }, 'caching in transaction')
-				for(const key in data) {
-					transactionCache[key] = transactionCache[key] || { }
-					Object.assign(transactionCache[key], data[key])
-
-					mutations[key] = mutations[key] || { }
-					Object.assign(mutations[key], data[key])
-				}
-			} else {
-				return state.set(data)
-			}
-		},
-		isInTransaction,
-		async transaction(work) {
-			let result: Awaited<ReturnType<typeof work>>
-			transactionsInProgress += 1
-			if(transactionsInProgress === 1) {
-				logger.trace('entering transaction')
-			}
-
-			try {
-				result = await work()
-				// commit if this is the outermost transaction
-				if(transactionsInProgress === 1) {
-					if(Object.keys(mutations).length) {
-						logger.trace('committing transaction')
-						// retry mechanism to ensure we've some recovery
-						// in case a transaction fails in the first attempt
-						let tries = maxCommitRetries
-						while(tries) {
-							tries -= 1
-							try {
-								await state.set(mutations)
-								logger.trace({ dbQueriesInTransaction }, 'committed transaction')
-								break
-							} catch(error) {
-								logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`)
-								await delay(delayBetweenTriesMs)
-							}
-						}
-					} else {
-						logger.trace('no mutations in transaction')
-					}
-				}
-			} finally {
-				transactionsInProgress -= 1
-				if(transactionsInProgress === 0) {
-					transactionCache = { }
-					mutations = { }
-					dbQueriesInTransaction = 0
-				}
-			}
-
-			return result
-		}
-	}
-
-	function isInTransaction() {
-		return transactionsInProgress > 0
-	}
-}
-
-export const initAuthCreds = (): AuthenticationCreds => {
-	const identityKey = Curve.generateKeyPair()
-	return {
-		noiseKey: Curve.generateKeyPair(),
-		pairingEphemeralKeyPair: Curve.generateKeyPair(),
-		signedIdentityKey: identityKey,
-		signedPreKey: signedKeyPair(identityKey, 1),
-		registrationId: generateRegistrationId(),
-		advSecretKey: randomBytes(32).toString('base64'),
-		processedHistoryMessages: [],
-		nextPreKeyId: 1,
-		firstUnuploadedPreKeyId: 1,
-		accountSyncCounter: 0,
-		accountSettings: {
-			unarchiveChats: false
-		},
-		// mobile creds
-		deviceId: Buffer.from(uuidv4().replace(/-/g, ''), 'hex').toString('base64url'),
-		phoneId: uuidv4(),
-		identityId: randomBytes(20),
-		registered: false,
-		backupToken: randomBytes(20),
-		registration: {} as never,
-		pairingCode: undefined,
-		lastPropHash: undefined,
-		routingInfo: undefined,
-	}
-}

package/src/Utils/baileys-event-stream.js

@@ -1,92 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readAndEmitEventStream = exports.captureEventStream = void 0;
-const events_1 = __importDefault(require("events"));
-const fs_1 = require("fs");
-const promises_1 = require("fs/promises");
-const readline_1 = require("readline");
-const generics_1 = require("./generics");
-const make_mutex_1 = require("./make-mutex");
-/**
- * Captures events from a baileys event emitter & stores them in a file
- * @param ev The event emitter to read events from
- * @param filename File to save to
- */
-const captureEventStream = (ev, filename) => {
-    const oldEmit = ev.emit;
-    // write mutex so data is appended in order
-    const writeMutex = (0, make_mutex_1.makeMutex)();
-    // monkey patch eventemitter to capture all events
-    ev.emit = function (...args) {
-        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n';
-        const result = oldEmit.apply(ev, args);
-        writeMutex.mutex(() => __awaiter(this, void 0, void 0, function* () {
-            yield (0, promises_1.writeFile)(filename, content, { flag: 'a' });
-        }));
-        return result;
-    };
-};
-exports.captureEventStream = captureEventStream;
-/**
- * Read event file and emit events from there
- * @param filename filename containing event data
- * @param delayIntervalMs delay between each event emit
- */
-const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
-    const ev = new events_1.default();
-    const fireEvents = () => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, e_1, _b, _c;
-        // from: https://stackoverflow.com/questions/6156501/read-a-file-one-line-at-a-time-in-node-js
-        const fileStream = (0, fs_1.createReadStream)(filename);
-        const rl = (0, readline_1.createInterface)({
-            input: fileStream,
-            crlfDelay: Infinity
-        });
-        try {
-            // Note: we use the crlfDelay option to recognize all instances of CR LF
-            // ('\r\n') in input.txt as a single line break.
-            for (var _d = true, rl_1 = __asyncValues(rl), rl_1_1; rl_1_1 = yield rl_1.next(), _a = rl_1_1.done, !_a; _d = true) {
-                _c = rl_1_1.value;
-                _d = false;
-                const line = _c;
-                if (line) {
-                    const { event, data } = JSON.parse(line);
-                    ev.emit(event, data);
-                    delayIntervalMs && (yield (0, generics_1.delay)(delayIntervalMs));
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = rl_1.return)) yield _b.call(rl_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        fileStream.close();
-    });
-    return {
-        ev,
-        task: fireEvents()
-    };
-};
-exports.readAndEmitEventStream = readAndEmitEventStream;

package/src/Utils/baileys-event-stream.ts

@@ -1,66 +0,0 @@
-import EventEmitter from 'events'
-import { createReadStream } from 'fs'
-import { writeFile } from 'fs/promises'
-import { createInterface } from 'readline'
-import type { BaileysEventEmitter } from '../Types'
-import { delay } from './generics'
-import { makeMutex } from './make-mutex'
-
-/**
- * Captures events from a baileys event emitter & stores them in a file
- * @param ev The event emitter to read events from
- * @param filename File to save to
- */
-export const captureEventStream = (ev: BaileysEventEmitter, filename: string) => {
-	const oldEmit = ev.emit
-	// write mutex so data is appended in order
-	const writeMutex = makeMutex()
-	// monkey patch eventemitter to capture all events
-	ev.emit = function(...args: any[]) {
-		const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n'
-		const result = oldEmit.apply(ev, args)
-
-		writeMutex.mutex(
-			async() => {
-				await writeFile(filename, content, { flag: 'a' })
-			}
-		)
-
-		return result
-	}
-}
-
-/**
- * Read event file and emit events from there
- * @param filename filename containing event data
- * @param delayIntervalMs delay between each event emit
- */
-export const readAndEmitEventStream = (filename: string, delayIntervalMs: number = 0) => {
-	const ev = new EventEmitter() as BaileysEventEmitter
-
-	const fireEvents = async() => {
-		// from: https://stackoverflow.com/questions/6156501/read-a-file-one-line-at-a-time-in-node-js
-		const fileStream = createReadStream(filename)
-
-		const rl = createInterface({
-			input: fileStream,
-			crlfDelay: Infinity
-		})
-		// Note: we use the crlfDelay option to recognize all instances of CR LF
-		// ('\r\n') in input.txt as a single line break.
-		for await (const line of rl) {
-			if(line) {
-				const { event, data } = JSON.parse(line)
-				ev.emit(event, data)
-				delayIntervalMs && await delay(delayIntervalMs)
-			}
-		}
-
-		fileStream.close()
-	}
-
-	return {
-		ev,
-		task: fireEvents()
-	}
-}