iobroker.javascript 8.9.2 → 9.0.1

package/lib/protectFs.js

@@ -1,401 +0,0 @@
-const nodeFS = require('node:fs');
-const path = require('node:path');
-
-const ProtectFs = function (log, ioBrokerDataDir) {
-    function checkProtected(file, readonly) {
-        const filePath = path.normalize(file);
-
-        if (filePath.endsWith(`-data${path.sep}objects.json`) || filePath.endsWith(`-data${path.sep}objects.jsonl`)) {
-            if (log) {
-                log.error(`May not read ${file}`);
-            } else {
-                console.error(`May not read ${file}`);
-            }
-            throw new Error('Permission denied');
-        } else if (!readonly && filePath.startsWith(path.join(ioBrokerDataDir, 'files'))) {
-            if (log) {
-                log.error(`May not read ${file} - use ${readonly ? 'readFile' : 'writeFile'} instead`);
-            } else {
-                console.error(`May not read ${file} - use ${readonly ? 'readFile' : 'writeFile'} instead`);
-            }
-            throw new Error('Permission denied');
-        }
-    }
-
-    this.access = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.access.apply(this, arguments); // function access(path, mode, callback) {
-    };
-    this.accessSync = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.accessSync.apply(this, arguments); // function accessSync(path, mode) {
-    };
-    this.cp = function () {
-        checkProtected(arguments[0], false);
-        checkProtected(arguments[1], false);
-        return nodeFS.cp.apply(this, arguments); // function cp(src, dest, options, callback) {
-    };
-    this.cpSync = function () {
-        checkProtected(arguments[0], false);
-        checkProtected(arguments[1], false);
-        return nodeFS.cpSync.apply(this, arguments); // function cpSync(src, dest, options) {
-    };
-    this.readFile = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.readFile.apply(this, arguments); // function readFile(path, options, callback) {
-    };
-    this.readFileSync = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.readFileSync.apply(this, arguments); // function readFileSync(path, options) {
-    };
-    this.readlink = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.readlink.apply(this, arguments); // function readlink(path, options, callback) {
-    };
-    this.readlinkSync = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.readlinkSync.apply(this, arguments); // function readlinkSync(path, options) {
-    };
-    this.symlink = function () {
-        checkProtected(arguments[0], true);
-        checkProtected(arguments[0], false);
-        return nodeFS.symlink.apply(this, arguments); // function symlink(target, path, type_, callback_) {
-    };
-    this.symlinkSync = function () {
-        checkProtected(arguments[0], true);
-        checkProtected(arguments[0], false);
-        return nodeFS.symlinkSync.apply(this, arguments); // function symlinkSync(target, path, type) {
-    };
-    this.writeFile = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.writeFile.apply(this, arguments); // function writeFile(path, data, options, callback) {
-    };
-    this.writeFileSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.writeFileSync.apply(this, arguments); // function writeFileSync(path, data, options) {
-    };
-    this.unlink = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.unlink.apply(this, arguments); // function unlink(path, callback) {
-    };
-    this.unlinkSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.unlinkSync.apply(this, arguments); // function unlinkSync(path) {
-    };
-    this.appendFile = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.appendFile.apply(this, arguments); // function appendFile(path, data, options, callback) {
-    };
-    this.appendFileSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.appendFileSync.apply(this, arguments); // function appendFileSync(path, data, options) {
-    };
-    this.chmod = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.chmod.apply(this, arguments); // function chmod(path, mode, callback) {
-    };
-    this.chmodSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.chmodSync.apply(this, arguments); // function chmodSync(path, mode) {
-    };
-    this.chown = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.chmodSync.apply(this, arguments); // function chown(path, uid, gid, callback) {
-    };
-    this.chownSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.chownSync.apply(this, arguments); // function chownSync(path, uid, gid) {
-    };
-    this.copyFile = function () {
-        checkProtected(arguments[0], false);
-        checkProtected(arguments[1], false);
-        return nodeFS.copyFile.apply(this, arguments); // function copyFile(src, dest, mode, callback) {
-    };
-    this.copyFileSync = function () {
-        checkProtected(arguments[0], true);
-        checkProtected(arguments[1], false);
-        return nodeFS.copyFileSync.apply(this, arguments); // function copyFileSync(src, dest, mode) {
-    };
-    this.rename = function () {
-        checkProtected(arguments[0], false);
-        checkProtected(arguments[1], false);
-        return nodeFS.rename.apply(this, arguments); // function rename(oldPath, newPath, callback) {
-    };
-    this.renameSync = function () {
-        checkProtected(arguments[0], false);
-        checkProtected(arguments[1], false);
-        return nodeFS.renameSync.apply(this, arguments); // function renameSync(oldPath, newPath) {
-    };
-    this.open = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.open.apply(this, arguments); // function open(path, flags, mode, callback) {
-    };
-    this.openSync = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.openSync.apply(this, arguments); // function openSync(path, flags, mode) {
-    };
-    this.truncate = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.truncate.apply(this, arguments); // function truncate(path, len, callback) {
-    };
-    this.truncateSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.truncateSync.apply(this, arguments); // function truncateSync(path, len) {
-    };
-    this.exists = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.exists.apply(this, arguments); // function exists(path, callback) {
-    };
-    this.existsSync = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.existsSync.apply(this, arguments); // function existsSync(path) {
-    };
-    this.stat = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.stat.apply(this, arguments); // function stat(path, options = { bigint: false }, callback) {
-    };
-    this.statSync = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.statSync.apply(this, arguments); // function statSync(path, options = { bigint: false, throwIfNoEntry: true }) {
-    };
-    this.utimes = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.utimes.apply(this, arguments); // function utimes(path, atime, mtime, callback) {
-    };
-    this.utimesSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.utimesSync.apply(this, arguments); // function utimesSync(path, atime, mtime) {
-    };
-    this.readdir = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.readdir.apply(this, arguments); // function readdir(path, options, callback) {
-    };
-    this.readdirSync = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.readdirSync.apply(this, arguments); // function readdirSync(path, options) {
-    };
-    this.createReadStream = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.createReadStream.apply(this, arguments); // function createReadStream(path, options) {
-    };
-    this.createWriteStream = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.createWriteStream.apply(this, arguments); // function createWriteStream(path, options) {
-    };
-    this.lchmod = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.lchmod.apply(this, arguments); // function lchmod(path, mode, callback) {
-    };
-    this.lchmodSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.lchmodSync.apply(this, arguments); // function lchmodSync(path, mode) {
-    };
-    this.lchown = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.lchown.apply(this, arguments); // function lchown(path, uid, gid, callback) {
-    };
-    this.lchownSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.lchownSync.apply(this, arguments); // function lchownSync(path, uid, gid) {
-    };
-    this.link = function () {
-        checkProtected(arguments[0], false);
-        checkProtected(arguments[1], false);
-        return nodeFS.link.apply(this, arguments); // function link(existingPath, newPath, callback) {
-    };
-    this.linkSync = function () {
-        checkProtected(arguments[0], false);
-        checkProtected(arguments[1], false);
-        return nodeFS.linkSync.apply(this, arguments); // function linkSync(existingPath, newPath) {
-    };
-    this.lstat = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.lstat.apply(this, arguments); // function lstat(path, options = { bigint: false }, callback) {
-    };
-    this.lstatSync = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.lstatSync.apply(this, arguments); // function lstatSync(path, options = { bigint: false, throwIfNoEntry: true }) {
-    };
-    this.lutimes = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.lutimes.apply(this, arguments); // function lutimes(path, atime, mtime, callback) {
-    };
-    this.lutimesSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.lutimesSync.apply(this, arguments); // function lutimesSync(path, atime, mtime) {
-    };
-    this.mkdir = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.mkdir.apply(this, arguments); // function mkdir(path, options, callback) {
-    };
-    this.mkdirSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.mkdirSync.apply(this, arguments); // function mkdirSync(path, options) {
-    };
-    this.mkdtemp = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.mkdtemp.apply(this, arguments); // function mkdtemp(prefix, options, callback) {
-    };
-    this.mkdtempSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.mkdtempSync.apply(this, arguments); // function mkdtempSync(prefix, options) {
-    };
-    this.rm = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.rm.apply(this, arguments); // function rm(path, options, callback) {
-    };
-    this.rmSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.rmSync.apply(this, arguments); // function rmSync(path, options) {
-    };
-    this.rmdir = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.rmdir.apply(this, arguments); // function rmdir(path, options, callback) {
-    };
-    this.rmdirSync = function () {
-        checkProtected(arguments[0], false);
-        return nodeFS.rmdirSync.apply(this, arguments); // function rmdirSync(path, options) {
-    };
-    this.watch = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.watch.apply(this, arguments); // function watch(filename, options, listener) {
-    };
-    this.watchFile = function () {
-        checkProtected(arguments[0], true);
-        return nodeFS.watchFile.apply(this, arguments); // function watchFile(filename, options, listener) {
-    };
-
-    this.promises = {
-        access: async function () {
-            checkProtected(arguments[0], true);
-            return nodeFS.promises.access.apply(this, arguments); // async function access(path, mode = F_OK) {
-        },
-        cp: async function () {
-            checkProtected(arguments[0], false);
-            checkProtected(arguments[1], false);
-            return nodeFS.promises.cp.apply(this, arguments); // async function cp(src, dest, options) {
-        },
-        readFile: async function () {
-            checkProtected(arguments[0], true);
-            return nodeFS.promises.readFile.apply(this, arguments); // async function readFile(path, options) {
-        },
-        readlink: async function () {
-            checkProtected(arguments[0], true);
-            return nodeFS.promises.readlink.apply(this, arguments); // async function readlink(path, options) {
-        },
-        symlink: async function () {
-            checkProtected(arguments[0], true);
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.symlink.apply(this, arguments); // async function symlink(target, path, type_) {
-        },
-        writeFile: async function () {
-            checkProtected(arguments[0], true);
-            return nodeFS.promises.writeFile.apply(this, arguments); // async function writeFile(path, data, options) {
-        },
-        unlink: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.unlink.apply(this, arguments); // async function unlink(path) {
-        },
-        appendFile: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.appendFile.apply(this, arguments); // async function appendFile(path, data, options) {
-        },
-        chmod: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.chmod.apply(this, arguments); // async function chmod(path, mode) {
-        },
-        chown: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.chmodSync.apply(this, arguments); // async function chown(path, uid, gid) {
-        },
-        copyFile: function () {
-            checkProtected(arguments[0], false);
-            checkProtected(arguments[1], false);
-            return nodeFS.promises.copyFile.apply(this, arguments); // async function copyFile(src, dest, mode) {
-        },
-        rename: async function () {
-            checkProtected(arguments[0], false);
-            checkProtected(arguments[1], false);
-            return nodeFS.promises.rename.apply(this, arguments); // async function rename(oldPath, newPath) {
-        },
-        open: async function () {
-            checkProtected(arguments[0], true);
-            return nodeFS.promises.open.apply(this, arguments); // async function open(path, flags, mode) {
-        },
-        truncate: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.truncate.apply(this, arguments); // async function truncate(path, len = 0) {
-        },
-        stat: async function () {
-            checkProtected(arguments[0], true);
-            return nodeFS.promises.stat.apply(this, arguments); // async function stat(path, options = { bigint: false }) {
-        },
-        utimes: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.utimes.apply(this, arguments); // async function utimes(path, atime, mtime) {
-        },
-        readdir: async function () {
-            checkProtected(arguments[0], true);
-            return nodeFS.promises.readdir.apply(this, arguments); // async function readdir(path, options) {
-        },
-        lchmod: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.lchmod.apply(this, arguments); // async function lchmod(path, mode) {
-        },
-        lchown: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.lchown.apply(this, arguments); // async function lchown(path, uid, gid) {
-        },
-        link: async function () {
-            checkProtected(arguments[0], false);
-            checkProtected(arguments[1], false);
-            return nodeFS.promises.link.apply(this, arguments); // async function link(existingPath, newPath) {
-        },
-        lstat: async function () {
-            checkProtected(arguments[0], true);
-            return nodeFS.promises.lstat.apply(this, arguments); // async function lstat(path, options = { bigint: false }) {
-        },
-        lutimes: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.lutimes.apply(this, arguments); // async function lutimes(path, atime, mtime) {
-        },
-        mkdir: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.mkdir.apply(this, arguments); // async function mkdir(path, options) {
-        },
-        mkdtemp: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.mkdtemp.apply(this, arguments); // async function mkdtemp(prefix, options) {
-        },
-        rm: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.rm.apply(this, arguments); // async function rm(path, options) {
-        },
-        rmdir: async function () {
-            checkProtected(arguments[0], false);
-            return nodeFS.promises.rmdir.apply(this, arguments); // async function rmdir(path, options) {
-        }
-    };
-
-    // Add missing constants
-    this.constants = nodeFS.constants;
-
-    // Add missing functions
-    for (const m in nodeFS) {
-        if (typeof nodeFS[m] === 'function' && Object.hasOwn(nodeFS, m) && !Object.hasOwn(this, m)) {
-            // console.debug(`Missing function in ProtectFS: ${m} - adding from node:fs`);
-            this[m] = nodeFS[m];
-        }
-    }
-
-    for (const m in nodeFS.promises) {
-        if (typeof nodeFS.promises[m] === 'function' && Object.hasOwn(nodeFS.promises, m) && !Object.hasOwn(this.promises, m)) {
-            // console.debug(`Missing function in ProtectFS: ${m} - adding from node:fs/promises`);
-            this.promises[m] = nodeFS.promises[m];
-        }
-    }
-
-    return this;
-};
-
-module.exports = ProtectFs;

