underpost 2.8.87 → 2.8.88

package/manifests/deployment/dd-test-development/deployment.yaml

@@ -0,0 +1,174 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dd-test-development-blue
+  labels:
+    app: dd-test-development-blue
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: dd-test-development-blue
+  template:
+    metadata:
+      labels:
+        app: dd-test-development-blue
+    spec:
+      containers:
+        - name: dd-test-development-blue
+          image: localhost/rockylinux9-underpost:v2.8.88
+#          resources:
+#            requests:
+#              memory: "94Ki"
+#              cpu: "75m"
+#            limits:
+#              memory: "1504Ki"
+#              cpu: "1200m"
+          command:
+            - /bin/sh
+            - -c
+            - >
+              npm install -g npm@11.2.0 &&
+              npm install -g underpost &&
+              underpost secret underpost --create-from-file /etc/config/.env.development &&
+              underpost start --build --run dd-test development
+          volumeMounts:
+            - name: config-volume
+              mountPath: /etc/config
+      volumes:
+        - name: config-volume
+          configMap:
+            name: underpost-config
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: dd-test-development-blue-service
+spec:
+  selector:
+    app: dd-test-development-blue
+  ports:
+    - name: 'tcp-4021'
+      protocol: TCP
+      port: 4021
+      targetPort: 4021
+    - name: 'udp-4021'
+      protocol: UDP
+      port: 4021
+      targetPort: 4021
+
+    - name: 'tcp-4022'
+      protocol: TCP
+      port: 4022
+      targetPort: 4022
+    - name: 'udp-4022'
+      protocol: UDP
+      port: 4022
+      targetPort: 4022
+
+    - name: 'tcp-4023'
+      protocol: TCP
+      port: 4023
+      targetPort: 4023
+    - name: 'udp-4023'
+      protocol: UDP
+      port: 4023
+      targetPort: 4023
+
+    - name: 'tcp-4024'
+      protocol: TCP
+      port: 4024
+      targetPort: 4024
+    - name: 'udp-4024'
+      protocol: UDP
+      port: 4024
+      targetPort: 4024
+  type: LoadBalancer
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dd-test-development-green
+  labels:
+    app: dd-test-development-green
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: dd-test-development-green
+  template:
+    metadata:
+      labels:
+        app: dd-test-development-green
+    spec:
+      containers:
+        - name: dd-test-development-green
+          image: localhost/rockylinux9-underpost:v2.8.88
+#          resources:
+#            requests:
+#              memory: "94Ki"
+#              cpu: "75m"
+#            limits:
+#              memory: "1504Ki"
+#              cpu: "1200m"
+          command:
+            - /bin/sh
+            - -c
+            - >
+              npm install -g npm@11.2.0 &&
+              npm install -g underpost &&
+              underpost secret underpost --create-from-file /etc/config/.env.development &&
+              underpost start --build --run dd-test development
+          volumeMounts:
+            - name: config-volume
+              mountPath: /etc/config
+      volumes:
+        - name: config-volume
+          configMap:
+            name: underpost-config
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: dd-test-development-green-service
+spec:
+  selector:
+    app: dd-test-development-green
+  ports:
+    - name: 'tcp-4021'
+      protocol: TCP
+      port: 4021
+      targetPort: 4021
+    - name: 'udp-4021'
+      protocol: UDP
+      port: 4021
+      targetPort: 4021
+
+    - name: 'tcp-4022'
+      protocol: TCP
+      port: 4022
+      targetPort: 4022
+    - name: 'udp-4022'
+      protocol: UDP
+      port: 4022
+      targetPort: 4022
+
+    - name: 'tcp-4023'
+      protocol: TCP
+      port: 4023
+      targetPort: 4023
+    - name: 'udp-4023'
+      protocol: UDP
+      port: 4023
+      targetPort: 4023
+
+    - name: 'tcp-4024'
+      protocol: TCP
+      port: 4024
+      targetPort: 4024
+    - name: 'udp-4024'
+      protocol: UDP
+      port: 4024
+      targetPort: 4024
+  type: LoadBalancer

package/manifests/deployment/dd-test-development/proxy.yaml

