underpost 2.7.1 → 2.7.2

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

@@ -1,31 +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 };
+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 };

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

@@ -1,51 +1,53 @@
-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 {
-      return res.status(200).json({
-        status: 'success',
-        data: await FileService.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 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 };
+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) return res.status(200).end(result);
+      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

@@ -1,19 +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 };
+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

@@ -1,20 +1,21 @@
-import { adminGuard, authMiddleware } 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();
-  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(`/: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 };
+import { adminGuard, authMiddleware } 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();
+  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

@@ -1,70 +1,76 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
-import { loggerFactory } from '../../server/logger.js';
-import crypto from 'crypto';
-
-const logger = loggerFactory(import.meta);
-
-const FileFactory = {
-  upload: async function (req, File) {
-    const results = [];
-    if (!req.files) throw { message: 'not file found' };
-    if (Array.isArray(req.files.file)) for (const file of req.files.file) results.push(await new File(file).save());
-    else if (Object.keys(req.files).length > 0)
-      for (const keyFile of Object.keys(req.files)) results.push(await new File(req.files[keyFile]).save());
-    let index = -1;
-    for (const file of results) {
-      index++;
-      const [result] = await File.find({
-        _id: file._id,
-      }).select({ _id: 1, name: 1, mimetype: 1 });
-      results[index] = result;
-    }
-    return results;
-  },
-  svg: (data = new Buffer(), name = '') => {
-    return {
-      name: name,
-      data: data,
-      size: data.length,
-      encoding: '7bit',
-      tempFilePath: '',
-      truncated: false,
-      mimetype: 'image/svg+xml',
-      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.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.File;
-
-    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.File;
-
-    switch (req.params.id) {
-      default:
-        return await File.findByIdAndDelete(req.params.id);
-    }
-  },
-};
-
-export { FileService, FileFactory };
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import crypto from 'crypto';
+
+const logger = loggerFactory(import.meta);
+
+const FileFactory = {
+  upload: async function (req, File) {
+    const results = [];
+    if (!req.files) throw { message: 'not file found' };
+    if (Array.isArray(req.files.file)) for (const file of req.files.file) results.push(await new File(file).save());
+    else if (Object.keys(req.files).length > 0)
+      for (const keyFile of Object.keys(req.files)) results.push(await new File(req.files[keyFile]).save());
+    let index = -1;
+    for (const file of results) {
+      index++;
+      const [result] = await File.find({
+        _id: file._id,
+      }).select({ _id: 1, name: 1, mimetype: 1 });
+      results[index] = result;
+    }
+    return results;
+  },
+  svg: (data = new Buffer(), name = '') => {
+    return {
+      name: name,
+      data: data,
+      size: data.length,
+      encoding: '7bit',
+      tempFilePath: '',
+      truncated: false,
+      mimetype: 'image/svg+xml',
+      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.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.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.File;
+
+    switch (req.params.id) {
+      default:
+        return await File.findByIdAndDelete(req.params.id);
+    }
+  },
+};
+
+export { FileService, FileFactory };

package/src/api/instance/instance.controller.js

@@ -1,69 +1,69 @@
-import { loggerFactory } from '../../server/logger.js';
-import { InstanceService } from './instance.service.js';
-
-const logger = loggerFactory(import.meta);
-
-const InstanceController = {
-  post: async (req, res, options) => {
-    try {
-      const result = await InstanceService.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 InstanceService.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 InstanceService.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 InstanceService.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 { InstanceController };
+import { loggerFactory } from '../../server/logger.js';
+import { InstanceService } from './instance.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const InstanceController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await InstanceService.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 InstanceService.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 InstanceService.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 InstanceService.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 { InstanceController };

package/src/api/instance/instance.model.js

@@ -1,36 +1,36 @@
-import { Schema, model, Types } from 'mongoose';
-
-// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
-
-const InstanceSchema = new Schema(
-  {
-    deployId: { type: String },
-    host: { type: String },
-    path: { type: String },
-    userId: {
-      type: Schema.Types.ObjectId,
-      ref: 'User',
-    },
-  },
-  {
-    timestamps: true,
-  },
-);
-
-const InstanceDto = {
-  populate: {
-    get: () => {
-      return {
-        path: 'userId',
-        model: 'User',
-        select: '_id email',
-      };
-    },
-  },
-};
-
-const InstanceModel = model('Instance', InstanceSchema);
-
-const ProviderSchema = InstanceSchema;
-
-export { InstanceSchema, InstanceModel, ProviderSchema, InstanceDto };
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const InstanceSchema = new Schema(
+  {
+    deployId: { type: String },
+    host: { type: String },
+    path: { type: String },
+    userId: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+const InstanceDto = {
+  populate: {
+    get: () => {
+      return {
+        path: 'userId',
+        model: 'User',
+        select: '_id email',
+      };
+    },
+  },
+};
+
+const InstanceModel = model('Instance', InstanceSchema);
+
+const ProviderSchema = InstanceSchema;
+
+export { InstanceSchema, InstanceModel, ProviderSchema, InstanceDto };