underpost 2.6.2

package/package.json

@@ -0,0 +1,128 @@
+{
+  "type": "module",
+  "main": "src/server.js",
+  "name": "underpost",
+  "version": "2.6.2",
+  "description": "pwa api rest template",
+  "scripts": {
+    "start": "env-cmd -f .env.production node --max-old-space-size=8192 src/server",
+    "pm2": "env-cmd -f .env.production pm2 start src/server.js --node-args=\"--max-old-space-size=8192\" --name engine && pm2 logs",
+    "ssl": "env-cmd -f .env.production node bin/ssl",
+    "pm2-delete": "pm2 delete engine",
+    "build": "node bin/deploy build-full-client --no-warnings",
+    "dev": "env-cmd -f .env.development node src/client.dev --no-warnings",
+    "dev-api": "env-cmd -f .env.development nodemon --watch src --ignore src/client src/api",
+    "docs": "jsdoc -c jsdoc.json",
+    "backup": "node bin/db default.net/ export",
+    "install-template": "npm install && npm run build",
+    "install-global": "npm install -g pm2 && npm install -g jsdoc && npm install -g prettier && npm install -g env-cmd",
+    "install-test": "npm install -g mocha && npm install -g c8 && npm install -g nyc && npm install -g coveralls",
+    "install-vs-extensions": "node bin/vs import",
+    "preinstall": "npm config set audit false && npm config set loglevel error",
+    "restore-preinstall": "npm config set audit true && npm config set loglevel notice",
+    "install": "npm run install-global && npm run install-test && npm run restore-preinstall --no-audit --no-warnings",
+    "docker:start": "docker-compose up",
+    "prettier": "prettier --write .",
+    "coveralls": "nyc npm run test --reporter=text-lcov | coveralls -v",
+    "test": "env-cmd -f .env.test c8 mocha",
+    "update": "npm update -g && npm update && npm audit fix --force && npm audit fix --force",
+    "underpost-publish": "npm publish --access public",
+    "underpost-unpublish": "npm unpublish underpost@2.5.x",
+    "login": "npm adduser",
+    "bin": "npm link --force"
+  },
+  "bin": {
+    "underpost": "bin/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/underpostnet/pwa-microservices-template.git"
+  },
+  "keywords": [
+    "pwa",
+    "template",
+    "microservices",
+    "api",
+    "server",
+    "proxy",
+    "client"
+  ],
+  "author": "https://github.com/underpostnet",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/underpostnet/pwa-microservices-template/issues"
+  },
+  "homepage": "https://github.com/underpostnet/pwa-microservices-template#readme",
+  "dependencies": {
+    "@fortawesome/fontawesome-free": "^6.4.2",
+    "@loadingio/css-spinner": "^2.0.2",
+    "@neodrag/vanilla": "^2.0.3",
+    "@pinata/sdk": "^2.1.0",
+    "adm-zip": "^0.5.10",
+    "ag-grid-community": "31.0.0",
+    "axios": "^1.5.1",
+    "cli-progress": "^3.12.0",
+    "cli-spinners": "^3.0.0",
+    "color": "^4.2.3",
+    "colors": "^1.4.0",
+    "compression": "^1.7.4",
+    "copy-paste": "^1.5.3",
+    "cors": "^2.8.5",
+    "d3": "^7.9.0",
+    "deepmerge": "^4.3.1",
+    "detect-port": "^1.5.1",
+    "dotenv": "^16.3.1",
+    "easymde": "^2.18.0",
+    "env-cmd": "^10.1.0",
+    "eventemitter3": "^5.0.1",
+    "express": "^4.18.2",
+    "express-fileupload": "^1.4.3",
+    "favicons": "^7.2.0",
+    "font-awesome-assets": "^0.0.9",
+    "fs-extra": "^11.1.1",
+    "fullcalendar": "^6.1.15",
+    "html-minifier-terser": "^7.2.0",
+    "http-proxy-middleware": "^2.0.6",
+    "ignore-walk": "^6.0.4",
+    "is-admin": "^4.0.0",
+    "is-ip": "^5.0.1",
+    "jimp": "^0.22.12",
+    "joystick-controller": "^1.0.15",
+    "json-colorizer": "^2.2.2",
+    "jsonwebtoken": "^9.0.2",
+    "kill-port-process": "^3.2.0",
+    "log-update": "^6.0.0",
+    "mariadb": "^3.2.2",
+    "marked": "^12.0.1",
+    "mongoose": "^8.0.1",
+    "morgan": "^1.10.0",
+    "nodemailer": "^6.9.9",
+    "nodemon": "^3.0.1",
+    "pathfinding": "^0.4.18",
+    "peer": "^1.0.2",
+    "peerjs": "^1.5.2",
+    "pixi.js": "7.4.0",
+    "prom-client": "^15.1.2",
+    "public-ip": "^6.0.1",
+    "read": "^2.1.0",
+    "sharp": "^0.32.5",
+    "shelljs": "^0.8.5",
+    "sitemap": "^7.1.1",
+    "socket.io": "^4.7.2",
+    "sortablejs": "^1.15.0",
+    "swagger-ui-express": "^5.0.0",
+    "systeminformation": "^5.21.17",
+    "text-to-image": "^5.2.0",
+    "uglify-js": "^3.17.4",
+    "validator": "^13.11.0",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "chai": "^5.1.0",
+    "clean-jsdoc-theme": "^4.3.0",
+    "mocha": "^10.4.0",
+    "plantuml": "^0.0.2",
+    "swagger-autogen": "^2.23.7",
+    "to-json-schema": "^0.2.5"
+  }
+}

