Implements client-side http transport

* Adds support of node 20 to package.json

Author: rgbabaev

JavaScript/9-logger/config.js

@@ -1,14 +1,14 @@
 module.exports = {
-  transport: "http", // ws | http
+  transport: 'ws', // ws | http
   apiPort: 8001,
   staticPort: 8000,
-  staticPath: "./static",
-  logPath: "./log",
+  staticPath: './static',
+  logPath: './log',
   db: {
-    host: "127.0.0.1",
+    host: '127.0.0.1',
     port: 5432,
-    database: "example",
-    user: "marcus",
-    password: "marcus",
+    database: 'example',
+    user: 'marcus',
+    password: 'marcus',
   },
 };

JavaScript/9-logger/http.js

@@ -2,6 +2,11 @@
 
 const http = require('node:http');
 
+const answerNotFound = (res, headers) => {
+  res.writeHead(404, headers);
+  res.end('Not found');
+};
+
 const receiveArgs = async (req) => {
   const buffers = [];
   for await (const chunk of req) buffers.push(chunk);
@@ -10,22 +15,34 @@ const receiveArgs = async (req) => {
 };
 
 module.exports = (routing, port, console) => {
-  http.createServer(async (req, res) => {
-    const { url, socket } = req;
-    const [name, method, id] = url.substring(1).split('/');
-    const entity = routing[name];
-    if (!entity) return void res.end('Not found');
-    const handler = entity[method];
-    if (!handler) return void res.end('Not found');
-    const src = handler.toString();
-    const signature = src.substring(0, src.indexOf(')'));
-    const args = [];
-    if (signature.includes('(id')) args.push(id);
-    if (signature.includes('{')) args.push(await receiveArgs(req));
-    console.log(`${socket.remoteAddress} ${method} ${url}`);
-    const result = await handler(...args);
-    res.end(JSON.stringify(result.rows));
-  }).listen(port);
+  http
+    .createServer(async (req, res) => {
+      const headers = {
+        'Access-Control-Allow-Origin':
+          '*' /* @dev First, read about security */,
+        'Access-Control-Allow-Methods': 'POST',
+        'Access-Control-Max-Age': 2592000, // 30 days
+        /** add other headers as per requirement */
+      };
+
+      const { url, socket } = req;
+      const [name, method, id] = url.substring(1).split('/');
+      const entity = routing[name];
+      if (!entity) return void answerNotFound(res, headers);
+      const handler = entity[method];
+      if (!handler) return void answerNotFound(res, headers);
+
+      res.writeHead(200, headers);
+      const src = handler.toString();
+      const signature = src.substring(0, src.indexOf(')'));
+      const args = [];
+      if (signature.includes('(id')) args.push(id);
+      args.push(...(await receiveArgs(req)));
+      console.log(`${socket.remoteAddress} ${req.method} ${url}`);
+      const result = await handler(...args);
+      res.end(JSON.stringify(result.rows));
+    })
+    .listen(port);
 
   console.log(`API on port ${port}`);
 };

JavaScript/9-logger/package.json

@@ -6,7 +6,7 @@
   "private": true,
   "main": "main.js",
   "engines": {
-    "node": "14 || 16 || 18"
+    "node": "14 || 16 || 18 || 20"
   },
   "scripts": {
     "start": "node --experimental-vm-modules main.js"

JavaScript/9-logger/static/client.js

@@ -1,44 +1,86 @@
 'use strict';
 
-const socket = new WebSocket('ws://127.0.0.1:8001/');
+const API_URL = 'ws://localhost:8001';
 
-const scaffold = (structure) => {
+const getTransport = (url) => {
+  let socket;
+  const protocol = url.split(':')[0];
+
+  const transports = {
+    ws: (name, method) => {
+      if (!socket) socket = new WebSocket(url);
+      return (...args) => {
+        return new Promise((resolve) => {
+          const packet = { name, method, args };
+          socket.send(JSON.stringify(packet));
+          socket.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            resolve(data);
+          };
+        });
+      };
+    },
+
+    http:
+      (name, method, methodArgs) =>
+      (...args) => {
+        const urlParts = [url, name, method];
+        if (methodArgs[0] === 'id') urlParts.push(args.shift());
+
+        return fetch(urlParts.join('/'), {
+          method: 'POST',
+          body: JSON.stringify(args),
+        }).then((response) => response.json());
+      },
+  };
+
+  return transports[protocol];
+};
+
+const scaffold = (url, structure) => {
+  const transport = getTransport(url);
   const api = {};
   const services = Object.keys(structure);
   for (const serviceName of services) {
     api[serviceName] = {};
     const service = structure[serviceName];
     const methods = Object.keys(service);
     for (const methodName of methods) {
-      api[serviceName][methodName] = (...args) => new Promise((resolve) => {
-        const packet = { name: serviceName, method: methodName, args };
-        socket.send(JSON.stringify(packet));
-        socket.onmessage = (event) => {
-          const data = JSON.parse(event.data);
-          resolve(data);
-        };
-      });
+      api[serviceName][methodName] = transport(
+        serviceName,
+        methodName,
+        service[methodName],
+      );
     }
   }
   return api;
 };
 
-const api = scaffold({
+const api = scaffold(API_URL, {
   user: {
     create: ['record'],
     read: ['id'],
     update: ['id', 'record'],
     delete: ['id'],
     find: ['mask'],
   },
+  city: {
+    read: ['id'],
+    create: ['record'],
+    update: ['id', 'record'],
+    delete: ['id'],
+  },
   country: {
     read: ['id'],
+    create: ['record'],
+    update: ['id', 'record'],
     delete: ['id'],
-    find: ['mask'],
   },
 });
 
-socket.addEventListener('open', async () => {
-  const data = await api.user.read(3);
-  console.dir({ data });
-});
+// socket.addEventListener('open', async () => {
+//   const data = await api.user.read(3);
+//   console.dir({ data });
+// });
+
+(async () => console.log(await api.user.read(3)))();