module.add(user,problem,record)

hydro/service/db.js

@@ -0,0 +1,18 @@
+const Mongo = require('mongodb');
+const options = require('../options');
+let mongourl = 'mongodb://';
+if (options.db.username) mongourl += options.db.username + ':' + options.db.password + '@';
+mongourl += `${options.db.host}:${options.db.port}/${options.db.name}`;
+/**
+ * @type {import('mongodb').Db}
+ */
+let db = null;
+Mongo.MongoClient.connect(mongourl, { useNewUrlParser: true, useUnifiedTopology: true })
+    .then(Database => {
+        db = Database.db(options.db.name);
+        global.bus.emit('connected');
+    });
+
+module.exports = {
+    collection: c => db.collection(c)
+};

hydro/service/queue.js

@@ -0,0 +1,53 @@
+const options = require('../options');
+if (options.mq) {
+    const amqplib = require('amqplib');
+    /**
+     * @type {import('amqplib').Connection}
+     */
+    let conn = null;
+    let ch = null;
+
+    module.exports = {
+        async connect() {
+            conn = await amqplib.connect(options.mq.url);
+            ch = conn.createChannel();
+        },
+        async assertQueue(queue) {
+            return await ch.assertQueue(queue);
+        },
+        async publish(queue, data) {
+            return await ch.sendToQueue(queue, Buffer.from(data));
+        },
+        async consume(queue, callback) {
+            ch.consume(queue, function (msg) {
+                if (msg !== null) {
+                    callback(msg.content.toString(), () => { ch.ack(msg); });
+                    ch.ack(msg);
+                }
+            });
+        }
+    };
+} else {
+    let q = {};
+    module.exports = {
+        async connect() { },
+        async assertQueue(queue) {
+            q[queue] = q[queue] || [];
+        },
+        async publish(queue, data) {
+            q[queue].push(data);
+        },
+        async consume(queue, callback) {
+            while (1) {
+                if (q[queue].length) {
+                    let data = q[queue][0];
+                    q[queue].splice(0, 1);
+                    callback(data, () => { });
+                }
+                await new Promise(resolve => {
+                    setTimeout(resolve, 500);
+                });
+            }
+        }
+    };
+}

hydro/service/server.js

@@ -0,0 +1,51 @@
+const options = require('../options');
+let http = options.listen.https ? require('https') : require('http');
+let app = new (require('koa'))();
+let server = http.createServer(app.callback());
+app.keys = options.session.keys;
+app.use(require('koa-morgan')(':method :url :status :res[content-length] - :response-time ms'));
+app.use(require('koa-body')());
+let router = (new require('koa-router'))();
+const sockjs = require('sockjs');
+/**
+ * @param {import('koa').Middleware} middleware 
+ */
+function MIDDLEWARE(middleware) {
+    app.use(middleware);
+}
+/**
+ * @param {string} route 
+ * @param {...import('koa').Middleware} handler 
+ */
+function GET(route, ...handler) {
+    router.get(route, ...handler);
+}
+/**
+ * @param {string} route 
+ * @param {...import('koa').Middleware} handler 
+ */
+function POST(route, ...handler) {
+    router.post(route, ...handler);
+}
+/**
+ * @callback SockJSHandler
+ * @param {import('sockjs').Connection} conn
+ */
+/**
+ * @param {string} prefix
+ * @param {SockJSHandler} handler
+ */
+function SOCKET(prefix, handler) {
+    const sock = sockjs.createServer({ prefix });
+    sock.on('connection', handler);
+    sock.installHandlers(server);
+}
+exports.MIDDLEWARE = MIDDLEWARE;
+exports.GET = GET;
+exports.POST = POST;
+exports.SOCKET = SOCKET;
+exports.start = function start() {
+    app.use(router.routes()).use(router.allowedMethods());
+    app.listen(options.listen.port);
+    console.log('Server listening at: %s', options.listen.port);
+};