dbgate-api-premium 5.5.7-alpha.45

package/src/controllers/storage.js

@@ -0,0 +1,380 @@
+const fs = require('fs-extra');
+const _ = require('lodash');
+const { setAuthProviders, getAuthProviderById } = require('../auth/authProvider');
+const { createStorageAuthProvider } = require('../auth/storageAuthProvider');
+const {
+  getStorageConnection,
+  getDbConnectionParams,
+  storageSelectFmt,
+  storageReadUserRolePermissions,
+  loadSuperadminPermissions,
+  storageReadConfig,
+  storageWriteConfig,
+  getStorageConnectionError,
+} = require('./storageDb');
+const { hasPermission } = require('../utility/hasPermission');
+const { changeSetToSql, removeSchemaFromChangeSet } = require('dbgate-datalib');
+const storageModel = require('../storageModel');
+const { dumpSqlCommand } = require('dbgate-sqltree');
+const { runCommandOnDriver } = require('dbgate-tools');
+const socket = require('../utility/socket');
+
+function mapConnection(connnection) {
+  return {
+    ...connnection,
+    _id: connnection.conid,
+  };
+}
+
+async function runQueryFmt(driver, conn, query, ...args) {
+  const dmp = driver.createDumper();
+  dmp.put(query, ...args);
+  await driver.query(conn, dmp.s);
+}
+
+module.exports = {
+  async _init() {
+    if (!process.env.STORAGE_DATABASE) {
+      return;
+    }
+    const authConfigs = await this.readAuthConfig();
+    const enabledConfig = authConfigs.filter(x => !x.isDisabled);
+    const providers = enabledConfig.map(cfg => createStorageAuthProvider(cfg));
+    let defIndex = enabledConfig.findIndex(x => x.isDefault);
+    if (defIndex < 0) {
+      defIndex = enabledConfig.findIndex(x => x.type == 'local');
+    }
+
+    setAuthProviders(providers, providers[defIndex]);
+  },
+
+  connections_meta: true,
+  async connections(req) {
+    if (!process.env.STORAGE_DATABASE) {
+      return null;
+    }
+
+    const userId = req?.user?.userId;
+    const roleId = req?.user?.roleId;
+
+    let resp = null;
+
+    if (hasPermission('all-connections', req)) {
+      resp = await storageSelectFmt(`select ~connections.* from ~connections`);
+    } else if (userId) {
+      resp = await storageSelectFmt(
+        `select ~connections.* from ~connections
+        where exists (
+          select * from ~user_connections where ~user_connections.~connection_id = ~connections.~id and ~user_connections.~user_id = %v
+        ) or exists (
+          select * from ~role_connections
+            inner join ~user_roles on ~role_connections.~role_id = ~user_roles.~role_id
+           where ~role_connections.~connection_id = ~connections.~id and ~user_roles.~user_id = %v
+        ) or exists (
+          select * from ~role_connections
+           where ~role_connections.~connection_id = ~connections.~id and ~role_connections.~role_id = -2
+        )
+        `,
+        userId,
+        userId
+      );
+    } else {
+      resp = await storageSelectFmt(
+        `select distinct ~connections.* from ~connections
+        inner join ~role_connections on ~connections.~id = ~role_connections.~connection_id
+        where ~role_connections.~role_id = %v`,
+        roleId ?? -1
+      );
+    }
+
+    if (!resp) {
+      return [];
+    }
+    const res = [];
+    if (hasPermission('internal-storage', req)) {
+      res.push(await this.getConnection({ conid: '__storage' }));
+    }
+    if (resp) {
+      res.push(...resp.map(x => mapConnection(x)));
+    }
+    return res;
+  },
+
+  async getConnection({ conid }) {
+    if (conid == '__storage') {
+      return {
+        _id: '__storage',
+        displayName: 'Internal storage',
+        defaultDatabase: process.env.STORAGE_DATABASE,
+        singleDatabase: true,
+        ...getDbConnectionParams(),
+      };
+    }
+
+    const [conn, driver] = await getStorageConnection();
+    if (!conn) {
+      return null;
+    }
+
+    const resp = await storageSelectFmt('select * from ~connections where ~conid = %v', conid);
+    return mapConnection(resp[0]);
+  },
+
+  readConfig_meta: true,
+  async readConfig({ group }) {
+    return await storageReadConfig(group);
+  },
+
+  readAuthConfig_meta: true,
+  async readAuthConfig() {
+    const authMethodsResp = await storageSelectFmt('select * from ~auth_methods');
+    const authMethodsConfig = await storageSelectFmt('select * from ~auth_methods_config');
+    const authMethods = authMethodsResp.map(x => {
+      const config = _.fromPairs(authMethodsConfig.filter(y => y.auth_method_id == x.id).map(y => [y.key, y.value]));
+      return {
+        ...config,
+        name: x.name,
+        type: x.type,
+        amoid: x.amoid,
+        isDisabled: x.is_disabled,
+        isDefault: x.is_default,
+        isCollapsed: x.is_collapsed,
+        id: x.id,
+      };
+    });
+    return authMethods;
+  },
+
+  writeAuthConfig_meta: true,
+  async writeAuthConfig({ authMethods }) {
+    const [conn, driver] = await getStorageConnection();
+    if (!conn) {
+      return null;
+    }
+
+    await runQueryFmt(driver, conn, 'delete from auth_methods_config');
+    await runQueryFmt(driver, conn, 'delete from auth_methods where id > 0');
+
+    let id = 1;
+    for (const method of authMethods) {
+      if (method.id < 0) {
+        await runQueryFmt(
+          driver,
+          conn,
+          'update auth_methods set is_disabled=%v, is_default = %v, is_collapsed = %v where id = %v',
+          method.isDisabled,
+          method.isDefault,
+          method.isCollapsed,
+          method.id
+        );
+      } else {
+        await runQueryFmt(
+          driver,
+          conn,
+          'insert into auth_methods (%i, %i, %i, %i, %i, %i, %i) values (%v, %v, %v, %v, %v, %v, %v)',
+          'id',
+          'name',
+          'type',
+          'is_disabled',
+          'is_default',
+          'is_collapsed',
+          'amoid',
+          id,
+          method.name,
+          method.type,
+          method.isDisabled ? 1 : 0,
+          method.isDefault ? 1 : 0,
+          method.isCollapsed ? 1 : 0,
+          method.amoid
+        );
+      }
+
+      for (const key in method) {
+        if (['id', 'name', 'type', 'isDisabled', 'isDefault', 'isCollapsed', 'amoid'].includes(key)) {
+          continue;
+        }
+        await runQueryFmt(
+          driver,
+          conn,
+          'insert into auth_methods_config (%i, %i, %i) values (%v, %v, %v)',
+          'auth_method_id',
+          'key',
+          'value',
+          method.id < 0 ? method.id : id,
+          key,
+          method[key]
+        );
+      }
+
+      if (!(method.id < 0)) {
+        id += 1;
+      }
+    }
+
+    await this._init();
+
+    return true;
+  },
+
+  writeConfig_meta: true,
+  async writeConfig({ group, config }) {
+    await storageWriteConfig(group, config);
+    await this._init();
+    return null;
+  },
+
+  readPermissions_meta: true,
+  async readPermissions({ tableName, filterColumn, filterValue }) {
+    const resp = Array.isArray(filterValue)
+      ? await storageSelectFmt('select * from %i where %i in (%,v)', tableName, filterColumn, filterValue)
+      : await storageSelectFmt('select * from %i where %i = %v', tableName, filterColumn, filterValue);
+    if (!resp) {
+      return null;
+    }
+    return resp.map(x => x.permission);
+  },
+
+  writePermissions_meta: true,
+  async writePermissions({ tableName, filterColumn, filterValue, permissions }) {
+    const [conn, driver] = await getStorageConnection();
+    if (!conn) {
+      return null;
+    }
+
+    await runQueryFmt(driver, conn, 'delete from %i where %i = %v', tableName, filterColumn, filterValue);
+
+    for (const perm of permissions) {
+      await runQueryFmt(
+        driver,
+        conn,
+        'insert into %i (%i, %i) values (%v, %v)',
+        tableName,
+        filterColumn,
+        'permission',
+        filterValue,
+        perm
+      );
+    }
+
+    return null;
+  },
+
+  readUserRolePermissions_meta: true,
+  async readUserRolePermissions({ userId }) {
+    return storageReadUserRolePermissions(userId);
+  },
+
+  async loadSuperadminPermissions() {
+    return loadSuperadminPermissions();
+  },
+
+  getConnectionsForLoginPage_meta: true,
+  getConnectionsForLoginPage({ amoid }) {
+    return getAuthProviderById(amoid).getLoginPageConnections();
+  },
+
+  saveAdminData_meta: true,
+  async saveAdminData({ changeSet, fireEvents }) {
+    const [conn, driver] = await getStorageConnection();
+    if (!conn) {
+      return null;
+    }
+
+    try {
+      runCommandOnDriver(conn, driver, dmp => dmp.beginTransaction());
+      const script = changeSetToSql(
+        // storage model is without schema
+        removeSchemaFromChangeSet(changeSet),
+        // @ts-ignore
+        storageModel
+      );
+      for (const item of script) {
+        await runCommandOnDriver(conn, driver, dmp => dumpSqlCommand(dmp, item));
+      }
+      await runCommandOnDriver(conn, driver, dmp => dmp.commitTransaction());
+    } catch (err) {
+      await runCommandOnDriver(conn, driver, dmp => dmp.rollbackTransaction());
+      return {
+        errorMessage: err.message,
+      };
+    }
+
+    if (fireEvents) {
+      for (const event of fireEvents ?? []) {
+        socket.emit(event);
+      }
+    }
+
+    return { status: 'ok' };
+  },
+
+  setAdminPassword_meta: true,
+  async setAdminPassword({ denyUseAdminPassword, oldPassword, newPassword, repeatPassword }) {
+    const [conn, driver] = await getStorageConnection();
+    if (!conn) {
+      return { status: 'error', errorMessage: 'Storage connection error' };
+    }
+
+    if (denyUseAdminPassword) {
+      await runQueryFmt(
+        driver,
+        conn,
+        "delete from ~config where ~group = 'admin' and ~key in ('adminPassword', 'adminPasswordState')"
+      );
+      await runQueryFmt(
+        driver,
+        conn,
+        "insert into ~config (~group, ~key, ~value) values ('admin', 'adminPasswordState', 'no')"
+      );
+
+      return { status: 'ok' };
+    }
+
+    const adminConfig = await storageReadConfig('admin');
+    if (adminConfig?.adminPasswordState == 'set') {
+      if (adminConfig.adminPassword != oldPassword) {
+        return {
+          status: 'error',
+          errorMessage: 'Invalid password - please check current password field',
+        };
+      }
+    }
+
+    if (newPassword != repeatPassword) {
+      return {
+        status: 'error',
+        errorMessage: 'Passwords do not match',
+      };
+    }
+
+    if (newPassword.length < 4) {
+      return {
+        status: 'error',
+        errorMessage: 'Password is too short, minimum length is 4 characters',
+      };
+    }
+
+    await runQueryFmt(
+      driver,
+      conn,
+      "delete from ~config where ~group = 'admin' and ~key in ('adminPassword', 'adminPasswordState')"
+    );
+    await runQueryFmt(
+      driver,
+      conn,
+      "insert into ~config (~group, ~key, ~value) values ('admin', 'adminPasswordState', 'set')"
+    );
+    await runQueryFmt(
+      driver,
+      conn,
+      "insert into ~config (~group, ~key, ~value) values ('admin', 'adminPassword', %v)",
+      newPassword
+    );
+
+    return { status: 'ok' };
+  },
+
+  getStorageConnectionError() {
+    return getStorageConnectionError();
+  },
+};

