cyberia 2.8.885

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

@@ -0,0 +1,74 @@
+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 { 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,
+      });
+    } 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,27 @@
+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();
+  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`,
+    // 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));
+  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,40 @@
+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.models.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.models.Default;
+    if (req.params.id) return await Default.findById(req.params.id);
+    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} */
+    const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.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.models.Default;
+    if (req.params.id) return await Default.findByIdAndDelete(req.params.id);
+    else return await Default.deleteMany();
+  },
+};
+
+export { DefaultService };

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,133 @@
+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;
+
+      const data = await Document.find(queryPayload)
+        .sort(sort)
+        .limit(limit)
+        .skip(skip)
+        .populate(DocumentDto.populate.file())
+        .populate(user && user.role !== 'guest' ? DocumentDto.populate.user() : null);
+
+      const lastDoc = await Document.findOne(queryPayload, '_id').sort({ createdAt: 1 });
+      const lastId = lastDoc ? lastDoc._id : null;
+
+      return {
+        data,
+        lastId,
+      };
+    }
+
+    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

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

package/src/api/file/file.model.js

@@ -0,0 +1,19 @@
+import { Schema, model } from 'mongoose';
+
+const FileSchema = new Schema({
+  name: { type: String },
+  data: { type: Buffer },
+  size: { type: Number },
+  encoding: { type: String },
+  tempFilePath: { type: String },
+  truncated: { type: Boolean },
+  mimetype: { type: String },
+  md5: { type: String },
+  cid: { type: String },
+});
+
+const FileModel = model('File', FileSchema);
+
+const ProviderSchema = FileSchema;
+
+export { FileSchema, FileModel, ProviderSchema };

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

@@ -0,0 +1,22 @@
+import { adminGuard } from '../../server/auth.js';
+import { loggerFactory } from '../../server/logger.js';
+import { FileController } from './file.controller.js';
+import express from 'express';
+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));
+  router.get(`/:id`, async (req, res) => await FileController.get(req, res, options));
+  router.get(`/`, async (req, res) => await FileController.get(req, res, options));
+  router.delete(`/:id`, authMiddleware, adminGuard, async (req, res) => await FileController.delete(req, res, options));
+  router.delete(`/`, authMiddleware, adminGuard, async (req, res) => await FileController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = FileRouter;
+
+export { ApiRouter, FileRouter };

package/src/api/file/file.service.js

@@ -0,0 +1,100 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import crypto from 'crypto';
+
+const logger = loggerFactory(import.meta);
+
+const FileFactory = {
+  filesExtract: (req) => {
+    const files = [];
+    if (Array.isArray(req.files.file)) for (const file of req.files.file) files.push(file);
+    else if (Object.keys(req.files).length > 0)
+      for (const keyFile of Object.keys(req.files)) files.push(req.files[keyFile]);
+    return files;
+  },
+  upload: async function (req, File) {
+    const results = FileFactory.filesExtract(req);
+    let index = -1;
+    for (let file of results) {
+      file = await new File(file).save();
+      index++;
+      const [result] = await File.find({
+        _id: file._id,
+      }).select({ _id: 1, name: 1, mimetype: 1 });
+      results[index] = result;
+    }
+    return results;
+  },
+  hex: (raw = '') => {
+    return Buffer.from(raw, 'utf8').toString('hex');
+    // reverse hexValue.toString()
+  },
+  getMymeTypeFromPath: (path) => {
+    switch (path.split('.').pop()) {
+      case 'png':
+        return 'image/png';
+      case 'jpg':
+        return 'image/jpeg';
+      case 'jpeg':
+        return 'image/jpeg';
+      case 'gif':
+        return 'image/gif';
+      case 'svg':
+        return 'image/svg+xml';
+      default:
+        return 'application/octet-stream';
+    }
+  },
+  create: (data = Buffer.from([]), name = '') => {
+    return {
+      name: name,
+      data: data,
+      size: data.length,
+      encoding: '7bit',
+      tempFilePath: '',
+      truncated: false,
+      mimetype: FileFactory.getMymeTypeFromPath(name),
+      md5: crypto.createHash('md5').update(data).digest('hex'),
+      cid: undefined,
+    };
+  },
+};
+
+const FileService = {
+  post: async (req, res, options) => {
+    /** @type {import('./file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+    return await FileFactory.upload(req, File);
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+
+    if (req.path.startsWith('/blob') && req.params.id) {
+      const file = await File.findOne({ _id: req.params.id });
+      res.set('Content-Type', file.mimetype);
+      return Buffer.from(file.data, 'base64');
+    }
+
+    switch (req.params.id) {
+      case 'all':
+        return await File.find();
+
+      default:
+        return await File.find({
+          _id: req.params.id,
+        });
+    }
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./file.model.js').FileModel} */
+    const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+
+    switch (req.params.id) {
+      default:
+        return await File.findByIdAndDelete(req.params.id);
+    }
+  },
+};
+
+export { FileService, FileFactory };