@iobroker/db-base 4.0.0-alpha.8-20210909-001a711c → 4.0.3

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014-2020 bluefox<dogafox@gmail.com>,
+Copyright (c) 2014-2022 bluefox<dogafox@gmail.com>,
 Copyright (c) 2014      hobbyquaker
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

package/README.md

@@ -4,5 +4,5 @@ This Library contains base classes that are used by the database classes for ioB
 ## License
 The MIT License (MIT)
 
-Copyright (c) 2014-2020 bluefox <dogafox@gmail.com>,
+Copyright (c) 2014-2022 bluefox <dogafox@gmail.com>,
 Copyright (c) 2014      hobbyquaker

package/lib/constants.js

@@ -0,0 +1,6 @@
+const Resp = require('respjs');
+
+module.exports = {
+    QUEUED_STR_BUF: Resp.encodeString('QUEUED'),
+    OK_STR_BUF: Resp.encodeString('OK')
+};

package/lib/inMemFileDB.js

@@ -1,7 +1,7 @@
 /**
  *      States DB in memory - Server
  *
- *      Copyright 2013-2021 bluefox <dogafox@gmail.com>
+ *      Copyright 2013-2022 bluefox <dogafox@gmail.com>
  *
  *      MIT License
  *
@@ -14,9 +14,9 @@
 /* jslint node: true */
 'use strict';
 
-const fs                = require('fs-extra');
-const path              = require('path');
-const tools             = require('./tools.js');
+const fs = require('fs-extra');
+const path = require('path');
+const tools = require('./tools.js');
 
 // settings = {
 //    change:    function (id, state) {},