package/src/controllers/storageDb.js

@@ -0,0 +1,215 @@
+const requireEngineDriver = require('../utility/requireEngineDriver');
+const storageModel = require('../storageModel');
+const dbgateApi = require('../shell');
+const { getPredefinedPermissions, getLogger, extractErrorLogData } = require('dbgate-tools');
+const _ = require('lodash');
+const logger = getLogger('storageDb');
+
+function getDbConnectionParams() {
+  const server = process.env.STORAGE_SERVER;
+  const port = process.env.STORAGE_PORT;
+  const user = process.env.STORAGE_USER;
+  const password = process.env.STORAGE_PASSWORD;
+  const database = process.env.STORAGE_DATABASE;
+  const engine = process.env.STORAGE_ENGINE;
+  const serviceName = process.env.STORAGE_SERVICE_NAME;
+
+  if (!server || !user || !password || !database || !engine) {
+    if (database) {
+      if (!server) {
+        throw new Error('Incorrect storage configuration, missing env variable STORAGE_SERVER');
+      }
+      if (!port) {
+        throw new Error('Incorrect storage configuration, missing env variable STORAGE_PORT');
+      }
+      if (!user) {
+        throw new Error('Incorrect storage configuration, missing env variable STORAGE_USER');
+      }
+      if (!password) {
+        throw new Error('Incorrect storage configuration, missing env variable STORAGE_PASSWORD');
+      }
+      if (!engine) {
+        throw new Error('Incorrect storage configuration, missing env variable STORAGE_ENGINE');
+      }
+    }
+    return null;
+  }
+
+  return { server, port, user, password, database, engine, serviceName };
+}
+
+let storageConnection = null;
+let storageDriver = null;
+let storageConnectionError = null;
+
+async function getStorageConnectionCore() {
+  if (storageConnection) {
+    return [storageConnection, storageDriver];
+  }
+
+  const dbConnectionParams = getDbConnectionParams();
+
+  if (!dbConnectionParams) {
+    return [null, null];
+  }
+
+  storageDriver = requireEngineDriver(dbConnectionParams.engine);
+
+  let newConnection = null;
+  while (!newConnection) {
+    try {
+      newConnection = await storageDriver.connect(dbConnectionParams);
+      const version = await storageDriver.getVersion(newConnection);
+      logger.info(`Connected to storage database ${dbConnectionParams.engine}, version ${version?.versionText}`);
+      storageConnectionError = null;
+    } catch (err) {
+      storageConnectionError = err;
+      if (newConnection) {
+        try {
+          await storageDriver.close(newConnection);
+        } catch (err) {}
+        newConnection = null;
+      }
+      logger.error(extractErrorLogData(err), 'Error connecting to storage database, retrying in 5 seconds');
+      // sleep 5 seconds
+      await new Promise(resolve => setTimeout(resolve, 5000));
+    }
+  }
+
+  // @ts-ignore
+  await dbgateApi.deployDb({
+    systemConnection: newConnection,
+    driver: storageDriver,
+    loadedDbModel: storageModel,
+  });
+
+  storageConnection = newConnection;
+  return [storageConnection, storageDriver];
+}
+
+let gettingStorageConnectionPromise = null;
+
+function getStorageConnection() {
+  // const timeoutPromise = new Promise((resolve, reject) => {
+  //   setTimeout(() => reject(new Error(storageConnectionError?.message ?? 'Storage connection timeout')), 1000);
+  // });
+
+  if (gettingStorageConnectionPromise) {
+    // return Promise.race([gettingStorageConnectionPromise, timeoutPromise]);
+    return gettingStorageConnectionPromise;
+  }
+  gettingStorageConnectionPromise = getStorageConnectionCore();
+  gettingStorageConnectionPromise
+    .then(() => {
+      gettingStorageConnectionPromise = null;
+    })
+    .catch(err => {
+      logger.error(extractErrorLogData(err), 'Error connecting to storage database');
+      gettingStorageConnectionPromise = null;
+    });
+
+  // return Promise.race([gettingStorageConnectionPromise, timeoutPromise]);
+  return gettingStorageConnectionPromise;
+}
+
+async function storageSelectFmt(sql, ...params) {
+  const [conn, driver] = await getStorageConnection();
+  if (!conn) {
+    return null;
+  }
+
+  const dmp = driver.createDumper();
+  dmp.put(sql, ...params);
+  const resp = await storageDriver.query(storageConnection, dmp.s);
+  return resp.rows;
+}
+
+async function storageReadUserRolePermissions(userId) {
+  const resp = await storageSelectFmt(
+    `
+      select * 
+        from ~role_permissions 
+        inner join ~user_roles on ~role_permissions.~role_id = ~user_roles.~role_id 
+        where ~user_roles.~user_id = %v`,
+    userId
+  );
+  if (!resp) {
+    return [];
+  }
+  return resp.map(x => x.permission);
+}
+
+async function storageReadUserPermissions(userId) {
+  const resp = await storageSelectFmt(
+    `
+      select * 
+        from ~user_permissions 
+        where ~user_permissions.~user_id = %v`,
+    userId
+  );
+  if (!resp) {
+    return [];
+  }
+  return resp.map(x => x.permission);
+}
+
+async function storageReadRolePermissions(roleId) {
+  const resp = await storageSelectFmt(
+    `
+      select * 
+        from ~role_permissions 
+        where ~role_permissions.~role_id = %v`,
+    roleId
+  );
+  if (!resp) {
+    return [];
+  }
+  return resp.map(x => x.permission);
+}
+
+async function loadSuperadminPermissions() {
+  const rolePermissions = await storageReadRolePermissions(-3);
+  return [...getPredefinedPermissions('superadmin'), ...rolePermissions];
+}
+
+async function storageReadConfig(group) {
+  const resp = await storageSelectFmt('select * from ~config where ~group = %v', group);
+  if (!resp) {
+    return null;
+  }
+  return _.fromPairs(resp.map(x => [x.key, x.value]));
+}
+
+async function storageWriteConfig(group, config) {
+  const [conn, driver] = await getStorageConnection();
+  if (!conn) {
+    return null;
+  }
+
+  const dmp = driver.createDumper();
+  dmp.put('delete from ~config where ~group = %v', group);
+  await driver.query(conn, dmp.s);
+
+  for (const key in config) {
+    const dmp = driver.createDumper();
+    dmp.put('insert into config (~group, ~key, ~value) values (%v, %v, %v)', group, key, config[key]);
+    await driver.query(conn, dmp.s);
+  }
+}
+
+function getStorageConnectionError() {
+  return storageConnectionError;
+}
+
+module.exports = {
+  getStorageConnection,
+  storageSelectFmt,
+  getDbConnectionParams,
+  storageReadUserRolePermissions,
+  storageReadUserPermissions,
+  storageReadRolePermissions,
+  loadSuperadminPermissions,
+  storageReadConfig,
+  storageWriteConfig,
+  getStorageConnectionError,
+};