package/lib/request.js

@@ -1,72 +0,0 @@
-// This module monkey-patches request for the sandbox
-// so unhandled errors in the callback or forgetting to
-// attach the error event handler does not bring down the adapter
-
-const _request = require('request');
-
-let logger = {
-    error: error => console.error(error),
-};
-
-function requestError(error) {
-    logger.error(`Request error: ${error}`);
-}
-
-/**
- * Calls a request method which accepts a callback and handles errors in the request and the callback itself
- * @param {(...args: any[]) => any} method
- * @param  {...any} args
- */
-function requestSafe(method, ...args) {
-    const lastArg = args[args.length - 1];
-    if (typeof lastArg === 'function') {
-        // If a callback was provided, handle errors in the callback
-        const otherArgs = args.slice(0, args.length - 1);
-        return method(...otherArgs, (...cbArgs) => {
-            try {
-                lastArg(...cbArgs);
-            } catch (e) {
-                logger.error(`Error in request callback: ${e}`);
-            }
-        }).on('error', requestError);
-    } else {
-        // otherwise, just pass the call through
-        return method(...args).on('error', requestError);
-    }
-}
-
-// Wrap all methods that accept a callback
-const methodsWithCallback = [
-    'get',
-    'post',
-    'put',
-    'head',
-    'patch',
-    'del',
-    'delete',
-    'initParams',
-];
-// and request itself
-const request = (...args) => requestSafe(_request, ...args);
-for (const methodName of methodsWithCallback) {
-    request[methodName] = (...args) => requestSafe(_request[methodName], ...args);
-}
-
-// And copy all other properties and methods
-const otherPropsAndMethods = [
-    'defaults',
-    'forever',
-    'jar',
-    'cookie',
-    'debug',
-];
-for (const propName of otherPropsAndMethods) {
-    request[propName] = _request[propName];
-}
-
-request.setLogger = function (_logger) {
-    logger = _logger;
-};
-
-// end of monkeypatching
-module.exports = request;