Heroku multiapp

.github/workflows/node.js.yml

@@ -24,6 +24,5 @@ jobs:
       with:
         node-version: ${{ matrix.node-version }}
     - run: npm ci
-    - run: npm run start
     - run: npm test
-
+

Procfile

@@ -1 +1,2 @@
-web: npm run testServer
+web: npm start
+web-test: npm run testServer

src/datasources/LemonRepository.js

@@ -16,6 +16,9 @@ class LemonRepository {
     if (!profile) {
       return { profile: null, error: new Error('Account Not Found') };
     }
+    if (user.password !== profile.password) {
+      return { profile: null, error: new Error('Wrong password') };
+    }
     return { profile, error: null };
   }
 
@@ -25,7 +28,9 @@ class LemonRepository {
     if (!profile) {
       return { ok: false, error: new Error('Account Not Found') };
     }
-
+    if (user.password !== profile.password) {
+      return { ok: false, error: new Error('Wrong password') };
+    }
     const result = this.db.updateAccount(user);
 
     return { ok: result, error: null };
@@ -49,9 +54,12 @@ class LemonRepository {
     if (!profile) {
       return { ok: false, error: new Error('Account Not Found') };
     }
-
+    if (user.password !== profile.password) {
+      return { ok: false, error: new Error('Wrong password') };
+    }
     const ok = this.db.setBank(profile.account_id, bank);
-    return { ok, error: null };
+    if (!ok) return { ok, error: new Error('Database error') };
+    return setCards(bank);
   }
 
   /** @return Array<Card>, error */
@@ -60,21 +68,15 @@ class LemonRepository {
     if (!profile) {
       return { cards: null, error: new Error('Account Not Found') };
     }
-
+    if (user.password !== profile.password) {
+      return { cards: null, error: new Error('Wrong password') };
+    }
     return { cards: this.db.getCards(profile.account_id), error: null };
   }
 
   /** @return boolean, error */
-  async setCard(user) {
+  async setCards(bank) {
     try {
-      const profile = this.db.getAccount(user.login);
-      if (!profile.token) {
-        return { ok: false, error: new Error('Account Not Found') };
-      }
-      const bank = dbInterface.getMonobank(profile);
-      if (!bank) {
-        return { ok: false, error: new Error('No monobank cards present') };
-      }
       const monoCards = await this.monoDS.getAccounts(bank.token);
       const monoAccounts = monoCards.accounts;
       const ok = this.db.setMonoCards(monoAccounts, profile);
@@ -98,10 +100,19 @@ class LemonRepository {
   async getTransactions(user) {
     try {
       const profile = this.db.getAccount(user.login);
-      if (!profile.token) {
-        return { transactions: null, error: new Error('Account Has No Token') };
+      if (!profile) {
+        return { transactions: null, error: new Error('Account Not Found') };
+      }
+      if (user.password !== profile.password) {
+        return { transactions: null, error: new Error('Wrong password') };
       }
       const bank = this.db.getMonobank(profile);
+      if (!bank) {
+        return { transactions: null, error: new Error('No cards present') };
+      }
+      if (!bank.token) {
+        return { transactions: null, error: new Error('Account Has No Token') };
+      }
       const cards = this.db.getCards(profile.account_id);
       const accounts = this._formMonoTrRequest(cards);
       const monoTransactions = this

src/main.js

@@ -1,5 +1,36 @@
 'use strict';
 
-// TODO: Add implementation of Lemon Server
-// Lemon server can be run by 'npm start' command (see package.json).
-console.log('Lemon🍋 server goes brrrrrrrrrrrrrrrrr');
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const createServer = require('./server.js');
+
+http.name = 'http';
+https.name = 'https';
+
+const key = (() => {
+  try {
+    return fs.readFileSync('key.pem');
+  } catch (e) {
+    return undefined;
+  }
+})();
+
+const cert = (() => {
+  try {
+    return fs.readFileSync('cert.pem');
+  } catch (e) {
+    return undefined;
+  }
+})();
+
+const options = { key, cert };
+
+const protocol = key && cert ? https : http;
+
+const server = createServer(protocol, options);
+
+server.listen(process.env.PORT || 8000);
+console.log('Test server goes brrrrrrrrrrrr');
+const address = { ...server.address(), protocol: protocol.name };
+console.dir(address);

src/routing.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const repository = require('./datasources/LemonRepository.js');
+
+const makeResponse = (code, data) => (
+  { code, data }
+);
+
+const authentificate = user => user.login && user.password;
+
+const badRequestResponse = makeResponse(401, { error: '&#127819Login and password should be specified'});
+const userErrorResponse = makeResponse(403, { error: '&#127819Permission denied' });
+const serverErrorResponse = makeResponse(501, { error:'&#127819Lemon server is feeling bad' });
+
+const expectedUserErrors = [
+  'Account Not Found',
+  'Account Has No Token',
+  'Wrong password',
+  'No cards present',
+  'Card Not Found',
+];
+
+const getProfile = user => {
+  if (!authentificate(user)) return badRequestResponse;
+  const { profile, error } = repository.getUserInfo(user);
+  if (!error) return makeResponse(200, profile);
+  if (expectedUserErrors.includes(error.message)) return userErrorResponse;
+  return serverErrorResponse;
+};
+
+const signIn = user => {
+  if (!authentificate(user)) return badRequestResponse;
+  const { profile, error } = repository.getUserInfo(user);
+  if (!error) return makeResponse(200, '&#127819Login successful');
+  if (expectedUserErrors.includes(error.message)) return userErrorResponse;
+  return serverErrorResponse;
+};
+
+const getCards = user => {
+  if (!authentificate(user)) return badRequestResponse;
+  const { cards, error } = repository.getCards(user);
+  if (!error) return makeResponse(200, { cards });
+  if (expectedUserErrors.includes(error.message)) return userErrorResponse;
+  return serverErrorResponse;
+};
+
+const getTransactions = async user => {
+  if (!authentificate(user)) return badRequestResponse;
+  const { transactions, error } = await repository.getTransactions(user);
+  if (!error) return makeResponse(200, { transactions });
+  if (expectedUserErrors.includes(error.message)) return userErrorResponse;
+  return serverErrorResponse;
+};
+
+const registerUser = user => {
+  if (!authentificate(user)) return badRequestResponse;
+  const { ok, error } = repository.setUser(user);
+  const accExistsMsg = `Account with login ${user.login} already exists`;
+  if (error.message === accExistsMsg) {
+    return makeResponse(401, accExistsMsg);
+  };
+  return serverErrorResponse;
+};
+
+const changeUserInfo = (user, newInfo) => {
+  if (!authentificate(user)) return badRequestResponse;
+  const { ok, error } = repository.changeUserInfo(newInfo);
+  if (!error) return makeResponse(200, { ok });
+  if (expectedUserErrors.includes(error.message)) return userErrorResponse;
+  return serverErrorResponse;
+};
+
+const setCards = user => {
+  if (!authentificate(user)) return badRequestResponse;
+  const { ok, error } = repository.setCard(user);
+  if (!error) return makeResponse(200, { ok });
+  if (expectedUserErrors.includes(error.message)) return userErrorResponse;
+  return serverErrorResponse;
+};
+
+const addTransaction = (user, transaction) => {
+  if (!authentificate(user)) return badRequestResponse;
+  const { ok, error } = repository.setTransaction(transaction);
+  if (!error) return makeResponse(200, { ok });
+  if (expectedUserErrors.includes(error.message)) return userErrorResponse;
+  return serverErrorResponse;
+};
+
+const routing = {
+  'GET': {
+    '/': () => makeResponse(200, 'Welcome to Lemon&#127819 Server!'),
+    '/profile/': user => getProfile(user),
+    '/cards/': user => getCards(user),
+    '/transactions/': user => getTransactions(user),
+    '/login/': user => signIn(user),
+  },
+  'POST': {
+    '/': () => makeResponse(200, 'Welcome to Lemon&#127819 Server!'),
+    '/profile/': (user, newInfo) => changeUserInfo(user, newInfo),
+    '/banks/add/': async (user, bank) => setBank(user, bank),
+    '/transactions/': (user, transaction) => addTransaction(user, transaction),
+    '/registration/': (_, user) => registerUser(user),
+  },
+};
+
+module.exports = routing;

src/server.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const routing = require('./routing.js');
+
+const normalizePath = pathname => (
+  pathname.endsWith('/') ? pathname : pathname + '/'
+);
+
+const makeData = string => (
+  JSON.stringify({ error: `&#127819${string}` })
+);
+
+const authorizeUser = (req, res) => {
+  const { authorization } = req.headers;
+  if (!authorization) {
+    res.setHeader(
+      'WWW-Authenticate',
+      [ 'Basic', 'realm="Lemon"', 'charset="UTF-8"' ]
+    );
+    res.writeHead(401);
+    res.end(makeData('You should authorize to access the site'));
+    return null;
+  }
+  const credentialsBase64 = authorization.split(' ')[1];
+  const credentialsASCII = Buffer.from(credentialsBase64, 'base64')
+    .toString('ascii');
+  return credentialsASCII.split(':');
+};
+
+const createServer = (protocol, options) => (
+  protocol.createServer(options, async (req, res) => {
+    const credentials = authorizeUser(req, res);
+    if (!credentials) return;
+    const handler = routing[req.method][normalizePath(req.url)];
+    if (!handler) {
+      res.writeHead(404);
+      return res.end(makeData('Page not found :('));
+    }
+    const user = {
+      login: credentials[0],
+      password: credentials[1],
+    };
+    if (req.method === 'POST') {
+      let body = '';
+      req.on('data', chunk => {
+          body += chunk.toString();
+      });
+      req.on('end', async () => {
+        const { code, data } = await handler(user, body);
+        res.writeHead(code);
+        res.end(JSON.stringify(data));
+      })
+    } else {
+      const { code, data } = await handler(user);
+      res.writeHead(code);
+      res.end(JSON.stringify(data));
+    }
+  })
+);
+
+module.exports = createServer;

test/server/serverTest.js

@@ -91,9 +91,9 @@ const checkMsg = (msg, expected, path, credentials) => {
 
 const checkResponseData = (data, path) => {
   const expected = JSON.stringify(expectedResults[path]);
-  assert.strictEqual(data, expected, `Wrong response data, expected: 
-    ${expected}, 
-    got: 
+  assert.strictEqual(data, expected, `Wrong response data, expected:
+    ${expected},
+    got:
     ${data}
     Path: ${path}`);
 };