@iobroker/db-objects-redis 7.2.3 → 8.0.0-alpha.1-20260921-e5941ca8a

package/build/cjs/lib/objects/objectsUtils.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -32,19 +33,22 @@ __export(objectsUtils_exports, {
   ERRORS: () => ERRORS,
   REG_CHECK_ID: () => REG_CHECK_ID,
   checkFile: () => checkFile,
-  checkFileRights: () => checkFileRights,
+  checkFileRightsAsync: () => checkFileRightsAsync,
   checkObject: () => checkObject,
   checkObjectRights: () => checkObjectRights,
+  checkObjectRightsAsync: () => checkObjectRightsAsync,
   getMimeType: () => getMimeType,
   getUserGroup: () => getUserGroup,
+  getUserGroupAsync: () => getUserGroupAsync,
   sanitizePath: () => sanitizePath
 });
 module.exports = __toCommonJS(objectsUtils_exports);
 var import_node_path = __toESM(require("node:path"), 1);
 var import_deep_clone = __toESM(require("deep-clone"), 1);
+var import_mime_types = __toESM(require("mime-types"), 1);
 var import_db_base = require("@iobroker/db-base");
 var CONSTS = __toESM(require("../../lib/objects/constants.js"), 1);
-var import_mime_types = __toESM(require("mime-types"), 1);
+var import_constants = require("../../lib/objects/constants.js");
 var CONSTS2 = __toESM(require("../../lib/objects/constants.js"), 1);
 const ERRORS = CONSTS.ERRORS;
 const REG_CHECK_ID = CONSTS.REG_CHECK_ID;
@@ -61,6 +65,7 @@ function getKnownMimeType(ext) {
   }
   return null;
 }