@@ -0,0 +1,51 @@
+
+---
+apiVersion: projectcontour.io/v1
+kind: HTTPProxy
+metadata:
+  name: test.nexodev.org
+spec:
+  virtualhost:
+    fqdn: test.nexodev.org
+  routes:
+    - conditions:
+        - prefix: /
+      enableWebsockets: true
+      services:
+        - name: dd-test-development-blue-service
+          port: 4021
+          weight: 100
+    
+    - conditions:
+        - prefix: /peer
+      enableWebsockets: true
+      services:
+        - name: dd-test-development-blue-service
+          port: 4022
+          weight: 100
+    
+---
+apiVersion: projectcontour.io/v1
+kind: HTTPProxy
+metadata:
+  name: stagging.nexodev.org
+spec:
+  virtualhost:
+    fqdn: stagging.nexodev.org
+  routes:
+    - conditions:
+        - prefix: /
+      enableWebsockets: true
+      services:
+        - name: dd-test-development-blue-service
+          port: 4023
+          weight: 100
+    
+    - conditions:
+        - prefix: /peer
+      enableWebsockets: true
+      services:
+        - name: dd-test-development-blue-service
+          port: 4024
+          weight: 100
+    

package/package.json

@@ -2,7 +2,7 @@
     "type": "module",
     "main": "src/index.js",
     "name": "underpost",