@@ -44,7 +44,6 @@ const tools             = require('./tools.js');
  * and general subscription and publish functionality
  **/
 class InMemoryFileDB {
-
     constructor(settings) {
         this.settings = settings || {};
 
@@ -57,15 +56,15 @@ class InMemoryFileDB {
         this.zlib = null;
         this.callbackSubscriptionClient = {};
 
-        this.settings.backup = this.settings.backup || {
-            disabled: false,  // deactivates
-            files: 24,     // minimum number of files
-            hours: 48,     // hours
-            period: 120,    // minutes
-            path: ''      // use default path
+        this.settings.backup = this.settings.connection.backup || {
+            disabled: false, // deactivates
+            files: 24, // minimum number of files
+            hours: 48, // hours
+            period: 120, // minutes
+            path: '' // use default path
         };
 
-        this.dataDir = (this.settings.connection.dataDir || tools.getDefaultDataDir());
+        this.dataDir = this.settings.connection.dataDir || tools.getDefaultDataDir();
         if (!path.isAbsolute(this.dataDir)) {
             this.dataDir = path.normalize(path.join(tools.getControllerDir(), this.dataDir));
         }
@@ -77,7 +76,7 @@ class InMemoryFileDB {
 
         this.stateTimer = null;
 
-        this.backupDir = this.settings.backup.path || (path.join(this.dataDir, this.settings.fileDB.backupDirName));
+        this.backupDir = this.settings.backup.path || path.join(this.dataDir, this.settings.fileDB.backupDirName);
 
         if (!this.settings.backup.disabled) {
             this.initBackupDir();
@@ -117,32 +116,55 @@ class InMemoryFileDB {
         let ret = {};
         try {
             ret = await this.loadDatasetFile(datasetName);
+
+            // loading worked, make sure that "bak" File is not broken
+            try {
+                await fs.readJSON(`${datasetName}.bak`);
+            } catch (e) {
+                this.log.info(
+                    `${this.namespace} Rewrite bak file, because error on verify ${datasetName}.bak: ${e.message}`
+                );
+                try {
+                    const jsonString = JSON.stringify(ret);
+                    await fs.writeFile(`${datasetName}.bak`, jsonString);
+                } catch (e) {
+                    this.log.error(`${this.namespace} Cannot save ${datasetName}.bak: ${e.message}`);
+                }
+            }
         } catch (err) {
             this.log.error(`${this.namespace} Cannot load ${datasetName}: ${err.message}. We try last Backup!`);
 
             try {
-                ret = await this.loadDatasetFile(datasetName + '.bak');
+                ret = await this.loadDatasetFile(`${datasetName}.bak`);
 
                 // it worked, lets overwrite old file and store the broken one for pot. forensic check
                 try {
                     if (await fs.pathExists(datasetName)) {
                         try {
-                            await fs.move(datasetName, `${datasetName}.broken`, {overwrite: true});
+                            await fs.move(datasetName, `${datasetName}.broken`, { overwrite: true });
                         } catch (e) {
-                            this.log.error(`${this.namespace} Cannot copy the broken file ${datasetName} to ${datasetName}.broken ${e.message}`);
+                            this.log.error(
+                                `${this.namespace} Cannot copy the broken file ${datasetName} to ${datasetName}.broken ${e.message}`
+                            );
                         }
                         try {
                             await fs.writeFile(datasetName, JSON.stringify(ret));
                         } catch (e) {
-                            this.log.error(`${this.namespace} Cannot restore backup file as new main ${datasetName}: ${e.message}`);
+                            this.log.error(
+                                `${this.namespace} Cannot restore backup file as new main ${datasetName}: ${e.message}`
+                            );
                         }
                     }
                 } catch {
                     // ignore, file does not exist
                 }
             } catch (err) {
-                this.log.error(`${this.namespace} Cannot load ${datasetName}.bak: ${err.message}. Continue with empty dataset!`);
-                this.log.error(`${this.namespace} If this is no Migration or initial start please restore the last backup from ${this.backupDir}`);
+                this.log.error(
+                    `${this.namespace} Cannot load ${datasetName}.bak: ${err.message}. Continue with empty dataset!`
+                );
+                this.log.error(
+                    `${this.namespace} If this is no Migration or initial start please restore the last backup from ${this.backupDir}`
+                );
             }
         }
         return ret;
@@ -151,18 +173,21 @@ class InMemoryFileDB {
     initBackupDir() {
         this.zlib = this.zlib || require('zlib');
         // Interval in minutes => to milliseconds
-        this.settings.backup.period = this.settings.backup.period === undefined ? 120 : parseInt(this.settings.backup.period);
+        this.settings.backup.period =
+            this.settings.backup.period === undefined ? 120 : parseInt(this.settings.backup.period);
         if (isNaN(this.settings.backup.period)) {
             this.settings.backup.period = 120;
         }
         this.settings.backup.period *= 60000;
 
-        this.settings.backup.files = this.settings.backup.files === undefined ? 24 : parseInt(this.settings.backup.files);
+        this.settings.backup.files =
+            this.settings.backup.files === undefined ? 24 : parseInt(this.settings.backup.files);
         if (isNaN(this.settings.backup.files)) {
             this.settings.backup.files = 24;
         }
 
-        this.settings.backup.hours = this.settings.backup.hours === undefined ? 48 : parseInt(this.settings.backup.hours);
+        this.settings.backup.hours =
+            this.settings.backup.hours === undefined ? 48 : parseInt(this.settings.backup.hours);
         if (isNaN(this.settings.backup.hours)) {
             this.settings.backup.hours = 48;
         }
@@ -186,11 +211,11 @@ class InMemoryFileDB {
                     return;
                 }
 
-                s.push({pattern: pattern, regex: new RegExp(tools.pattern2RegEx(pattern)), options: options});
+                s.push({ pattern: pattern, regex: new RegExp(tools.pattern2RegEx(pattern)), options: options });
             });
         } else {
             if (!s.find(sub => sub.pattern === pattern)) {
-                s.push({pattern: pattern, regex: new RegExp(tools.pattern2RegEx(pattern)), options: options});
+                s.push({ pattern: pattern, regex: new RegExp(tools.pattern2RegEx(pattern)), options: options });
             }
         }
         typeof cb === 'function' && cb();
@@ -226,13 +251,13 @@ class InMemoryFileDB {
         throw new Error('no communication handling implemented');
     }
 
-    deleteOldBackupFiles() {
+    deleteOldBackupFiles(baseFilename) {
         // delete files only if settings.backupNumber is not 0
         let files = fs.readdirSync(this.backupDir);
         files.sort();
         const limit = Date.now() - this.settings.backup.hours * 3600000;
 
-        files = files.filter(f => f.endsWith(this.settings.fileDB.fileName + '.gz'));
+        files = files.filter(f => f.endsWith(baseFilename + '.gz'));
 
         while (files.length > this.settings.backup.files) {
             const file = files.shift();
@@ -245,7 +270,9 @@ class InMemoryFileDB {
                 try {
                     fs.unlinkSync(path.join(this.backupDir, file));
                 } catch (e) {
-                    this.log.error(`${this.namespace} Cannot delete file "${path.join(this.backupDir, file)}: ${e.message}`);
+                    this.log.error(
+                        `${this.namespace} Cannot delete file "${path.join(this.backupDir, file)}: ${e.message}`
+                    );
                 }
             }
         }
@@ -319,7 +346,7 @@ class InMemoryFileDB {
         try {
             if (await fs.pathExists(this.datasetName)) {
                 try {
-                    await fs.move(this.datasetName, `${this.datasetName}.bak`, {overwrite: true});
+                    await fs.move(this.datasetName, `${this.datasetName}.bak`, { overwrite: true });
                 } catch (e) {
                     bakOk = false;
                     this.log.error(`${this.namespace} Cannot backup file ${this.datasetName}.bak: ${e.message}`);
@@ -333,19 +360,21 @@ class InMemoryFileDB {
         }
 
         try {
-            await fs.move(`${this.datasetName}.new`, this.datasetName, {overwrite: true});
+            await fs.move(`${this.datasetName}.new`, this.datasetName, { overwrite: true });
         } catch (e) {
-            this.log.error(`${this.namespace} Cannot move ${this.datasetName}.new to ${this.datasetName}: ${e.message}. Try direct write as fallback`);
+            this.log.error(
+                `${this.namespace} Cannot move ${this.datasetName}.new to ${this.datasetName}: ${e.message}. Try direct write as fallback`
+            );
             try {
                 await fs.writeFile(this.datasetName, jsonString);
             } catch (e) {
                 this.log.error(`${this.namespace} Cannot directly write Dataset to ${this.datasetName}: ${e.message}`);
                 return jsonString;
             }
-
         }
 
-        if (!bakOk) { // it seems the bak File is not successfully there, write current content again
+        if (!bakOk) {
+            // it seems the bak File is not successfully there, write current content again
             try {
                 await fs.writeFile(`${this.datasetName}.bak`, jsonString);
             } catch (e) {
@@ -368,7 +397,10 @@ class InMemoryFileDB {
         // makes backups only if settings.backupInterval is not 0
         if (this.settings.backup.period && (!this.lastSave || now - this.lastSave > this.settings.backup.period)) {
             this.lastSave = now;
-            const backFileName = path.join(this.backupDir, this.getTimeStr(now) + '_' + this.settings.fileDB.fileName + '.gz');
+            const backFileName = path.join(
+                this.backupDir,
+                this.getTimeStr(now) + '_' + this.settings.fileDB.fileName + '.gz'
+            );
 
             try {
                 if (!fs.existsSync(backFileName)) {
@@ -386,7 +418,7 @@ class InMemoryFileDB {
                     compress.end();
 
                     // analyse older files
-                    this.deleteOldBackupFiles();
+                    this.deleteOldBackupFiles(this.settings.fileDB.fileName);
                 }
             } catch (e) {
                 this.log.error(`${this.namespace} Cannot save backup ${backFileName}: ${e.message}`);
@@ -395,7 +427,7 @@ class InMemoryFileDB {
     }
 
     getStatus() {
-        return {type: 'file', server: true};
+        return { type: 'file', server: true };
     }
 
     /** @returns {object} */
@@ -419,11 +451,14 @@ class InMemoryFileDB {
         }
 
         // local subscriptions
-        if (this.change && this.callbackSubscriptionClient._subscribe && this.callbackSubscriptionClient._subscribe[type]) {
+        if (
+            this.change &&
+            this.callbackSubscriptionClient._subscribe &&
+            this.callbackSubscriptionClient._subscribe[type]
+        ) {
             for (let j = 0; j < this.callbackSubscriptionClient._subscribe[type].length; j++) {
                 if (this.callbackSubscriptionClient._subscribe[type][j].regex.test(id)) {
-                    setImmediate(() =>
-                        this.change(id, obj));
+                    setImmediate(() => this.change(id, obj));
                     break;
                 }
             }

package/lib/redisHandler.js

@@ -1,5 +1,6 @@
 const Resp = require('respjs');
 const { EventEmitter } = require('events');
+const { QUEUED_STR_BUF, OK_STR_BUF } = require('./constants');
 
 /**
  * Class to handle a redis connection and provide events to react on for
@@ -23,10 +24,11 @@ class RedisHandler extends EventEmitter {
         }
         this.socket = socket;
 
-        this.socketId = this.logScope + socket.remoteAddress + ':' + socket.remotePort;
+        this.socketId = `${this.logScope + socket.remoteAddress}:${socket.remotePort}`;
         this.initialized = false;
         this.stop = false;
 
+        this.activeMultiCalls = [];
         this.writeQueue = [];
 
         this.handleBuffers = false;
@@ -40,7 +42,7 @@ class RedisHandler extends EventEmitter {
         this.resp.on('error', err => {
             this.log.error(`${this.socketId} (Init=${this.initialized}) Redis error:${err}`);
             if (this.initialized) {
-                this.sendError(null,new Error('PARSER ERROR ' + err)); // TODO
+                this.sendError(null, new Error(`PARSER ERROR ${err}`)); // TODO
             } else {
                 this.close();
             }
@@ -50,7 +52,16 @@ class RedisHandler extends EventEmitter {
 
         socket.on('data', data => {
             if (this.options.enhancedLogging) {
-                this.log.silly(`${this.socketId} New Redis request: ${(data.length > 1024) ? data.toString().replace(/[\r\n]+/g, '').substring(0, 100) + ' -- ' + data.length + ' bytes' : data.toString().replace(/[\r\n]+/g, '')}`);
+                this.log.silly(
+                    `${this.socketId} New Redis request: ${
+                        data.length > 1024
+                            ? `${data
+                                  .toString()
+                                  .replace(/[\r\n]+/g, '')
+                                  .substring(0, 100)} -- ${data.length} bytes`
+                            : data.toString().replace(/[\r\n]+/g, '')
+                    }`
+                );
             }
             this.resp.write(data);
         });
@@ -87,19 +98,53 @@ class RedisHandler extends EventEmitter {
                 }
             }
         }
-        if (command === 'info') {
-            this.initialized = true;
-        }
+
         const t = process.hrtime();
-        const responseId = (t[0] * 1e3) + (t[1] / 1e6);
+        const responseId = t[0] * 1e3 + t[1] / 1e6;
+
         if (this.options.enhancedLogging) {
-            this.log.silly(`${this.socketId} Parser result: id=${responseId}, command=${command}, data=${(JSON.stringify(data).length > 1024) ? JSON.stringify(data).substring(0, 100) + ' -- ' + JSON.stringify(data).length + ' bytes' : JSON.stringify(data)}`);
+            this.log.silly(
+                `${this.socketId} Parser result: id=${responseId}, command=${command}, data=${
+                    JSON.stringify(data).length > 1024
+                        ? `${JSON.stringify(data).substring(0, 100)} -- ${JSON.stringify(data).length} bytes`
+                        : JSON.stringify(data)
+                }`
+            );
+        }
+
+        if (command === 'multi') {
+            if (this.activeMultiCalls.length && !this.activeMultiCalls[0].execCalled) {
+                // should never happen
+                this.log.warn(`${this.socketId} Conflicting multi call`);
+            }
+            this._handleMulti();
+            return;
+        }
+
+        // multi active and exec not called yet
+        if (this.activeMultiCalls.length && !this.activeMultiCalls[0].execCalled && command !== 'exec') {
+            // store all response ids so we know which need to be in the multi call
+            this.activeMultiCalls[0].responseIds.push(responseId);
+            // add it for the correct order will be overwritten with correct response
+            this.activeMultiCalls[0].responseMap.set(responseId, null);
+        } else {
+            // multi response ids should not be pushed - we will answer combined
+            this.writeQueue.push({ id: responseId, data: false });
         }
-        this.writeQueue.push({id: responseId, data: false});
+
+        if (command === 'exec') {
+            this._handleExec(responseId);
+            return;
+        }
+
+        if (command === 'info') {
+            this.initialized = true;
+        }
+
         if (this.listenerCount(command) !== 0) {
             setImmediate(() => this.emit(command, data, responseId));
         } else {
-            this.sendError(responseId, new Error(command + ' NOT SUPPORTED'));
+            this.sendError(responseId, new Error(`${command} NOT SUPPORTED`));
         }
     }
 
@@ -112,6 +157,7 @@ class RedisHandler extends EventEmitter {
      */
     _sendQueued(responseId, data) {
         let idx = 0;
+
         while (this.writeQueue.length && idx < this.writeQueue.length) {
             // we found the queue entry that matches with the responseId, so store the data so be sent out
             if (this.writeQueue[idx].id === responseId) {
@@ -127,8 +173,15 @@ class RedisHandler extends EventEmitter {
             if (idx === 0 && this.writeQueue[idx].data !== false) {
                 const response = this.writeQueue.shift();
                 if (this.options.enhancedLogging) {
-                    this.log.silly(`${this.socketId} Redis response (${response.id}): ${(response.data.length > 1024) ? data.length + ' bytes' : response.data.toString().replace(/[\r\n]+/g, '')}`);
+                    this.log.silly(
+                        `${this.socketId} Redis response (${response.id}): ${
+                            response.data.length > 1024
+                                ? `${data.length} bytes`
+                                : response.data.toString().replace(/[\r\n]+/g, '')
+                        }`
+                    );
                 }
+
                 this._write(response.data);
                 // We sended out first queue entry but no further response is ready
                 // and we do not need to check the whole queue, so we are done here
@@ -175,8 +228,9 @@ class RedisHandler extends EventEmitter {
         }
         if (!data) {
             this.log.warn(`${this.socketId} Not able to write ${JSON.stringify(data)}`);
-            data = Resp.encodeError(new Error('INVALID RESPONSE: ' + JSON.stringify(data)));
+            data = Resp.encodeError(new Error(`INVALID RESPONSE: ${JSON.stringify(data)}`));
         }
+
         setImmediate(() => this._sendQueued(responseId, data));
     }
 
@@ -202,6 +256,13 @@ class RedisHandler extends EventEmitter {
      * @param responseId ID of the response
      */
     sendNull(responseId) {
+        for (const i in this.activeMultiCalls) {
+            if (this.activeMultiCalls[i].responseIds.includes(responseId)) {
+                this._handleMultiResponse(responseId, i, Resp.encodeNull());
+                return;
+            }
+        }
+
         this.sendResponse(responseId, Resp.encodeNull());
     }
 
@@ -210,6 +271,13 @@ class RedisHandler extends EventEmitter {
      * @param responseId ID of the response
      */
     sendNullArray(responseId) {
+        for (const i in this.activeMultiCalls) {
+            if (this.activeMultiCalls[i].responseIds.includes(responseId)) {
+                this._handleMultiResponse(responseId, i, Resp.encodeNullArray());
+                return;
+            }
+        }
+
         this.sendResponse(responseId, Resp.encodeNullArray());
     }
 
@@ -219,6 +287,13 @@ class RedisHandler extends EventEmitter {
      * @param str String to encode
      */
     sendString(responseId, str) {
+        for (const i in this.activeMultiCalls) {
+            if (this.activeMultiCalls[i].responseIds.includes(responseId)) {
+                this._handleMultiResponse(responseId, i, Resp.encodeString(str));
+                return;
+            }
+        }
+
         this.sendResponse(responseId, Resp.encodeString(str));
     }
 
@@ -229,6 +304,14 @@ class RedisHandler extends EventEmitter {
      */
     sendError(responseId, error) {
         this.log.warn(`${this.socketId} Error from InMemDB: ${error}`);
+
+        for (const i in this.activeMultiCalls) {
+            if (this.activeMultiCalls[i].responseIds.includes(responseId)) {
+                this._handleMultiResponse(responseId, i, Resp.encodeError(error));
+                return;
+            }
+        }
+
         this.sendResponse(responseId, Resp.encodeError(error));
     }
 
@@ -238,6 +321,13 @@ class RedisHandler extends EventEmitter {
      * @param num Integer to send out
      */
     sendInteger(responseId, num) {
+        for (const i in this.activeMultiCalls) {
+            if (this.activeMultiCalls[i].responseIds.includes(responseId)) {
+                this._handleMultiResponse(responseId, i, Resp.encodeInteger(num));
+                return;
+            }
+        }
+
         this.sendResponse(responseId, Resp.encodeInteger(num));
     }
 
@@ -247,6 +337,13 @@ class RedisHandler extends EventEmitter {
      * @param str String to send out
      */
     sendBulk(responseId, str) {
+        for (const i in this.activeMultiCalls) {
+            if (this.activeMultiCalls[i].responseIds.includes(responseId)) {
+                this._handleMultiResponse(responseId, i, Resp.encodeBulk(str));
+                return;
+            }
+        }
+
         this.sendResponse(responseId, Resp.encodeBulk(str));
     }
 
@@ -256,6 +353,13 @@ class RedisHandler extends EventEmitter {
      * @param buf Buffer to send out
      */
     sendBufBulk(responseId, buf) {
+        for (const i in this.activeMultiCalls) {
+            if (this.activeMultiCalls[i].responseIds.includes(responseId)) {
+                this._handleMultiResponse(responseId, i, Resp.encodeBufBulk(buf));
+                return;
+            }
+        }
+
         this.sendResponse(responseId, Resp.encodeBufBulk(buf));
     }
 
@@ -283,12 +387,83 @@ class RedisHandler extends EventEmitter {
 
     /**
      * Encode a array values to buffers and send out
-     * @param responseId ID of the response
-     * @param arr Array to send out
+     * @param {number} responseId ID of the response
+     * @param {any[]} arr Array to send out
      */
     sendArray(responseId, arr) {
+        for (const i in this.activeMultiCalls) {
+            if (this.activeMultiCalls[i].responseIds.includes(responseId)) {
+                this._handleMultiResponse(responseId, i, Resp.encodeArray(this.encodeRespArray(arr)));
+                return;
+            }
+        }
+
         this.sendResponse(responseId, Resp.encodeArray(this.encodeRespArray(arr)));
     }
+
+    /**
+     * Handles a 'multi' command
+     *
+     * @private
+     */
+    _handleMulti() {
+        this.activeMultiCalls.unshift({
+            responseIds: [],
+            execCalled: false,
+            responseCount: 0,
+            responseMap: new Map()
+        });
+    }
+
+    /**
+     * Handles an 'exec' command
+     *
+     * @param {number} responseId ID of the response
+     * @private
+     */
+    _handleExec(responseId) {
+        this.activeMultiCalls[0].execId = responseId;
+        this.activeMultiCalls[0].execCalled = true;
+
+        // maybe we have all fullfilled yet
+        if (this.activeMultiCalls[0].responseCount === this.activeMultiCalls[0].responseIds.length) {
+            const multiRespObj = this.activeMultiCalls.shift();
+            this._sendExecResponse(multiRespObj);
+        }
+    }
+
+    /**
+     * Builds up the exec response and sends it
+     * @param {Record<string, any>} multiObj the multi object to send out
+     *
+     * @private
+     */
+    _sendExecResponse(multiObj) {
+        // collect all 'QUEUED' answers
+        const queuedStrArr = new Array(multiObj.responseCount).fill(QUEUED_STR_BUF);
+
+        this._sendQueued(
+            multiObj.execId,
+            Buffer.concat([OK_STR_BUF, ...queuedStrArr, Resp.encodeArray(Array.from(multiObj.responseMap.values()))])
+        );
+    }
+
+    /**
+     * Handles a multi response
+     *
+     * @param {number} responseId ID of the response
+     * @param {number} index index of the multi call
+     * @param {Buffer} buf buffer to include in response
+     * @private
+     */
+    _handleMultiResponse(responseId, index, buf) {
+        this.activeMultiCalls[index].responseMap.set(responseId, buf);
+        this.activeMultiCalls[index].responseCount++;
+        if (this.activeMultiCalls[index].responseCount === this.activeMultiCalls[index].responseIds.length) {
+            const multiRespObj = this.activeMultiCalls.splice(index, 1)[0];
+            this._sendExecResponse(multiRespObj);
+        }
+    }
 }
 
 module.exports = RedisHandler;

package/lib/tools.js

@@ -18,4 +18,4 @@ module.exports.maybeCallbackWithRedisError = (callback, error, ...args) => {
         error.message = module.exports.ERRORS.ERROR_DB_CLOSED;
     }
     return module.exports.maybeCallbackWithError(callback, error, ...args);
-};
+};

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@iobroker/db-base",
-  "version": "4.0.0-alpha.8-20210909-001a711c",
+  "version": "4.0.3",
   "engines": {
     "node": ">=12.0.0"
   },
   "dependencies": {
-    "@iobroker/js-controller-common": "4.0.0-alpha.8-20210909-001a711c",
+    "@iobroker/js-controller-common": "4.0.3",
     "deep-clone": "^3.0.3",
     "fs-extra": "^10.0.0",
-    "node.extend": "^2.0.2",
     "respjs": "^4.2.0"
   },
   "keywords": [
@@ -36,5 +35,5 @@
     "lib/",
     "index.js"
   ],
-  "gitHead": "4c022b8b6845fdd4792fc0003dbfc740fef4a942"
+  "gitHead": "79a76a082db91399d0e432ef02bf2981a6739107"
 }