@underpostnet/underpost 2.7.9

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.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);
+    return await Default.find();
+  },
+  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 await Default.deleteMany();
+  },
+};
+
+export { DefaultService };

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

@@ -0,0 +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 {
+      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

@@ -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,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(`/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,80 @@
+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;
+  },
+  hex: (raw = '') => {
+    return Buffer.from(raw, 'utf8').toString('hex');
+    // reverse hexValue.toString()
+  },
+  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.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 };

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

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

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

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

package/src/api/instance/instance.router.js

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

package/src/api/instance/instance.service.js

@@ -0,0 +1,48 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { InstanceDto } from './instance.model.js';
+
+const logger = loggerFactory(import.meta);
+
+const InstanceService = {
+  post: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Instance;
+    return await new Instance(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Instance;
+
+    /** @type {import('../user/user.model.js').UserModel} */
+    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.User;
+
+    const user = await User.findOne({
+      _id: req.auth.user._id,
+    });
+    switch (req.params.id) {
+      default:
+        switch (user.role) {
+          case 'admin':
+            if (req.params.id) return await Instance.findById(req.params.id);
+            return await Instance.find().populate(InstanceDto.populate.get());
+
+          default:
+            return await Instance.find({ userId: req.auth.user._id }).populate(InstanceDto.populate.get());
+        }
+    }
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Instance;
+    return await Instance.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Instance;
+    if (req.params.id) return await Instance.findByIdAndDelete(req.params.id);
+    else return await await Instance.deleteMany();
+  },
+};
+
+export { InstanceService };