-    "version": "2.8.87",
+    "version": "2.8.88",
     "description": "pwa api rest template",
     "scripts": {
         "start": "env-cmd -f .env.production node --max-old-space-size=8192 src/server",
@@ -51,10 +51,9 @@
     "dependencies": {
         "@fortawesome/fontawesome-free": "^6.4.2",
         "@fullcalendar/rrule": "^6.1.15",
-        "@loadingio/css-spinner": "^2.0.2",
         "@neodrag/vanilla": "^2.0.3",
         "adm-zip": "^0.5.10",
-        "ag-grid-community": "31.0.0",
+        "ag-grid-community": "^31.3.4",
         "axios": "^1.5.1",
         "chai": "^5.1.0",
         "clean-jsdoc-theme": "^4.3.0",
@@ -63,6 +62,7 @@
         "colors": "^1.4.0",
         "commander": "^12.1.0",
         "compression": "^1.7.4",
+        "cookie-parser": "^1.4.7",
         "cors": "^2.8.5",
         "d3": "^7.9.0",
         "dotenv": "^16.3.1",
@@ -70,9 +70,12 @@
         "env-cmd": "^10.1.0",
         "express": "^4.18.2",
         "express-fileupload": "^1.4.3",
+        "express-rate-limit": "^8.1.0",
+        "express-slow-down": "^3.0.0",
         "favicons": "^7.2.0",
         "fs-extra": "^11.1.1",
         "fullcalendar": "^6.1.15",
+        "helmet": "^8.1.0",
         "html-minifier-terser": "^7.2.0",
         "http-proxy-middleware": "^2.0.6",
         "ignore-walk": "^6.0.4",
@@ -80,7 +83,6 @@
         "jimp": "^0.22.12",
         "json-colorizer": "^2.2.2",
         "jsonwebtoken": "^9.0.2",
-        "keyword-extractor": "^0.0.28",
         "mariadb": "^3.2.2",
         "marked": "^12.0.2",
         "mocha": "^10.8.2",
@@ -88,7 +90,6 @@
         "morgan": "^1.10.0",
         "nodemailer": "^6.9.9",
         "nodemon": "^3.0.1",
-        "pathfinding": "^0.4.18",
         "peer": "^1.0.2",
         "peerjs": "^1.5.2",
         "prom-client": "^15.1.2",

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

@@ -1,4 +1,4 @@
-import { adminGuard, authMiddleware } from '../../server/auth.js';
+import { adminGuard } from '../../server/auth.js';
 import { loggerFactory } from '../../server/logger.js';
 import { CoreController } from './core.controller.js';
 import express from 'express';
@@ -7,6 +7,7 @@ const logger = loggerFactory(import.meta);
 
 const CoreRouter = (options) => {
   const router = express.Router();
+  const authMiddleware = options.authMiddleware;
   router.post(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
   router.post(`/`, authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
   router.get(`/:id`, authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));

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

@@ -21,7 +21,12 @@ const DefaultController = {
   },
   get: async (req, res, options) => {
     try {
-      const result = await DefaultService.get(req, res, options);
+      const { page, limit } = req.query;
+      const result = await DefaultService.get(
+        { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },
+        res,
+        options,
+      );
       return res.status(200).json({
         status: 'success',
         data: result,

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

@@ -1,4 +1,3 @@
-import { authMiddleware } from '../../server/auth.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DefaultController } from './default.controller.js';
 import express from 'express';
@@ -7,9 +6,14 @@ const logger = loggerFactory(import.meta);
 
 const DefaultRouter = (options) => {
   const router = express.Router();
+  const authMiddleware = options.authMiddleware;
   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(
+    `/:id`,
+    // authMiddleware,
+    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));

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

@@ -13,7 +13,16 @@ const DefaultService = {
     /** @type {import('./default.model.js').DefaultModel} */
     const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Default;
     if (req.params.id) return await Default.findById(req.params.id);
-    return await Default.find();
+    const { query, page = 1, limit = 10, sort = { updatedAt: -1 } } = req.query;
+    const queryPayload = query ? JSON.parse(query) : {};
+    const skip = (page - 1) * limit;
+    const [data, total] = await Promise.all([
+      Default.find(queryPayload).sort(sort).limit(limit).skip(skip),
+      Default.countDocuments(queryPayload),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
   },
   put: async (req, res, options) => {
     /** @type {import('./default.model.js').DefaultModel} */

package/src/api/document/document.controller.js

@@ -0,0 +1,66 @@
+import { loggerFactory } from '../../server/logger.js';
+import { DocumentService } from './document.service.js';
+const logger = loggerFactory(import.meta);
+
+const DocumentController = {
+  post: async (req, res, options) => {
+    try {
+      return res.status(200).json({
+        status: 'success',
+        data: await DocumentService.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 DocumentService.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 DocumentService.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,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await DocumentService.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,
+      });
+    }
+  },
+};
+
+export { DocumentController };

package/src/api/document/document.model.js

@@ -0,0 +1,51 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const DocumentSchema = new Schema(
+  {
+    userId: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+    },
+    location: { type: String },
+    title: { type: String },
+    tags: [{ type: String }],
+    fileId: {
+      type: Schema.Types.ObjectId,
+      ref: 'File',
+    },
+    mdFileId: {
+      type: Schema.Types.ObjectId,
+      ref: 'File',
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+const DocumentModel = model('Document', DocumentSchema);
+
+const ProviderSchema = DocumentSchema;
+
+const DocumentDto = {
+  populate: {
+    file: () => {
+      return {
+        path: 'fileId',
+        model: 'File',
+        select: '_id name mimetype',
+      };
+    },
+    user: () => {
+      return {
+        path: 'userId',
+        model: 'User',
+        select: '_id email username',
+      };
+    },
+  },
+};
+
+export { DocumentSchema, DocumentModel, ProviderSchema, DocumentDto };

package/src/api/document/document.router.js

@@ -0,0 +1,24 @@
+import { loggerFactory } from '../../server/logger.js';
+import { DocumentController } from './document.controller.js';
+import express from 'express';
+import fs from 'fs-extra';
+const logger = loggerFactory(import.meta);
+
+const DocumentRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(`/:id`, authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
+  router.post(`/`, authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
+  router.get(`/public`, async (req, res) => await DocumentController.get(req, res, options));
+  router.get(`/:id`, authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
+  router.get(`/`, authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
+  router.put(`/:id`, authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
+  router.put(`/`, authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
+  router.delete(`/:id`, authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
+  router.delete(`/`, authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = DocumentRouter;
+
+export { ApiRouter, DocumentRouter };

package/src/api/document/document.service.js

@@ -0,0 +1,125 @@
+import { loggerFactory } from '../../server/logger.js';
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DocumentDto } from './document.model.js';
+import { uniqueArray } from '../../client/components/core/CommonJs.js';
+import { getBearerToken, verifyJWT } from '../../server/auth.js';
+import { isValidObjectId } from 'mongoose';
+
+const logger = loggerFactory(import.meta);
+
+const DocumentService = {
+  post: async (req, res, options) => {
+    /** @type {import('./document.model.js').DocumentModel} */
+    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+
+    switch (req.params.id) {
+      default:
+        req.body.userId = req.auth.user._id;
+        return await new Document(req.body).save();
+    }
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./document.model.js').DocumentModel} */
+    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+    /** @type {import('../user/user.model.js').UserModel} */
+    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.User;
+
+    if (req.path.startsWith('/public') && req.query['tags']) {
+      const publisherUsers = await User.find({ $or: [{ role: 'admin' }, { role: 'moderator' }] });
+
+      const token = getBearerToken(req);
+      let user;
+      if (token) user = verifyJWT(token, options);
+
+      const queryPayload = {
+        userId: {
+          $in: publisherUsers.map((p) => p._id).concat(user?.role && user.role !== 'guest' ? [user._id] : []),
+        },
+        tags: {
+          // $in: uniqueArray(['public'].concat(req.query['tags'].split(','))),
+          $all: uniqueArray(['public'].concat(req.query['tags'].split(','))),
+        },
+        ...(req.query.cid
+          ? {
+              _id: {
+                $in: req.query.cid.split(',').filter((cid) => isValidObjectId(cid)),
+              },
+            }
+          : undefined),
+      };
+      logger.info('queryPayload', queryPayload);
+      // sort in descending (-1) order by length
+      const sort = { createdAt: -1 };
+      const limit = req.query.limit ? parseInt(req.query.limit, 10) : 6;
+      const skip = req.query.skip ? parseInt(req.query.skip, 10) : 0;
+
+      return await Document.find(queryPayload)
+        .sort(sort)
+        .limit(limit)
+        .skip(skip)
+        .populate(DocumentDto.populate.file())
+        .populate(user && user.role !== 'guest' ? DocumentDto.populate.user() : null);
+    }
+
+    switch (req.params.id) {
+      default:
+        return await Document.find({
+          userId: req.auth.user._id,
+          ...(req.params.id ? { _id: req.params.id } : undefined),
+        }).populate(DocumentDto.populate.file());
+    }
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./document.model.js').DocumentModel} */
+    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+    /** @type {import('../file/file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+
+    switch (req.params.id) {
+      default: {
+        const document = await Document.findOne({ _id: req.params.id });
+        if (!document) throw new Error('document not found');
+
+        if (document.userId.toString() !== req.auth.user._id) throw new Error('invalid user');
+
+        if (document.mdFileId) {
+          const file = await File.findOne({ _id: document.mdFileId });
+          if (file) await File.findByIdAndDelete(document.mdFileId);
+        }
+
+        if (document.fileId) {
+          const file = await File.findOne({ _id: document.fileId });
+          if (file) await File.findByIdAndDelete(document.fileId);
+        }
+
+        return await Document.findByIdAndDelete(req.params.id);
+      }
+    }
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./document.model.js').DocumentModel} */
+    const Document = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Document;
+    /** @type {import('../file/file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+
+    switch (req.params.id) {
+      default: {
+        const document = await Document.findOne({ _id: req.params.id });
+        if (!document) throw new Error(`Document not found`);
+
+        if (document.mdFileId) {
+          const file = await File.findOne({ _id: document.mdFileId });
+          if (file) await File.findByIdAndDelete(document.mdFileId);
+        }
+
+        if (document.fileId) {
+          const file = await File.findOne({ _id: document.fileId });
+          if (file) await File.findByIdAndDelete(document.fileId);
+        }
+        return await Document.findByIdAndUpdate(req.params.id, req.body);
+      }
+    }
+  },
+};
+
+export { DocumentService };

package/src/api/file/file.controller.js

@@ -20,7 +20,21 @@ const FileController = {
   get: async (req, res, options) => {
     try {
       const result = await FileService.get(req, res, options);
-      if (result instanceof Buffer) return res.status(200).end(result);
+      if (result instanceof Buffer) {
+        if (
+          process.env.NODE_ENV === 'development' ||
+          req.hostname === options.host ||
+          (options.origins && options.origins.find((o) => o.match(req.hostname)))
+        ) {
+          res.set('Cross-Origin-Resource-Policy', 'cross-origin');
+          return res.status(200).end(result);
+        }
+        return res.status(403).json({
+          status: 'error',
+          message: 'Forbidden',
+        });
+      }
+
       return res.status(200).json({
         status: 'success',
         data: result,

package/src/api/file/file.router.js

@@ -1,4 +1,4 @@
-import { adminGuard, authMiddleware } from '../../server/auth.js';
+import { adminGuard } from '../../server/auth.js';
 import { loggerFactory } from '../../server/logger.js';
 import { FileController } from './file.controller.js';
 import express from 'express';
@@ -6,6 +6,7 @@ const logger = loggerFactory(import.meta);
 
 const FileRouter = (options) => {
   const router = express.Router();
+  const authMiddleware = options.authMiddleware;
   router.post(`/:id`, authMiddleware, async (req, res) => await FileController.post(req, res, options));
   router.post(`/`, authMiddleware, async (req, res) => await FileController.post(req, res, options));
   router.get(`/blob/:id`, async (req, res) => await FileController.get(req, res, options));

package/src/api/test/test.router.js

@@ -1,4 +1,3 @@
-import { authMiddleware } from '../../server/auth.js';
 import { loggerFactory } from '../../server/logger.js';
 import { TestController } from './test.controller.js';
 import express from 'express';
@@ -7,6 +6,7 @@ const logger = loggerFactory(import.meta);
 
 const TestRouter = (options) => {
   const router = express.Router();
+  const authMiddleware = options.authMiddleware;
   router.post(`/:id`, async (req, res) => await TestController.post(req, res, options));
   router.post(`/`, authMiddleware, async (req, res) => await TestController.post(req, res, options));
   router.get(`/:id`, async (req, res) => await TestController.get(req, res, options));