Unify API calls by http(s) and ws(s)

PR-URL: #105

Author: tshemsedinov

lib/server.js

@@ -9,6 +9,7 @@ const TRANSPORT = { http, https, ws: http, wss: https };
 
 const MIME_TYPES = {
   html: 'text/html; charset=UTF-8',
+  json: 'application/json; charset=UTF-8',
   js: 'application/javascript; charset=UTF-8',
   css: 'text/css',
   png: 'image/png',
@@ -64,82 +65,58 @@ class Client {
     else this.error(404);
   }
 
-  error(status) {
-    if (this.res.finished) return;
-    this.res.writeHead(status, { 'Content-Type': 'text/plain' });
-    this.res.end(`HTTP ${status}: ${http.STATUS_CODES[status]}`);
-  }
-
-  async apihttp(method, args) {
-    const { res, application } = this;
-    const { semaphore } = application.server;
-    try {
-      await semaphore.enter();
-    } catch {
-      this.error(504);
+  error(status, err) {
+    const { application, req, res, connection } = this;
+    const reason = http.STATUS_CODES[status];
+    const message = err ? err.stack : reason;
+    application.logger.error(`${req.url} - ${message} - ${status}`);
+    const result = JSON.stringify({ result: 'error', reason });
+    if (connection) {
+      connection.send(result);
       return;
     }
-    const session = await this.application.auth.restore(this);
-    const sandbox = session ? session.sandbox : undefined;
-    const context = session ? session.context : {};
-    try {
-      const exp = this.application.runScript(method, sandbox);
-      const proc = exp(context);
-      if (!session && proc.access !== 'public') {
-        this.application.logger.error(`Forbidden ${method}`);
-        this.error(403);
-        semaphore.leave();
-        return;
-      }
-      const result = await proc.method(args);
-      if (res.finished) {
-        semaphore.leave();
-        return;
-      }
-      if (!session && proc.access === 'public') {
-        this.application.auth.start(this, result.userId);
-      }
-      res.end(JSON.stringify(result));
-    } catch (err) {
-      this.application.logger.error(err.stack);
-      this.error(err.message === 'Not found' ? 404 : 500);
-    }
-    semaphore.leave();
+    if (res.finished) return;
+    res.writeHead(status, { 'Content-Type': MIME_TYPES.json });
+    res.end(result);
   }
 
-  async apiws(method, args) {
-    const { connection, application } = this;
+  async execute(method, args) {
+    const { application } = this;
     const { semaphore } = application.server;
-    const send = obj => connection.send(JSON.stringify(obj));
-    try {
-      await semaphore.enter();
-    } catch {
-      send({ result: 'error', reason: 'timeout' });
-      return;
-    }
+    await semaphore.enter();
     try {
       const session = await application.auth.restore(this);
       const sandbox = session ? session.sandbox : undefined;
       const context = session ? session.context : {};
       const exp = application.runScript(method, sandbox);
       const proc = exp(context);
       if (!session && proc.access !== 'public') {
-        application.logger.error(`Forbidden: ${method}`);
-        send({ result: 'error', reason: 'forbidden' });
         semaphore.leave();
-        return;
+        throw new Error(`Forbidden: ${method}`);
       }
       const result = await proc.method(args);
       if (!session && proc.access === 'public') {
         const session = application.auth.start(this, result.userId);
         result.token = session.token;
       }
-      send(result);
+      return JSON.stringify(result);
+    } finally {
+      semaphore.leave();
+    }
+  }
+
+  async rpc(method, args) {
+    const { res, connection } = this;
+    try {
+      const result = await this.execute(method, args);
+      if (connection) connection.send(result);
+      else res.end(result);
     } catch (err) {
-      application.logger.error(err.stack);
-      send({ result: 'error' });
+      if (err.message === 'Not found') this.error(404);
+      else if (err.message === 'Semaphore timeout') this.error(504);
+      else if (err.message.startsWith('Forbidden:')) this.error(403);
+      else this.error(500, err);
     }
-    semaphore.leave();
   }
 }
 
@@ -171,14 +148,13 @@ const listener = application => (req, res) => {
     }
     receiveArgs(req).then(args => {
       const method = url.substring(METHOD_OFFSET);
-      client.apihttp(method, args);
+      client.rpc(method, args);
     });
   } else {
     client.static();
   }
 };
 
-
 class Server {
   constructor(config, application) {
     this.config = config;
@@ -196,7 +172,7 @@ class Server {
         const client = new Client(req, null, application, connection);
         connection.on('message', message => {
           const { method, args } = JSON.parse(message);
-          client.apiws(method, args);
+          client.rpc(method, args);
         });
       });
     }