feat(reliability): WhatsApp Web version caching (#1847)

* feat: use specific whatsapp web version

* add constants to version updater

* configurable caches

* rename

* typings

* rm extraneous export

* missing from the rename

* rm version resolver

* match readme version

* use try-catch

* only persist if cache miss

src/webCache/LocalWebCache.js

@@ -0,0 +1,43 @@
+const path = require('path');
+const fs = require('fs');
+
+const { WebCache, VersionResolveError } = require('./WebCache');
+
+/**
+ * LocalWebCache - Fetches a WhatsApp Web version from a local file store
+ * @param {object} options - options
+ * @param {string} options.path - Path to the directory where cached versions are saved, default is: "./.wwebjs_cache/" 
+ * @param {boolean} options.strict - If true, will throw an error if the requested version can't be fetched. If false, will resolve to the latest version.
+ */
+class LocalWebCache extends WebCache {
+    constructor(options = {}) {
+        super();
+
+        this.path = options.path || './.wwebjs_cache/';
+        this.strict = options.strict || false;
+    }
+
+    async resolve(version) {
+        const filePath = path.join(this.path, `${version}.html`);
+        
+        try {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (err) {
+            if (this.strict) throw new VersionResolveError(`Couldn't load version ${version} from the cache`);
+            return null;
+        }
+    }
+
+    async persist(indexHtml) {
+        // extract version from index (e.g. manifest-2.2206.9.json -> 2.2206.9)
+        const version = indexHtml.match(/manifest-([\d\\.]+)\.json/)[1];
+        if(!version) return;
+   
+        const filePath = path.join(this.path, `${version}.html`);
+        fs.mkdirSync(this.path, { recursive: true });
+        fs.writeFileSync(filePath, indexHtml);
+    }
+}
+
+module.exports = LocalWebCache;

src/webCache/RemoteWebCache.js

@@ -0,0 +1,40 @@
+const fetch = require('node-fetch');
+const { WebCache, VersionResolveError } = require('./WebCache');
+
+/**
+ * RemoteWebCache - Fetches a WhatsApp Web version index from a remote server
+ * @param {object} options - options
+ * @param {string} options.remotePath - Endpoint that should be used to fetch the version index. Use {version} as a placeholder for the version number.
+ * @param {boolean} options.strict - If true, will throw an error if the requested version can't be fetched. If false, will resolve to the latest version. Defaults to false.
+ */
+class RemoteWebCache extends WebCache {
+    constructor(options = {}) {
+        super();
+
+        if (!options.remotePath) throw new Error('webVersionCache.remotePath is required when using the remote cache');
+        this.remotePath = options.remotePath;
+        this.strict = options.strict || false;
+    }
+
+    async resolve(version) {
+        const remotePath = this.remotePath.replace('{version}', version);
+
+        try {
+            const cachedRes = await fetch(remotePath);
+            if (cachedRes.ok) {
+                return cachedRes.text();
+            }
+        } catch (err) {
+            console.error(`Error fetching version ${version} from remote`, err);
+        }
+
+        if (this.strict) throw new VersionResolveError(`Couldn't load version ${version} from the archive`);
+        return null;         
+    }
+
+    async persist() {
+        // Nothing to do here
+    }
+}
+
+module.exports = RemoteWebCache;

src/webCache/WebCache.js

@@ -0,0 +1,14 @@
+/**
+ * Default implementation of a web version cache that does nothing.
+ */
+class WebCache {
+    async resolve() { return null; }
+    async persist() { }
+}
+
+class VersionResolveError extends Error { }
+
+module.exports = {
+    WebCache,
+    VersionResolveError
+};

src/webCache/WebCacheFactory.js

@@ -0,0 +1,20 @@
+const RemoteWebCache = require('./RemoteWebCache');
+const LocalWebCache = require('./LocalWebCache');
+const { WebCache } = require('./WebCache');
+
+const createWebCache = (type, options) => {
+    switch (type) {
+    case 'remote':
+        return new RemoteWebCache(options);
+    case 'local':
+        return new LocalWebCache(options);
+    case 'none':
+        return new WebCache();
+    default:
+        throw new Error(`Invalid WebCache type ${type}`);
+    }
+};
+
+module.exports = {
+    createWebCache,
+};