package/prometheus.yml

@@ -0,0 +1,36 @@
+# my global config
+global:
+  scrape_interval: 5s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
+  evaluation_interval: 5s # Evaluate rules every 15 seconds. The default is every 1 minute.
+  # scrape_timeout is set to the global default (10s).
+
+# Alertmanager configuration
+alerting:
+  alertmanagers:
+    - static_configs:
+        - targets:
+          # - alertmanager:9093
+
+# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
+rule_files:
+  # - "first_rules.yml"
+  # - "second_rules.yml"
+
+# A scrape configuration containing exactly one endpoint to scrape:
+# Here it's Prometheus itself.
+scrape_configs:
+  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
+  - job_name: 'prometheus_service'
+
+    # metrics_path defaults to '/metrics'
+    # scheme defaults to 'http'.
+
+    static_configs:
+      - targets: ['host.docker.internal:9090']
+
+  - job_name: 'nodejs_service'
+    static_configs:
+      - targets: ['host.docker.internal:4001', 'host.docker.internal:4002']
+      # - targets: ['localhost:4001', 'localhost:4002']
+      # - targets: ["host.docker.internal:3002"] # Windows
+      # - targets: ["docker.for.mac.localhost:9090"] # macOs

package/setup.sh

@@ -0,0 +1,25 @@
+sudo apt update
+sudo apt upgrade
+
+# Install the MongoDB 4.4 GPG key:
+wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -
+
+# Add the source location for the MongoDB packages:
+# echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list
+echo "deb [ arch=arm64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.2.list
+
+# Download the package details for the MongoDB packages:
+sudo apt-get update
+
+# Install MongoDB:
+sudo apt-get install -y mongodb-org
+# sudo apt-get install mongodb
+
+# Ensure mongod config is picked up:
+sudo systemctl daemon-reload
+
+# Tell systemd to run mongod on reboot:
+sudo systemctl enable mongod
+
+# Start up mongod!
+sudo systemctl start mongod

package/src/api/core/core.controller.js

@@ -0,0 +1,69 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CoreService } from './core.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const CoreController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await CoreService.post(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      const result = await CoreService.put(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await CoreService.get(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await CoreService.delete(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+};
+
+export { CoreController };

package/src/api/core/core.model.js

