@underpostnet/underpost 2.7.82

package/docker-compose.yml

@@ -0,0 +1,67 @@
+# https://docs.docker.com/compose/compose-file/compose-file-v3
+# https://docs.docker.com/engine/reference/commandline/compose/
+version: '3'
+services:
+  prometheus:
+    image: prom/prometheus
+    ports:
+      - 9090:9090
+    volumes:
+      - ./prometheus_data:/prometheus
+      - ./prometheus.yml:/etc/prometheus/prometheus.yml
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+    networks:
+      - load-balancer
+
+  grafana:
+    image: grafana/grafana
+    ports:
+      - 3000:3000
+    volumes:
+      - ./grafana_data:/var/lib/grafana
+    #  - ./grafana.ini:/etc/grafana/grafana.ini
+    networks:
+      - load-balancer
+    depends_on:
+      - prometheus
+
+  underpost-engine:
+    build:
+      dockerfile: ./Dockerfile
+      context: . # workdir path
+    # image: underpost-engine
+    # container_name: <name> ignore for replicas
+    ports:
+      - '22'
+      - '80' # host port allocated dynamically, host ports are unique independent of replicas
+      - '443'
+      - '3306'
+      - '27017'
+      - '4001-4002:3001'
+      - '3002-3020'
+    volumes:
+      - ./logs:/code/logs
+    deploy:
+      mode: replicated
+      replicas: 2
+      restart_policy:
+        condition: on-failure
+        delay: 5s
+        max_attempts: 3
+        window: 120s
+      resources:
+        limits:
+          cpus: '2'
+          memory: 400M
+        reservations:
+          cpus: '0.25'
+          memory: 20M
+    labels: # labels in Compose file instead of Dockerfile
+      engine.version: '2.7.82'
+    networks:
+      - load-balancer
+
+networks:
+  load-balancer:
+    driver: bridge

package/jsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "module": "CommonJS",
+    "target": "ES6"
+  },
+  "exclude": ["node_modules", "public", "engine-private"]
+}

package/jsdoc.json

@@ -0,0 +1,32 @@
+{
+  "tags": {
+    "allowUnknownTags": true,
+    "dictionaries": ["jsdoc"]
+  },
+  "source": {
+    "include": ["./src", "./package.json", "./README.md"],
+    "includePattern": ".js$",
+    "excludePattern": "(node_modules/|docs)"
+  },
+  "plugins": ["plugins/markdown", "plugins/summarize", "plugins/shout"],
+  "opts": {
+    "template": "node_modules/clean-jsdoc-theme",
+    "readme": "./README.md",
+    "recurse": true,
+    "destination": "./public/www.nexodev.org/docs/",
+    "encoding": "utf8",
+    "verbose": true,
+    "theme_opts": {
+      "default_theme": "light",
+      "search": true,
+      "title": "Nexodev - ERP, CRM Development & Cloud DevOps Services",
+      "homepageTitle": "Docs",
+      "favicon": "./public/www.nexodev.org/"
+    },
+    "tutorials": "./public/www.nexodev.org/docs/learn"
+  },
+  "markdown": {
+    "hardwrap": false,
+    "idInHeadings": true
+  }
+}

package/nodemon.json

@@ -0,0 +1,6 @@
+{
+  "watch": ["./src"],
+  "ext": "js",
+  "delay": 0,
+  "ignore": []
+}

package/package.json

@@ -0,0 +1,134 @@
+{
+    "type": "module",
+    "main": "src/index.js",
+    "name": "@underpostnet/underpost",
+    "version": "2.7.82",
+    "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 && npm install -g yarn && npm install -g auto-changelog",
+        "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 --provenance --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-ghpkg.git"
+    },
+    "keywords": [
+        "engine",
+        "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",
+        "@xenova/transformers": "^2.17.2",
+        "adm-zip": "^0.5.10",
+        "ag-grid-community": "31.0.0",
+        "axios": "^1.5.1",
+        "chai": "^5.1.0",
+        "cli-progress": "^3.12.0",
+        "cli-spinners": "^3.0.0",
+        "color": "^4.2.3",
+        "colors": "^1.4.0",
+        "commander": "^12.1.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.2",
+        "mongoose": "^8.0.1",
+        "morgan": "^1.10.0",
+        "node-cron": "^3.0.3",
+        "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",
+        "simple-git": "^3.26.0",
+        "simple-icons": "^13.9.0",
+        "sitemap": "^7.1.1",
+        "socket.io": "^4.8.0",
+        "sortablejs": "^1.15.0",
+        "split-file": "^2.3.0",
+        "swagger-ui-express": "^5.0.0",
+        "systeminformation": "^5.21.17",
+        "uglify-js": "^3.17.4",
+        "validator": "^13.11.0",
+        "winston": "^3.11.0"
+    },
+    "devDependencies": {
+        "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"
+    },
+    "publishConfig": {
+        "provenance": true,
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    }
+}

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/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 };