dbgate-api-premium 6.8.2 → 7.0.0

package/src/controllers/teamFiles.js

@@ -15,6 +15,16 @@ const {
   storageUpdateTeamFileAdmin,
   storageDeleteFile,
   storageCopyFile,
+  storageListAllAdminFolders,
+  storageGetExistingFolder,
+  storageUpdateTeamFolderAdmin,
+  storageDeleteFolder,
+  storageInsertTeamFolderAdmin,
+  storageListAllTeamFolders,
+  storageListTeamFoldersForUser,
+  storageListTeamFoldersForRole,
+  storageGetTeamFolderRoleAccess,
+  storageGetTeamFolderUserAccess,
 } = require('./storageDb');
 const { getBuiltinRoleIdFromRequest } = require('../auth/storageAuthProvider');
 const socket = require('../utility/socket');
@@ -41,14 +51,16 @@ function deserialize(format, text) {
 
 module.exports = {
   createNew_meta: true,
-  async createNew({ fileType, file, data }, req) {
+  async createNew({ fileType, file, data, teamFolderId }, req) {
     const loadedPermissions = await loadPermissionsFromRequest(req);
     if (!hasPermission(`all-team-files/create`, loadedPermissions)) {
-      throw new Error('No permission to create team files');
+      if (!(await this.checkFolderCreateAccess(teamFolderId, req, false))) {
+        throw new Error('No permission to create team files');
+      }
     }
     const userId = req?.user?.userId;
     const metadata = extractFileMetadata(data, fileType);
-    const resp = await storageCreateTeamFile({ fileType, file, data, ownerUserId: userId, metadata });
+    const resp = await storageCreateTeamFile({ fileType, file, data, ownerUserId: userId, metadata, teamFolderId });
     socket.emitChanged('team-files-changed');
     return resp;
   },
@@ -57,7 +69,7 @@ module.exports = {
   async update({ teamFileId, data, name }, req) {
     const existingFile = await storageGetExistingFile(teamFileId);
     if (!existingFile) return false;
-    await this.checkWriteAccess(existingFile, req);
+    await this.checkFileWriteAccess(existingFile, req);
     const metadata = extractFileMetadata(data, existingFile.type_name);
     const resp = await storageUpdateTeamFile({ teamFileId, data, name, metadata });
     socket.emitChanged('team-files-changed');
@@ -93,12 +105,53 @@ module.exports = {
           allowRead: !!(item.allow_read || isOwner),
           allowWrite: !!(item.allow_write || isOwner),
           allowUse: !!(item.allow_use || isOwner),
+          teamFolderId: item.team_folder_id,
+          teamFolderName: item.team_folder_name,
+        };
+      }) || []
+    );
+  },
+
+  listFolders_meta: true,
+  async listFolders(_params, req) {
+    const loadedPermissions = await loadPermissionsFromRequest(req);
+    let res = [];
+    const createAll = hasPermission(`all-team-files/create`, loadedPermissions);
+    const readAll = hasPermission(`all-team-files/read`, loadedPermissions);
+    const writeAll = hasPermission(`all-team-files/write`, loadedPermissions);
+    const useAll = hasPermission(`all-team-files/use`, loadedPermissions);
+    if (readAll || writeAll || useAll || createAll) {
+      res = await storageListAllTeamFolders();
+      res = res?.map(item => ({
+        ...item,
+        allow_create: createAll,
+        allow_read: readAll,
+        allow_write: writeAll,
+        allow_use: useAll,
+      }));
+    } else {
+      const userId = req?.user?.userId;
+      if (userId) {
+        res = await storageListTeamFoldersForUser(userId);
+      } else {
+        res = await storageListTeamFoldersForRole(getBuiltinRoleIdFromRequest(req));
+      }
+    }
+    return (
+      res?.map(item => {
+        return {
+          teamFolderId: item.id,
+          folder: item.folder_name,
+          allowRead: !!item.allow_read,
+          allowWrite: !!item.allow_write,
+          allowUse: !!item.allow_use,
+          allowCreate: !!item.allow_create,
         };
       }) || []
     );
   },
 
-  async checkAccessCore(existingFile, req, throwError, accessType, accessField) {
+  async checkFileAccessCore(existingFile, req, throwError, accessType, accessField) {
     const userId = req?.user?.userId;
     const loadedPermissions = await loadPermissionsFromRequest(req);
 
@@ -110,15 +163,57 @@ module.exports = {
       return true;
     }
     const roleId = getBuiltinRoleIdFromRequest(req);
-    const roleAccess = await storageGetTeamFileRoleAccess(existingFile.id, roleId);
-    if (roleAccess[accessField]) {
+    const roleFileAccess = await storageGetTeamFileRoleAccess(existingFile.id, roleId);
+    const roleFolderAccess = await storageGetTeamFolderRoleAccess(existingFile.team_folder_id, roleId);
+    if (roleFileAccess[accessField] || roleFolderAccess[accessField]) {
       return true;
     }
     if (existingFile.owner_user_id == userId && userId) {
       return true;
     }
     if (existingFile.owner_user_id != userId && userId) {
-      const userAccess = await storageGetTeamFileUserAccess(existingFile.id, userId);
+      const userFileAccess = await storageGetTeamFileUserAccess(existingFile.id, userId);
+      const userFolderAccess = await storageGetTeamFolderUserAccess(existingFile.team_folder_id, userId);
+
+      if (userFileAccess[accessField] || userFolderAccess[accessField]) {
+        return true;
+      }
+    }
+
+    if (!throwError) return false;
+    throw new Error(`No permission to ${accessType} this team file`);
+  },
+
+  async checkFileReadAccess(existingFile, req, throwError = true) {
+    return await this.checkFileAccessCore(existingFile, req, throwError, 'read', 'allowRead');
+  },
+
+  async checkFileWriteAccess(existingFile, req, throwError = true) {
+    return await this.checkFileAccessCore(existingFile, req, throwError, 'write', 'allowWrite');
+  },
+
+  async checkFileUseAccess(existingFile, req, throwError = true) {
+    return await this.checkFileAccessCore(existingFile, req, throwError, 'use', 'allowUse');
+  },
+
+  async checkFolderAccessCore(existingFolderId, req, throwError, accessType, accessField) {
+    const userId = req?.user?.userId;
+    const loadedPermissions = await loadPermissionsFromRequest(req);
+
+    if (hasPermission(`admin/team-folders`, loadedPermissions)) {
+      return true;
+    }
+
+    if (hasPermission(`all-team-files/${accessType}`, loadedPermissions)) {
+      return true;
+    }
+    const roleId = getBuiltinRoleIdFromRequest(req);
+    const roleAccess = await storageGetTeamFolderRoleAccess(existingFolderId, roleId);
+    if (roleAccess[accessField]) {
+      return true;
+    }
+    if (userId) {
+      const userAccess = await storageGetTeamFolderUserAccess(existingFolderId, userId);
 
       if (userAccess[accessField]) {
         return true;
@@ -129,16 +224,20 @@ module.exports = {
     throw new Error(`No permission to ${accessType} this team file`);
   },
 
-  async checkReadAccess(existingFile, req, throwError = true) {
-    return await this.checkAccessCore(existingFile, req, throwError, 'read', 'allowRead');
+  async checkFolderReadAccess(existingFolderId, req, throwError = true) {
+    return await this.checkFolderAccessCore(existingFolderId, req, throwError, 'read', 'allowRead');
   },
 
-  async checkWriteAccess(existingFile, req, throwError = true) {
-    return await this.checkAccessCore(existingFile, req, throwError, 'write', 'allowWrite');
+  async checkFolderWriteAccess(existingFolderId, req, throwError = true) {
+    return await this.checkFolderAccessCore(existingFolderId, req, throwError, 'write', 'allowWrite');
   },
 
-  async checkUseAccess(existingFile, req, throwError = true) {
-    return await this.checkAccessCore(existingFile, req, throwError, 'use', 'allowUse');
+  async checkFolderCreateAccess(existingFolderId, req, throwError = true) {
+    return await this.checkFolderAccessCore(existingFolderId, req, throwError, 'create', 'allowWrite');
+  },
+
+  async checkFolderUseAccess(existingFolderId, req, throwError = true) {
+    return await this.checkFolderAccessCore(existingFolderId, req, throwError, 'use', 'allowUse');
   },
 
   getContent_meta: true,
@@ -150,7 +249,7 @@ module.exports = {
     if (existingFile.type_name == 'sql') {
       const frontMatter = getSqlFrontMatter(existingFile.file_content, yaml);
       if (frontMatter?.autoExecute) {
-        allowUse = await this.checkUseAccess(existingFile, req, false);
+        allowUse = await this.checkFileUseAccess(existingFile, req, false);
         if (allowUse) {
           const useToken = jwt.sign(
             {
@@ -168,7 +267,7 @@ module.exports = {
       }
     }
     if (!allowUse) {
-      await this.checkReadAccess(existingFile, req);
+      await this.checkFileReadAccess(existingFile, req);
     }
     return {
       content: deserialize(existingFile.type_format, actualContent),
@@ -181,7 +280,7 @@ module.exports = {
   async copy({ teamFileId, newName }, req) {
     const existingFile = await storageGetExistingFile(teamFileId);
     if (!existingFile) return false;
-    await this.checkReadAccess(existingFile, req);
+    await this.checkFileReadAccess(existingFile, req);
     const loadedPermissions = await loadPermissionsFromRequest(req);
     if (!hasPermission(`all-team-files/create`, loadedPermissions)) {
       throw new Error('No permission to create team files');
@@ -196,7 +295,7 @@ module.exports = {
   async exportFile({ teamFileId, filePath }, req) {
     const existingFile = await storageGetExistingFileWithContent(teamFileId);
     if (!existingFile) return false;
-    await this.checkReadAccess(existingFile, req);
+    await this.checkFileReadAccess(existingFile, req);
     await fs.writeFile(filePath, existingFile.file_content);
     return true;
   },
@@ -205,12 +304,65 @@ module.exports = {
   async delete({ teamFileId }, req) {
     const existingFile = await storageGetExistingFile(teamFileId);
     if (!existingFile) return false;
-    await this.checkWriteAccess(existingFile, req);
+    await this.checkFileWriteAccess(existingFile, req);
     const resp = await storageDeleteFile(teamFileId);
     socket.emitChanged('team-files-changed');
     return resp;
   },
 
+  listAdminFolders_meta: true,
+  async listAdminFolders({}, req) {
+    const loadedPermissions = await loadPermissionsFromRequest(req);
+    if (!hasPermission(`admin/team-folders`, loadedPermissions)) return [];
+    const res = await storageListAllAdminFolders();
+    return res.map(item => ({
+      id: item.id,
+      name: item.folder_name,
+      ownerLogin: item.owner_login,
+      ownerEmail: item.owner_email,
+      fileCount: item.file_count,
+    }));
+  },
+
+  getAdminFolder_meta: true,
+  async getAdminFolder({ id }, req) {
+    const loadedPermissions = await loadPermissionsFromRequest(req);
+    if (!hasPermission(`admin/team-folders`, loadedPermissions)) return false;
+    if (id == 'new') {
+      return { id: null, name: 'New team folder', ownerName: null };
+    }
+    const existingFolder = await storageGetExistingFolder(id);
+    if (!existingFolder) return false;
+    return {
+      id: existingFolder.id,
+      name: existingFolder.folder_name,
+      ownerName: existingFolder.owner_login,
+    };
+  },
+
+  setAdminFolder_meta: true,
+  async setAdminFolder({ id, name }, req) {
+    const loadedPermissions = await loadPermissionsFromRequest(req);
+    if (!hasPermission(`admin/team-folders`, loadedPermissions)) return false;
+    if (id) {
+      await storageUpdateTeamFolderAdmin({ teamFolderId: id, name });
+    } else {
+      await storageInsertTeamFolderAdmin({ name });
+    }
+    socket.emitChanged('team-folders-changed');
+    return true;
+  },
+
+  deleteAdminFolder_meta: true,
+  async deleteAdminFolder({ id }, req) {
+    const loadedPermissions = await loadPermissionsFromRequest(req);
+    if (!hasPermission(`admin/team-folders`, loadedPermissions)) return false;
+    if (id < 0 || !id) return false;
+    await storageDeleteFolder(id);
+    socket.emitChanged('team-folders-changed');
+    return true;
+  },
+
   listAdminFiles_meta: true,
   async listAdminFiles({}, req) {
     const loadedPermissions = await loadPermissionsFromRequest(req);
@@ -222,6 +374,7 @@ module.exports = {
       ownerLogin: item.owner_login,
       ownerEmail: item.owner_email,
       typeName: item.type_name,
+      folderName: item.folder_name,
     }));
   },
 

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '6.8.2',
-  buildTime: '2025-12-29T13:10:42.923Z'
+  version: '7.0.0',
+  buildTime: '2026-01-22T09:09:52.304Z'
 };

package/src/index.js

@@ -147,6 +147,7 @@ const shell = require('./shell/index');
 global.DBGATE_PACKAGES = {
   'dbgate-tools': require('dbgate-tools'),
   'dbgate-sqltree': require('dbgate-sqltree'),
+  'dbgate-datalib': require('dbgate-datalib'),
 };
 
 if (processArgs.startProcess) {

package/src/proc/databaseConnectionProcess.js

@@ -368,6 +368,107 @@ async function handleSaveTableData({ msgid, changeSet }) {
   }
 }
 
+async function handleMultiCallMethod({ msgid, callList }) {
+  try {
+    const driver = requireEngineDriver(storedConnection);
+    await driver.invokeMethodCallList(dbhan, callList);
+
+    // for (const change of changeSet.changes) {
+    //   if (change.type === 'string') {
+    //     await driver.query(dbhan, `SET "${change.key}" "${change.value}"`);
+    //   } else if (change.type === 'json') {
+    //     await driver.query(dbhan, `JSON.SET "${change.key}" $ '${change.value.replace(/'/g, "\\'")}'`);
+    //   } else if (change.type === 'hash') {
+    //     if (change.updates && Array.isArray(change.updates)) {
+    //       for (const update of change.updates) {
+    //         await driver.query(dbhan, `HSET "${change.key}" "${update.key}" "${update.value}"`);
+          
+    //         if (update.ttl !== undefined && update.ttl !== null && update.ttl !== -1) {
+    //           try {
+    //             await dbhan.client.call('HEXPIRE', change.key, update.ttl, 'FIELDS', 1, update.key);
+    //           } catch (e) {}
+    //         }
+    //       }
+    //     }
+    //     if (change.inserts && Array.isArray(change.inserts)) {
+    //       for (const insert of change.inserts) {
+    //         await driver.query(dbhan, `HSET "${change.key}" "${insert.key}" "${insert.value}"`);
+            
+    //         if (insert.ttl !== undefined && insert.ttl !== null && insert.ttl !== -1) {
+    //           try {
+    //             await dbhan.client.call('HEXPIRE', change.key, insert.ttl, 'FIELDS', 1, insert.key);
+    //           } catch (e) {}
+    //         }
+    //       }
+    //     }
+    //     if (change.deletes && Array.isArray(change.deletes)) {
+    //       for (const delKey of change.deletes) {
+    //         await driver.query(dbhan, `HDEL "${change.key}" "${delKey}"`);
+    //       }
+    //     }
+    //   } else if (change.type === 'zset') {
+    //     if (change.updates && Array.isArray(change.updates)) {
+    //       for (const update of change.updates) {
+    //         await driver.query(dbhan, `ZADD "${change.key}" ${update.score} "${update.member}"`);
+    //       }
+    //     }
+    //     if (change.inserts && Array.isArray(change.inserts)) {
+    //       for (const insert of change.inserts) {
+    //         await driver.query(dbhan, `ZADD "${change.key}" ${insert.score} "${insert.member}"`);
+    //       }
+    //     }
+    //     if (change.deletes && Array.isArray(change.deletes)) {
+    //       for (const delMember of change.deletes) {
+    //         await driver.query(dbhan, `ZREM "${change.key}" "${delMember}"`);
+    //       }
+    //     }
+    //   } else if (change.type === 'list') {
+    //     if (change.updates && Array.isArray(change.updates)) {
+    //       for (const update of change.updates) {
+    //         await driver.query(dbhan, `LSET "${change.key}" ${update.index} "${update.value}"`);
+    //       }
+    //     }
+    //     if (change.inserts && Array.isArray(change.inserts)) {
+    //       for (const insert of change.inserts) {
+    //         await driver.query(dbhan, `RPUSH "${change.key}" "${insert.value}"`);
+    //       }
+    //     }
+    //   } else if (change.type === 'set') {
+    //     if (change.inserts && Array.isArray(change.inserts)) {
+    //       for (const insert of change.inserts) {
+    //         await driver.query(dbhan, `SADD "${change.key}" "${insert.value}"`);
+    //       }
+    //     }
+    //     if (change.deletes && Array.isArray(change.deletes)) {
+    //       for (const delValue of change.deletes) {
+    //         await driver.query(dbhan, `SREM "${change.key}" "${delValue}"`);
+    //       }
+    //     }
+    //   } else if (change.type === 'stream') {
+    //     if (change.inserts && Array.isArray(change.inserts)) {
+    //       for (const insert of change.inserts) {
+    //         const streamId = insert.id === '*' || !insert.id ? '*' : insert.id;
+    //         await driver.query(dbhan, `XADD "${change.key}" ${streamId} value "${insert.value}"`);
+    //       }
+    //     }
+    //     if (change.deletes && Array.isArray(change.deletes)) {
+    //       for (const delId of change.deletes) {
+    //         await driver.query(dbhan, `XDEL "${change.key}" "${delId}"`);
+    //       }
+    //     }
+    //   }
+    // }
+
+    process.send({ msgtype: 'response', msgid });
+  } catch (err) {
+    process.send({
+      msgtype: 'response',
+      msgid,
+      errorMessage: extractErrorMessage(err, 'Error saving Redis data'),
+    });
+  }
+}
+
 async function handleSqlPreview({ msgid, objects, options }) {
   await waitStructure();
   const driver = requireEngineDriver(storedConnection);
@@ -501,6 +602,7 @@ const messageHandlers = {
   schemaList: handleSchemaList,
   executeSessionQuery: handleExecuteSessionQuery,
   evalJsonScript: handleEvalJsonScript,
+  multiCallMethod: handleMultiCallMethod,
   // runCommand: handleRunCommand,
 };
 

package/src/storageModel.js

@@ -1498,6 +1498,86 @@ module.exports = {
         ]
       }
     },
+    {
+      "pureName": "role_team_folders",
+      "columns": [
+        {
+          "pureName": "role_team_folders",
+          "columnName": "id",
+          "dataType": "int",
+          "autoIncrement": true,
+          "notNull": true
+        },
+        {
+          "pureName": "role_team_folders",
+          "columnName": "role_id",
+          "dataType": "int",
+          "notNull": true
+        },
+        {
+          "pureName": "role_team_folders",
+          "columnName": "team_folder_id",
+          "dataType": "int",
+          "notNull": true
+        },
+        {
+          "pureName": "role_team_folders",
+          "columnName": "allow_read_files",
+          "dataType": "int",
+          "notNull": false
+        },
+        {
+          "pureName": "role_team_folders",
+          "columnName": "allow_write_files",
+          "dataType": "int",
+          "notNull": false
+        },
+        {
+          "pureName": "role_team_folders",
+          "columnName": "allow_use_files",
+          "dataType": "int",
+          "notNull": false
+        }
+      ],
+      "foreignKeys": [
+        {
+          "constraintType": "foreignKey",
+          "constraintName": "FK_role_team_folders_role_id",
+          "pureName": "role_team_folders",
+          "refTableName": "roles",
+          "deleteAction": "CASCADE",
+          "columns": [
+            {
+              "columnName": "role_id",
+              "refColumnName": "id"
+            }
+          ]
+        },
+        {
+          "constraintType": "foreignKey",
+          "constraintName": "FK_role_team_folders_team_folder_id",
+          "pureName": "role_team_folders",
+          "refTableName": "team_folders",
+          "deleteAction": "CASCADE",
+          "columns": [
+            {
+              "columnName": "team_folder_id",
+              "refColumnName": "id"
+            }
+          ]
+        }
+      ],
+      "primaryKey": {
+        "pureName": "role_team_folders",
+        "constraintType": "primaryKey",
+        "constraintName": "PK_role_team_folders",
+        "columns": [
+          {
+            "columnName": "id"
+          }
+        ]
+      }
+    },
     {
       "pureName": "table_permission_roles",
       "columns": [
@@ -1655,6 +1735,14 @@ module.exports = {
           "columnName": "metadata",
           "dataType": "varchar(1000)",
           "notNull": false
+        },
+        {
+          "pureName": "team_files",
+          "columnName": "team_folder_id",
+          "dataType": "int",
+          "notNull": true,
+          "defaultValue": -1,
+          "defaultConstraint": "DF_team_files_team_folder_id"
         }
       ],
       "foreignKeys": [
@@ -1681,6 +1769,18 @@ module.exports = {
               "refColumnName": "id"
             }
           ]
+        },
+        {
+          "constraintType": "foreignKey",
+          "constraintName": "FK_team_files_team_folder_id",
+          "pureName": "team_files",
+          "refTableName": "team_folders",
+          "columns": [
+            {
+              "columnName": "team_folder_id",
+              "refColumnName": "id"
+            }
+          ]
         }
       ],
       "primaryKey": {
@@ -1765,6 +1865,41 @@ module.exports = {
         }
       ]
     },
+    {
+      "pureName": "team_folders",
+      "columns": [
+        {
+          "pureName": "team_folders",
+          "columnName": "id",
+          "dataType": "int",
+          "autoIncrement": true,
+          "notNull": true
+        },
+        {
+          "pureName": "team_folders",
+          "columnName": "folder_name",
+          "dataType": "varchar(250)",
+          "notNull": false
+        }
+      ],
+      "foreignKeys": [],
+      "primaryKey": {
+        "pureName": "team_folders",
+        "constraintType": "primaryKey",
+        "constraintName": "PK_team_folders",
+        "columns": [
+          {
+            "columnName": "id"
+          }
+        ]
+      },
+      "preloadedRows": [
+        {
+          "id": -1,
+          "folder_name": "default"
+        }
+      ]
+    },
     {
       "pureName": "users",
       "columns": [
@@ -2363,6 +2498,86 @@ module.exports = {
           }
         ]
       }
+    },
+    {
+      "pureName": "user_team_folders",
+      "columns": [
+        {
+          "pureName": "user_team_folders",
+          "columnName": "id",
+          "dataType": "int",
+          "autoIncrement": true,
+          "notNull": true
+        },
+        {
+          "pureName": "user_team_folders",
+          "columnName": "user_id",
+          "dataType": "int",
+          "notNull": true
+        },
+        {
+          "pureName": "user_team_folders",
+          "columnName": "team_folder_id",
+          "dataType": "int",
+          "notNull": true
+        },
+        {
+          "pureName": "user_team_folders",
+          "columnName": "allow_read_files",
+          "dataType": "int",
+          "notNull": false
+        },
+        {
+          "pureName": "user_team_folders",
+          "columnName": "allow_write_files",
+          "dataType": "int",
+          "notNull": false
+        },
+        {
+          "pureName": "user_team_folders",
+          "columnName": "allow_use_files",
+          "dataType": "int",
+          "notNull": false
+        }
+      ],
+      "foreignKeys": [
+        {
+          "constraintType": "foreignKey",
+          "constraintName": "FK_user_team_folders_user_id",
+          "pureName": "user_team_folders",
+          "refTableName": "users",
+          "deleteAction": "CASCADE",
+          "columns": [
+            {
+              "columnName": "user_id",
+              "refColumnName": "id"
+            }
+          ]
+        },
+        {
+          "constraintType": "foreignKey",
+          "constraintName": "FK_user_team_folders_team_folder_id",
+          "pureName": "user_team_folders",
+          "refTableName": "team_folders",
+          "deleteAction": "CASCADE",
+          "columns": [
+            {
+              "columnName": "team_folder_id",
+              "refColumnName": "id"
+            }
+          ]
+        }
+      ],
+      "primaryKey": {
+        "pureName": "user_team_folders",
+        "constraintType": "primaryKey",
+        "constraintName": "PK_user_team_folders",
+        "columns": [
+          {
+            "columnName": "id"
+          }
+        ]
+      }
     }
   ],
   "collections": [],