@@ -0,0 +1,11 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const CoreSchema = new Schema({});
+
+const CoreModel = model('Core', CoreSchema);
+
+const ProviderSchema = CoreSchema;
+
+export { CoreSchema, CoreModel, ProviderSchema };

package/src/api/core/core.router.js

@@ -0,0 +1,23 @@
+import { authMiddleware } from '../../server/auth.js';
+import { loggerFactory } from '../../server/logger.js';
+import { CoreController } from './core.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CoreRouter = (options) => {
+  const router = express.Router();
+  router.post(`/:id`, async (req, res) => await CoreController.post(req, res, options));
+  router.post(`/`, async (req, res) => await CoreController.post(req, res, options));
+  router.get(`/:id`, async (req, res) => await CoreController.get(req, res, options));
+  router.get(`/`, async (req, res) => await CoreController.get(req, res, options));
+  router.put(`/:id`, async (req, res) => await CoreController.put(req, res, options));
+  router.put(`/`, async (req, res) => await CoreController.put(req, res, options));
+  router.delete(`/:id`, async (req, res) => await CoreController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await CoreController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = CoreRouter;
+
+export { ApiRouter, CoreRouter };

package/src/api/core/core.service.js

@@ -0,0 +1,29 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+const CoreService = {
+  post: async (req, res, options) => {
+    /** @type {import('./core.model.js').CoreModel} */
+    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
+    return await new Core(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./core.model.js').CoreModel} */
+    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
+    return await Core.findById(req.params.id);
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./core.model.js').CoreModel} */
+    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
+    return await Core.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./core.model.js').CoreModel} */
+    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
+    return await Core.findByIdAndDelete(req.params.id);
+  },
+};
+
+export { CoreService };

package/src/api/crypto/crypto.controller.js

@@ -0,0 +1,51 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CryptoService } from './crypto.service.js';
+const logger = loggerFactory(import.meta);
+
+const CryptoController = {
+  post: async (req, res, options) => {
+    try {
+      return res.status(200).json({
+        status: 'success',
+        data: await CryptoService.post(req, res, options),
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      return res.status(200).json({
+        status: 'success',
+        data: await CryptoService.get(req, res, options),
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await CryptoService.delete(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+};
+
+export { CryptoController };

package/src/api/crypto/crypto.model.js

@@ -0,0 +1,23 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+// Example:
+// JWKS: Array of JWK
+// https://auth0.com/docs/secure/tokens/json-web-tokens/json-web-key-sets
+
+const CryptoSchema = new Schema({
+  format: { type: String, required: 'format is required' },
+  data: { type: String, required: 'data is required', unique: true },
+  algorithm: {
+    name: { type: String, required: 'name is required' },
+    namedCurve: { type: String, required: 'namedCurve is required' },
+    hash: { type: String, required: 'hash is required' },
+  },
+});
+
+const CryptoModel = model('Crypto', CryptoSchema);
+
+const ProviderSchema = CryptoSchema;
+
+export { CryptoSchema, CryptoModel, ProviderSchema };

package/src/api/crypto/crypto.router.js

@@ -0,0 +1,20 @@
+import { authMiddleware } from '../../server/auth.js';
+import { loggerFactory } from '../../server/logger.js';
+import { CryptoController } from './crypto.controller.js';
+import express from 'express';
+const logger = loggerFactory(import.meta);
+
+const CryptoRouter = (options) => {
+  const router = express.Router();
+  router.post(`/:id`, async (req, res) => await CryptoController.post(req, res, options));
+  router.post(`/`, authMiddleware, async (req, res) => await CryptoController.post(req, res, options));
+  router.get(`/:id`, async (req, res) => await CryptoController.get(req, res, options));
+  router.get(`/`, async (req, res) => await CryptoController.get(req, res, options));
+  router.delete(`/:id`, async (req, res) => await CryptoController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await CryptoController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = CryptoRouter;
+
+export { ApiRouter, CryptoRouter };

package/src/api/crypto/crypto.service.js

@@ -0,0 +1,64 @@
+import { loggerFactory } from '../../server/logger.js';
+import crypto from 'crypto';
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+const logger = loggerFactory(import.meta);
+
+const CryptoService = {
+  post: async (req, res, options) => {
+    /** @type {import('./crypto.model.js').CryptoModel} */
+    const Crypto = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Crypto;
+    /** @type {import('../user/user.model.js').UserModel} */
+    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.User;
+
+    switch (req.params.id) {
+      case 'verify': {
+        const signature = Buffer.from(req.body.signature, 'base64');
+
+        const publicKey = await crypto.subtle.importKey(
+          'jwk',
+          req.body.publicKey,
+          {
+            name: 'ECDSA',
+            namedCurve: 'P-384',
+            hash: 'SHA-256',
+          },
+          true,
+          ['verify'],
+        );
+
+        const isValid = await crypto.subtle.verify(
+          {
+            name: 'ECDSA',
+            hash: 'SHA-256',
+          },
+          publicKey,
+          signature,
+          new TextEncoder().encode(JSON.stringify(req.body.payload)),
+        );
+
+        return { isValid };
+      }
+      default: {
+        const publicKey = await new Crypto(req.body).save();
+        const user = await User.findById(req.auth.user._id);
+        user.publicKey.push(publicKey._id);
+        await User.findByIdAndUpdate(req.auth.user._id, user, {
+          runValidators: true,
+        });
+        return publicKey;
+      }
+    }
+  },
+  get: async (req, res, options) => {
+    switch (req.params.id) {
+      default:
+    }
+  },
+  delete: async (req, res, options) => {
+    switch (req.params.id) {
+      default:
+    }
+  },
+};
+
+export { CryptoService };

package/src/api/default/default.controller.js

@@ -0,0 +1,69 @@
+import { loggerFactory } from '../../server/logger.js';
+import { DefaultService } from './default.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const DefaultController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await DefaultService.post(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      const result = await DefaultService.get(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await DefaultService.put(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await DefaultService.delete(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+};
+
+export { DefaultController };

package/src/api/default/default.model.js

@@ -0,0 +1,20 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const DefaultSchema = new Schema(
+  {
+    0: { type: String },
+    1: { type: String },
+    2: { type: String },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+const DefaultModel = model('Default', DefaultSchema);
+
+const ProviderSchema = DefaultSchema;
+
+export { DefaultSchema, DefaultModel, ProviderSchema };

package/src/api/default/default.router.js

@@ -0,0 +1,23 @@
+import { authMiddleware } from '../../server/auth.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DefaultController } from './default.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const DefaultRouter = (options) => {
+  const router = express.Router();
+  router.post(`/:id`, async (req, res) => await DefaultController.post(req, res, options));
+  router.post(`/`, async (req, res) => await DefaultController.post(req, res, options));
+  router.get(`/:id`, async (req, res) => await DefaultController.get(req, res, options));
+  router.get(`/`, async (req, res) => await DefaultController.get(req, res, options));
+  router.put(`/:id`, async (req, res) => await DefaultController.put(req, res, options));
+  router.put(`/`, async (req, res) => await DefaultController.put(req, res, options));
+  router.delete(`/:id`, async (req, res) => await DefaultController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await DefaultController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = DefaultRouter;
+
+export { ApiRouter, DefaultRouter };

package/src/api/default/default.service.js

@@ -0,0 +1,31 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+const DefaultService = {
+  post: async (req, res, options) => {
+    /** @type {import('./default.model.js').DefaultModel} */
+    const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Default;
+    return await new Default(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./default.model.js').DefaultModel} */
+    const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Default;
+    if (req.params.id) return await Default.findById(req.params.id);
+    return await Default.find();
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./default.model.js').DefaultModel} */
+    const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Default;
+    return await Default.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./default.model.js').DefaultModel} */
+    const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Default;
+    if (req.params.id) return await Default.findByIdAndDelete(req.params.id);
+    else return await await Default.deleteMany();
+  },
+};
+
+export { DefaultService };