+__name(getKnownMimeType, "getKnownMimeType");
 const defaultAcl = {
   groups: [],
   acl: {
@@ -107,23 +112,21 @@ function getMimeType(ext, isTextData) {
   }
   return { mimeType: isTextData ? "text/plain" : "application/octet-stream", isBinary: !isTextData };
 }
-function checkFile(fileOptions, options, flag, defaultNewAcl) {
-  if (typeof fileOptions.acl !== "object") {
-    fileOptions = {};
-    fileOptions.mimeType = (0, import_deep_clone.default)(fileOptions);
-    fileOptions.acl = {
-      owner: defaultNewAcl && defaultNewAcl.owner || CONSTS.SYSTEM_ADMIN_USER,
-      ownerGroup: defaultNewAcl && defaultNewAcl.ownerGroup || CONSTS.SYSTEM_ADMIN_GROUP,
-      permissions: defaultNewAcl && defaultNewAcl.file || CONSTS.ACCESS_USER_RW | CONSTS.ACCESS_GROUP_READ | CONSTS.ACCESS_EVERY_READ
-      // '0644'
-    };
-  }
-  fileOptions.acl.ownerGroup = fileOptions.acl.ownerGroup || defaultNewAcl && defaultNewAcl.ownerGroup || CONSTS.SYSTEM_ADMIN_GROUP;
-  fileOptions.acl.owner = fileOptions.acl.owner || defaultNewAcl && defaultNewAcl.owner || CONSTS.SYSTEM_ADMIN_USER;
-  fileOptions.acl.permissions = fileOptions.acl.permissions || defaultNewAcl && defaultNewAcl.file || CONSTS.ACCESS_USER_RW | CONSTS.ACCESS_GROUP_READ | CONSTS.ACCESS_EVERY_READ;
-  if (options.user !== CONSTS.SYSTEM_ADMIN_USER && options.groups.indexOf(CONSTS.SYSTEM_ADMIN_GROUP) === -1 && fileOptions.acl) {
-    if (fileOptions.acl.owner !== options.user) {
-      if (options.groups.indexOf(fileOptions.acl.ownerGroup) !== -1) {
+__name(getMimeType, "getMimeType");
+function checkFile(fileOptions, userContext, flag, defaultNewAcl) {
+  fileOptions ||= {};
+  fileOptions.acl ||= {
+    owner: defaultNewAcl?.owner || CONSTS.SYSTEM_ADMIN_USER,
+    ownerGroup: defaultNewAcl?.ownerGroup || CONSTS.SYSTEM_ADMIN_GROUP,
+    permissions: defaultNewAcl?.file || CONSTS.ACCESS_USER_RW | CONSTS.ACCESS_GROUP_READ | CONSTS.ACCESS_EVERY_READ
+    // '0644'
+  };
+  fileOptions.acl.owner ||= defaultNewAcl?.owner || CONSTS.SYSTEM_ADMIN_USER;
+  fileOptions.acl.ownerGroup ||= defaultNewAcl?.ownerGroup || CONSTS.SYSTEM_ADMIN_GROUP;
+  fileOptions.acl.permissions ||= defaultNewAcl?.file || CONSTS.ACCESS_USER_RW | CONSTS.ACCESS_GROUP_READ | CONSTS.ACCESS_EVERY_READ;
+  if (userContext.user !== CONSTS.SYSTEM_ADMIN_USER && !userContext.groups.includes(CONSTS.SYSTEM_ADMIN_GROUP) && fileOptions.acl) {
+    if (fileOptions.acl.owner !== userContext.user) {
+      if (userContext.groups.includes(fileOptions.acl.ownerGroup)) {
         if (!(fileOptions.acl.permissions & flag << 4)) {
           return false;
         }
@@ -140,36 +143,39 @@ function checkFile(fileOptions, options, flag, defaultNewAcl) {
   }
   return true;
 }
-function checkFileRights(objects, id, name, options, flag, callback) {
-  const _options = options || {};
-  if (!_options.user) {
-    _options.user = "system.user.admin";
-    _options.params = _options;
-    _options.group = "system.group.administrator";
-  }
-  if (!_options.acl) {
-    objects.getUserGroup(_options.user, (_user, groups2, acl) => {
-      _options.acl = acl || {};
-      _options.groups = groups2;
-      _options.group = groups2 ? groups2[0] : null;
-      checkFileRights(objects, id, name, _options, flag, callback);
-    });
-    return;
-  }
-  if (flag === CONSTS.ACCESS_WRITE && !_options.acl.file.write) {
-    return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, _options);
-  }
-  if (flag === CONSTS.ACCESS_READ && !_options.acl.file.read) {
-    return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, _options);
-  }
-  _options.checked = true;
-  objects.checkFile(id, name, _options, flag, (err, options2, opt) => {
-    if (err) {
-      return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options2);
-    }
-    return import_db_base.tools.maybeCallbackWithError(callback, null, options2, opt);
-  });
+__name(checkFile, "checkFile");
+async function checkFileRightsAsync(objects, id, name, options, flag) {
+  let userContext;
+  if (!options?.user) {
+    userContext = {
+      user: import_constants.SYSTEM_ADMIN_USER,
+      group: import_constants.SYSTEM_ADMIN_GROUP,
+      groups: [import_constants.SYSTEM_ADMIN_GROUP],
+      acl: getDefaultAdminRights()
+    };
+  } else {
+    const [, groups2, acl] = await getUserGroupAsync(objects, options.user);
+    userContext = {
+      user: options.user,
+      group: groups2?.[0] || null,
+      groups: groups2,
+      acl
+    };
+  }
+  if (flag === CONSTS.ACCESS_WRITE && !userContext.acl.file.write) {
+    throw new Error(ERRORS.ERROR_PERMISSION);
+  }
+  if (flag === CONSTS.ACCESS_READ && !userContext.acl.file.read) {
+    throw new Error(ERRORS.ERROR_PERMISSION);
+  }
+  userContext.checked = true;
+  const fileOptions = await objects.checkFileAsync(id, name, userContext, flag);
+  if (!fileOptions) {
+    throw new Error(ERRORS.ERROR_PERMISSION);
+  }
+  return { fileOptions, userContext };
 }
+__name(checkFileRightsAsync, "checkFileRightsAsync");
 function getDefaultAdminRights(acl, _isState) {
   return {
     ...acl,
@@ -208,129 +214,131 @@ function getDefaultAdminRights(acl, _isState) {
     }
   };
 }
+__name(getDefaultAdminRights, "getDefaultAdminRights");
 function getUserGroup(objects, user, callback) {
+  try {
+    getUserGroupAsync(objects, user).then((result) => import_db_base.tools.maybeCallbackWithError(callback, null, result[0], result[1], result[2])).catch((err) => import_db_base.tools.maybeCallbackWithError(callback, err, (0, import_deep_clone.default)(user), [], (0, import_deep_clone.default)(defaultAcl.acl)));
+  } catch (err) {
+    return import_db_base.tools.maybeCallbackWithError(callback, err, (0, import_deep_clone.default)(user), [], (0, import_deep_clone.default)(defaultAcl.acl));
+  }
+}
+__name(getUserGroup, "getUserGroup");
+async function getUserGroupAsync(objects, user) {
   if (!user || typeof user !== "string" || !user.startsWith(USER_STARTS_WITH)) {
     console.log(`invalid user name: ${user}`);
-    return import_db_base.tools.maybeCallbackWithError(callback, `invalid user name: ${user}`, (0, import_deep_clone.default)(user), [], (0, import_deep_clone.default)(defaultAcl.acl));
+    throw new Error(`invalid user name: ${user}`);
   }
   if (users[user]) {
-    return import_db_base.tools.maybeCallbackWithError(callback, null, user, users[user].groups, users[user].acl);
+    return [user, users[user].groups, users[user].acl];
   }
   let error;
-  objects.getObjectList({ startkey: "system.group.", endkey: "system.group.\u9999" }, { checked: true }, (err, arr) => {
-    if (err) {
-      error = err;
-    }
-    groups = [];
-    if (arr) {
-      for (const g in arr.rows) {
-        const val = arr.rows[g].value;
-        if (!val) {
-          continue;
-        }
-        groups[g] = val;
-        if (groups[g]._id === CONSTS.SYSTEM_ADMIN_GROUP) {
-          groups[g].common.acl = getDefaultAdminRights(groups[g].common.acl);
-        }
+  groups = [];
+  const groupList = await objects.getObjectListAsync({ startkey: "system.group.", endkey: "system.group.\u9999" }, { checked: true });
+  if (groupList) {
+    for (let g = 0; g < groupList.rows.length; g++) {
+      const val = groupList.rows[g].value;
+      if (!val) {
+        continue;
+      }
+      groups[g] = val;
+      if (groups[g]._id === CONSTS.SYSTEM_ADMIN_GROUP) {
+        groups[g].common.acl = getDefaultAdminRights(groups[g].common.acl);
       }
     }
-    objects.getObjectList({ startkey: "system.user.", endkey: "system.user.\u9999" }, { checked: true }, (err2, arr2) => {
-      if (err2) {
-        error = err2;
+  }
+  users = {};
+  const userList = await objects.getObjectListAsync({ startkey: "system.user.", endkey: "system.user.\u9999" }, { checked: true });
+  if (userList) {
+    for (const row of userList.rows) {
+      users[row.value._id] = (0, import_deep_clone.default)(defaultAcl);
+    }
+  }
+  users[CONSTS.SYSTEM_ADMIN_USER] ||= (0, import_deep_clone.default)(defaultAcl);
+  users[CONSTS.SYSTEM_ADMIN_USER].acl = getDefaultAdminRights(users[CONSTS.SYSTEM_ADMIN_USER].acl);
+  for (let g = 0; g < groups.length; g++) {
+    if (!groups[g]?.common?.members) {
+      continue;
+    }
+    for (let m = 0; m < groups[g].common.members.length; m++) {
+      const u = groups[g].common.members[m];
+      if (!users[u]) {
+        error ||= `Unknown user in group "${groups[g]._id.replace("system.group.", "")}": ${u}`;
+        continue;
+      }
+      users[u].groups.push(groups[g]._id);
+      if (groups[g].common.acl?.file) {
+        if (!users[u].acl?.file) {
+          users[u].acl ||= {};
+          users[u].acl.file ||= {};
+          users[u].acl.file.create = groups[g].common.acl.file.create;
+          users[u].acl.file.read = groups[g].common.acl.file.read;
+          users[u].acl.file.write = groups[g].common.acl.file.write;
+          users[u].acl.file.delete = groups[g].common.acl.file.delete;
+          users[u].acl.file.list = groups[g].common.acl.file.list;
+        } else {
+          users[u].acl.file.create ||= groups[g].common.acl.file.create;
+          users[u].acl.file.read ||= groups[g].common.acl.file.read;
+          users[u].acl.file.write ||= groups[g].common.acl.file.write;
+          users[u].acl.file.delete ||= groups[g].common.acl.file.delete;
+          users[u].acl.file.list ||= groups[g].common.acl.file.list;
+        }
       }
-      users = {};
-      if (arr2) {
-        for (const row of arr2.rows) {
-          users[row.value._id] = (0, import_deep_clone.default)(defaultAcl);
+      if (groups[g].common.acl?.object) {
+        if (!users[u].acl?.object) {
+          users[u].acl ||= {};
+          users[u].acl.object ||= {};
+          users[u].acl.object.create = groups[g].common.acl.object.create;
+          users[u].acl.object.read = groups[g].common.acl.object.read;
+          users[u].acl.object.write = groups[g].common.acl.object.write;
+          users[u].acl.object.delete = groups[g].common.acl.object.delete;
+          users[u].acl.object.list = groups[g].common.acl.object.list;
+        } else {
+          users[u].acl.object.create ||= groups[g].common.acl.object.create;
+          users[u].acl.object.read ||= groups[g].common.acl.object.read;
+          users[u].acl.object.write ||= groups[g].common.acl.object.write;
+          users[u].acl.object.delete ||= groups[g].common.acl.object.delete;
+          users[u].acl.object.list ||= groups[g].common.acl.object.list;
         }
       }
-      users[CONSTS.SYSTEM_ADMIN_USER] = users[CONSTS.SYSTEM_ADMIN_USER] || (0, import_deep_clone.default)(defaultAcl);
-      users[CONSTS.SYSTEM_ADMIN_USER].acl = getDefaultAdminRights(users[CONSTS.SYSTEM_ADMIN_USER].acl);
-      for (let g = 0; g < groups.length; g++) {
-        if (!groups[g] || !groups[g].common || !groups[g].common.members) {
-          continue;
+      if (groups[g].common.acl?.users) {
+        if (!users[u].acl?.users) {
+          users[u].acl ||= {};
+          users[u].acl.users ||= {};
+          users[u].acl.users.create = groups[g].common.acl.users.create;
+          users[u].acl.users.read = groups[g].common.acl.users.read;
+          users[u].acl.users.write = groups[g].common.acl.users.write;
+          users[u].acl.users.delete = groups[g].common.acl.users.delete;
+          users[u].acl.users.list = groups[g].common.acl.users.list;
+        } else {
+          users[u].acl.users.create ||= groups[g].common.acl.users.create;
+          users[u].acl.users.read ||= groups[g].common.acl.users.read;
+          users[u].acl.users.write ||= groups[g].common.acl.users.write;
+          users[u].acl.users.delete ||= groups[g].common.acl.users.delete;
+          users[u].acl.users.list ||= groups[g].common.acl.users.list;
         }
-        for (let m = 0; m < groups[g].common.members.length; m++) {
-          const u = groups[g].common.members[m];
-          if (!users[u]) {
-            error = error || `Unknown user in group "${groups[g]._id.replace("system.group.", "")}": ${u}`;
-            continue;
-          }
-          users[u].groups.push(groups[g]._id);
-          if (groups[g].common.acl && groups[g].common.acl.file) {
-            if (!users[u].acl || !users[u].acl.file) {
-              users[u].acl = users[u].acl || {};
-              users[u].acl.file = users[u].acl.file || {};
-              users[u].acl.file.create = groups[g].common.acl.file.create;
-              users[u].acl.file.read = groups[g].common.acl.file.read;
-              users[u].acl.file.write = groups[g].common.acl.file.write;
-              users[u].acl.file.delete = groups[g].common.acl.file.delete;
-              users[u].acl.file.list = groups[g].common.acl.file.list;
-            } else {
-              users[u].acl.file.create = users[u].acl.file.create || groups[g].common.acl.file.create;
-              users[u].acl.file.read = users[u].acl.file.read || groups[g].common.acl.file.read;
-              users[u].acl.file.write = users[u].acl.file.write || groups[g].common.acl.file.write;
-              users[u].acl.file.delete = users[u].acl.file.delete || groups[g].common.acl.file.delete;
-              users[u].acl.file.list = users[u].acl.file.list || groups[g].common.acl.file.list;
-            }
-          }
-          if (groups[g].common.acl && groups[g].common.acl.object) {
-            if (!users[u].acl || !users[u].acl.object) {
-              users[u].acl = users[u].acl || {};
-              users[u].acl.object = users[u].acl.object || {};
-              users[u].acl.object.create = groups[g].common.acl.object.create;
-              users[u].acl.object.read = groups[g].common.acl.object.read;
-              users[u].acl.object.write = groups[g].common.acl.object.write;
-              users[u].acl.object.delete = groups[g].common.acl.object.delete;
-              users[u].acl.object.list = groups[g].common.acl.object.list;
-            } else {
-              users[u].acl.object.create = users[u].acl.object.create || groups[g].common.acl.object.create;
-              users[u].acl.object.read = users[u].acl.object.read || groups[g].common.acl.object.read;
-              users[u].acl.object.write = users[u].acl.object.write || groups[g].common.acl.object.write;
-              users[u].acl.object.delete = users[u].acl.object.delete || groups[g].common.acl.object.delete;
-              users[u].acl.object.list = users[u].acl.object.list || groups[g].common.acl.object.list;
-            }
-          }
-          if (groups[g].common.acl && groups[g].common.acl.users) {
-            if (!users[u].acl || !users[u].acl.users) {
-              users[u].acl = users[u].acl || {};
-              users[u].acl.users = users[u].acl.users || {};
-              users[u].acl.users.create = groups[g].common.acl.users.create;
-              users[u].acl.users.read = groups[g].common.acl.users.read;
-              users[u].acl.users.write = groups[g].common.acl.users.write;
-              users[u].acl.users.delete = groups[g].common.acl.users.delete;
-              users[u].acl.users.list = groups[g].common.acl.users.list;
-            } else {
-              users[u].acl.users.create = users[u].acl.users.create || groups[g].common.acl.users.create;
-              users[u].acl.users.read = users[u].acl.users.read || groups[g].common.acl.users.read;
-              users[u].acl.users.write = users[u].acl.users.write || groups[g].common.acl.users.write;
-              users[u].acl.users.delete = users[u].acl.users.delete || groups[g].common.acl.users.delete;
-              users[u].acl.users.list = users[u].acl.users.list || groups[g].common.acl.users.list;
-            }
-          }
-          if (groups[g].common.acl && groups[g].common.acl.state) {
-            if (!users[u].acl || !users[u].acl.state) {
-              users[u].acl = users[u].acl || {};
-              users[u].acl.state = users[u].acl.state || {};
-              users[u].acl.state.create = groups[g].common.acl.state?.create;
-              users[u].acl.state.read = groups[g].common.acl.state?.read;
-              users[u].acl.state.write = groups[g].common.acl.state?.write;
-              users[u].acl.state.delete = groups[g].common.acl.state?.delete;
-              users[u].acl.state.list = groups[g].common.acl.state?.list;
-            } else {
-              users[u].acl.state.create = users[u].acl.state.create || groups[g].common.acl.state?.create;
-              users[u].acl.state.read = users[u].acl.state.read || groups[g].common.acl.state?.read;
-              users[u].acl.state.write = users[u].acl.state.write || groups[g].common.acl.state?.write;
-              users[u].acl.state.delete = users[u].acl.state.delete || groups[g].common.acl.state?.delete;
-              users[u].acl.state.list = users[u].acl.state.list || groups[g].common.acl.state?.list;
-            }
-          }
+      }
+      if (groups[g].common.acl?.state) {
+        if (!users[u].acl?.state) {
+          users[u].acl ||= {};
+          users[u].acl.state ||= {};
+          users[u].acl.state.create = groups[g].common.acl.state.create;
+          users[u].acl.state.read = groups[g].common.acl.state.read;
+          users[u].acl.state.write = groups[g].common.acl.state.write;
+          users[u].acl.state.delete = groups[g].common.acl.state.delete;
+          users[u].acl.state.list = groups[g].common.acl.state.list;
+        } else {
+          users[u].acl.state.create ||= groups[g].common.acl.state.create;
+          users[u].acl.state.read ||= groups[g].common.acl.state.read;
+          users[u].acl.state.write ||= groups[g].common.acl.state.write;
+          users[u].acl.state.delete ||= groups[g].common.acl.state.delete;
+          users[u].acl.state.list ||= groups[g].common.acl.state.list;
         }
       }
-      return import_db_base.tools.maybeCallbackWithError(callback, error, user, users[user] ? users[user].groups : [], users[user] ? users[user].acl : (0, import_deep_clone.default)(defaultAcl.acl));
-    });
-  });
+    }
+  }
+  return [user, users[user]?.groups || [], users[user]?.acl || (0, import_deep_clone.default)(defaultAcl.acl)];
 }
+__name(getUserGroupAsync, "getUserGroupAsync");
 function sanitizePath(id, name) {
   if (!name) {
     name = "";
@@ -356,6 +364,7 @@ function sanitizePath(id, name) {
   }
   return { id, name };
 }
+__name(sanitizePath, "sanitizePath");
 function checkObject(obj, options, flag) {
   if (!obj || !("common" in obj) || !obj.acl || flag === CONSTS.ACCESS_LIST) {
     return true;
@@ -386,80 +395,91 @@ function checkObject(obj, options, flag) {
   }
   return true;
 }
+__name(checkObject, "checkObject");
 function checkObjectRights(objects, id, object, options, flag, callback) {
-  options = options || {};
-  if (!options.user) {
-    options = {
+  try {
+    checkObjectRightsAsync(objects, id, object, options, flag).then((userContext) => import_db_base.tools.maybeCallbackWithError(callback, null, userContext)).catch((error) => import_db_base.tools.maybeCallbackWithError(callback, error));
+  } catch (error) {
+    import_db_base.tools.maybeCallbackWithError(callback, error);
+  }
+}
+__name(checkObjectRights, "checkObjectRights");
+async function checkObjectRightsAsync(objects, id, object, options, flag) {
+  let userContext;
+  options ||= {};
+  if (!options?.user) {
+    userContext = {
       user: CONSTS.SYSTEM_ADMIN_USER,
-      params: options,
       group: CONSTS.SYSTEM_ADMIN_GROUP,
       groups: [CONSTS.SYSTEM_ADMIN_GROUP],
       acl: getDefaultAdminRights()
     };
+  } else {
+    const [, groups2, acl] = await getUserGroupAsync(objects, options.user);
+    userContext = {
+      user: options.user,
+      groups: groups2,
+      acl: acl || {},
+      group: groups2?.[0] || null
+    };
   }
-  if (!options.acl) {
-    return objects.getUserGroup(options.user, (_user, groups2, acl) => {
-      options = options || {};
-      options.acl = acl || {};
-      options.groups = groups2;
-      options.group = groups2 ? groups2[0] : null;
-      checkObjectRights(objects, id, object, options, flag, callback);
-    });
-  }
-  if (options.user === CONSTS.SYSTEM_ADMIN_USER || options.group === CONSTS.SYSTEM_ADMIN_GROUP || options.groups && options.groups.includes(CONSTS.SYSTEM_ADMIN_GROUP)) {
-    return import_db_base.tools.maybeCallbackWithError(callback, null, options);
+  if (userContext.user === CONSTS.SYSTEM_ADMIN_USER || userContext.group === CONSTS.SYSTEM_ADMIN_GROUP || userContext.groups?.includes(CONSTS.SYSTEM_ADMIN_GROUP)) {
+    return userContext;
   }
   if (typeof id === "string" && (id.startsWith(USER_STARTS_WITH) || id.startsWith(GROUP_STARTS_WITH))) {
-    if (flag === CONSTS.ACCESS_WRITE && !options.acl.users.write) {
-      return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+    if (flag === CONSTS.ACCESS_WRITE && !userContext.acl.users.write) {
+      throw new Error(ERRORS.ERROR_PERMISSION);
     }
-    if (flag === CONSTS.ACCESS_READ && !options.acl.users.read) {
-      return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+    if (flag === CONSTS.ACCESS_READ && !userContext.acl.users.read) {
+      throw new Error(ERRORS.ERROR_PERMISSION);
     }
-    if (flag === CONSTS.ACCESS_DELETE && !options.acl.users.delete) {
-      return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+    if (flag === CONSTS.ACCESS_DELETE && !userContext.acl.users.delete) {
+      throw new Error(ERRORS.ERROR_PERMISSION);
     }
-    if (flag === CONSTS.ACCESS_LIST && !options.acl.users.list) {
-      return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+    if (flag === CONSTS.ACCESS_LIST && !userContext.acl.users.list) {
+      throw new Error(ERRORS.ERROR_PERMISSION);
     }
-    if (flag === CONSTS.ACCESS_CREATE && !options.acl.users.create) {
-      return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+    if (flag === CONSTS.ACCESS_CREATE && !userContext.acl.users.create) {
+      throw new Error(ERRORS.ERROR_PERMISSION);
     }
     if (flag === CONSTS.ACCESS_DELETE) {
       flag = CONSTS.ACCESS_WRITE;
     }
   }
-  if (flag === CONSTS.ACCESS_WRITE && !options.acl.object.write) {
-    import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+  if (flag === CONSTS.ACCESS_WRITE && !userContext.acl.object.write) {
+    throw new Error(ERRORS.ERROR_PERMISSION);
   }
-  if (flag === CONSTS.ACCESS_READ && !options.acl.object.read) {
-    return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+  if (flag === CONSTS.ACCESS_READ && !userContext.acl.object.read) {
+    throw new Error(ERRORS.ERROR_PERMISSION);
   }
-  if (flag === CONSTS.ACCESS_DELETE && !options.acl.object.delete) {
-    return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+  if (flag === CONSTS.ACCESS_DELETE && !userContext.acl.object.delete) {
+    throw new Error(ERRORS.ERROR_PERMISSION);
   }
-  if (flag === CONSTS.ACCESS_LIST && !options.acl.object.list) {
-    return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+  if (flag === CONSTS.ACCESS_LIST && !userContext.acl.object.list) {
+    throw new Error(ERRORS.ERROR_PERMISSION);
   }
   if (flag === CONSTS.ACCESS_DELETE) {
     flag = CONSTS.ACCESS_WRITE;
   }
-  if (id && !checkObject(object, options, flag)) {
-    return import_db_base.tools.maybeCallbackWithError(callback, ERRORS.ERROR_PERMISSION, options);
+  if (id && !checkObject(object, userContext, flag)) {
+    throw new Error(ERRORS.ERROR_PERMISSION);
   }
-  return import_db_base.tools.maybeCallbackWithError(callback, null, options);
+  return userContext;
 }
+__name(checkObjectRightsAsync, "checkObjectRightsAsync");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CONSTS,
   ERRORS,
   REG_CHECK_ID,
   checkFile,
-  checkFileRights,
+  checkFileRightsAsync,
   checkObject,
   checkObjectRights,
+  checkObjectRightsAsync,
   getMimeType,
   getUserGroup,
+  getUserGroupAsync,
   sanitizePath
 });
 //# sourceMappingURL=objectsUtils.js.map