introduced yarn workspace

packages/api/src/controllers/connections.js

@@ -0,0 +1,59 @@
+
+const path = require('path');
+const { fork } = require('child_process');
+const _ = require('lodash');
+const nedb = require('nedb-promises');
+
+const datadir = require('../utility/datadir');
+const socket = require('../utility/socket');
+
+module.exports = {
+  datastore: null,
+  opened: [],
+
+  async _init() {
+    const dir = await datadir();
+    // @ts-ignore
+    this.datastore = nedb.create(path.join(dir, 'connections.jsonl'));
+  },
+
+  list_meta: 'get',
+  async list() {
+    return this.datastore.find();
+  },
+
+  test_meta: {
+    method: 'post',
+    raw: true,
+  },
+  test(req, res) {
+    const subprocess = fork(`${__dirname}/../proc/connectProcess.js`);
+    subprocess.on('message', resp => res.json(resp));
+    subprocess.send(req.body);
+  },
+
+  save_meta: 'post',
+  async save(connection) {
+    let res;
+    if (connection._id) {
+      res = await this.datastore.update(_.pick(connection, '_id'), connection);
+    } else {
+      res = await this.datastore.insert(connection);
+    }
+    socket.emit('connection-list-changed');
+    return res;
+  },
+
+  delete_meta: 'post',
+  async delete(connection) {
+    const res = await this.datastore.remove(_.pick(connection, '_id'));
+    socket.emit('connection-list-changed');
+    return res;
+  },
+
+  get_meta: 'get',
+  async get({ conid }) {
+    const res = await this.datastore.find({ _id: conid });
+    return res[0];
+  },
+};

packages/api/src/controllers/databaseConnections.js

@@ -0,0 +1,69 @@
+const _ = require('lodash');
+const uuidv1 = require('uuid/v1');
+const connections = require('./connections');
+const socket = require('../utility/socket');
+const { fork } = require('child_process');
+const DatabaseAnalyser = require('@dbgate/engines/default/DatabaseAnalyser');
+
+module.exports = {
+  /** @type {import('dbgate').OpenedDatabaseConnection[]} */
+  opened: [],
+  requests: {},
+
+  handle_structure(conid, database, { structure }) {
+    const existing = this.opened.find(x => x.conid == conid && x.database == database);
+    if (!existing) return;
+    existing.structure = structure;
+    conid;
+    socket.emit(`database-structure-changed-${conid}-${database}`);
+  },
+  handle_error(conid, database, props) {
+    const { error } = props;
+    console.log(`Error in database connection ${conid}, database ${database}: ${error}`);
+  },
+  handle_response(conid, database, { msgid, ...response }) {
+    const [resolve, reject] = this.requests[msgid];
+    resolve(response);
+    delete this.requests[msgid];
+  },
+
+  async ensureOpened(conid, database) {
+    const existing = this.opened.find(x => x.conid == conid && x.database == database);
+    if (existing) return existing;
+    const connection = await connections.get({ conid });
+    const subprocess = fork(`${__dirname}/../proc/databaseConnectionProcess.js`);
+    const newOpened = {
+      conid,
+      database,
+      subprocess,
+      structure: DatabaseAnalyser.createEmptyStructure(),
+      connection,
+    };
+    this.opened.push(newOpened);
+    // @ts-ignore
+    subprocess.on('message', ({ msgtype, ...message }) => {
+      this[`handle_${msgtype}`](conid, database, message);
+    });
+    subprocess.send({ msgtype: 'connect', ...connection, database });
+    return newOpened;
+  },
+
+  /** @param {import('dbgate').OpenedDatabaseConnection} conn */
+  async sendRequest(conn, message) {
+    const msgid = uuidv1();
+    const promise = new Promise((resolve, reject) => {
+      this.requests[msgid] = [resolve, reject];
+      conn.subprocess.send({ msgid, ...message });
+    });
+    return promise;
+  },
+
+  listObjects_meta: 'get',
+  async listObjects({ conid, database }) {
+    const opened = await this.ensureOpened(conid, database);
+    const { tables } = opened.structure;
+    return {
+      tables: _.sortBy(tables, x => `${x.schemaName}.${x.pureName}`),
+    }; // .map(fp.pick(['tableName', 'schemaName']));
+  },
+};

packages/api/src/controllers/serverConnections.js

@@ -0,0 +1,44 @@
+
+const connections = require('./connections');
+const socket = require('../utility/socket');
+const { fork } = require('child_process');
+
+module.exports = {
+  opened: [],
+
+  handle_databases(conid, { databases }) {
+    const existing = this.opened.find(x => x.conid == conid);
+    if (!existing) return;
+    existing.databases = databases;
+    socket.emit(`database-list-changed-${conid}`);
+  },
+  handle_error(conid, { error }) {
+    console.log(`Error in server connection ${conid}: ${error}`);
+  },
+
+  async ensureOpened(conid) {
+    const existing = this.opened.find(x => x.conid == conid);
+    if (existing) return existing;
+    const connection = await connections.get({ conid });
+    const subprocess = fork(`${__dirname}/../proc/serverConnectionProcess.js`);
+    const newOpened = {
+      conid,
+      subprocess,
+      databases: [],
+      connection,
+    };
+    this.opened.push(newOpened);
+    // @ts-ignore
+    subprocess.on('message', ({ msgtype, ...message }) => {
+      this[`handle_${msgtype}`](conid, message);
+    });
+    subprocess.send({ msgtype: 'connect', ...connection });
+    return newOpened;
+  },
+
+  listDatabases_meta: 'get',
+  async listDatabases({ conid }) {
+    const opened = await this.ensureOpened(conid);
+    return opened.databases;
+  },
+};

packages/api/src/controllers/tables.js

@@ -0,0 +1,22 @@
+const _ = require('lodash');
+const databaseConnections = require('./databaseConnections');
+
+module.exports = {
+  tableData_meta: 'get',
+  async tableData({ conid, database, schemaName, pureName }) {
+    const opened = await databaseConnections.ensureOpened(conid, database);
+    const res = await databaseConnections.sendRequest(opened, { msgtype: 'tableData', schemaName, pureName });
+    return res;
+  },
+
+  tableInfo_meta: 'get',
+  async tableInfo({ conid, database, schemaName, pureName }) {
+    const opened = await databaseConnections.ensureOpened(conid, database);
+    const table = opened.structure.tables.find(x => x.pureName == pureName && x.schemaName == schemaName);
+    const allForeignKeys = _.flatten(opened.structure.tables.map(x => x.foreignKeys));
+    return {
+      ...table,
+      dependencies: allForeignKeys.filter(x => x.refSchemaName == schemaName && x.refTableName == pureName),
+    };
+  },
+};