underpost 2.7.1 → 2.7.2

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

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

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

package/src/api/test/test.controller.js

@@ -1,59 +1,59 @@
-import { loggerFactory } from '../../server/logger.js';
-import { TestService } from './test.service.js';
-
-const logger = loggerFactory(import.meta);
-
-const TestController = {
-  post: async (req, res, options) => {
-    try {
-      return res.status(200).json({
-        status: 'success',
-        data: await TestService.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 TestService.get(req, res, options);
-      if (result)
-        return res.status(200).json({
-          status: 'success',
-          data: result,
-        });
-      else
-        return res.status(400).json({
-          status: 'error',
-        });
-    } 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 TestService.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 { TestController };
+import { loggerFactory } from '../../server/logger.js';
+import { TestService } from './test.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const TestController = {
+  post: async (req, res, options) => {
+    try {
+      return res.status(200).json({
+        status: 'success',
+        data: await TestService.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 TestService.get(req, res, options);
+      if (result)
+        return res.status(200).json({
+          status: 'success',
+          data: result,
+        });
+      else
+        return res.status(400).json({
+          status: 'error',
+        });
+    } 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 TestService.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 { TestController };

package/src/api/test/test.model.js

@@ -1,14 +1,14 @@
-import { Schema, model, Types } from 'mongoose';
-
-// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
-
-const TestSchema = new Schema({
-  testId: { type: String, required: true, immutable: true },
-  value: { type: String, required: true, immutable: true },
-});
-
-const TestModel = model('Test', TestSchema);
-
-const ProviderSchema = TestSchema;
-
-export { TestSchema, TestModel, ProviderSchema };
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const TestSchema = new Schema({
+  testId: { type: String, required: true, immutable: true },
+  value: { type: String, required: true, immutable: true },
+});
+
+const TestModel = model('Test', TestSchema);
+
+const ProviderSchema = TestSchema;
+
+export { TestSchema, TestModel, ProviderSchema };

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

@@ -1,21 +1,21 @@
-import { authMiddleware } from '../../server/auth.js';
-import { loggerFactory } from '../../server/logger.js';
-import { TestController } from './test.controller.js';
-import express from 'express';
-
-const logger = loggerFactory(import.meta);
-
-const TestRouter = (options) => {
-  const router = express.Router();
-  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));
-  router.get(`/`, async (req, res) => await TestController.get(req, res, options));
-  router.delete(`/:id`, async (req, res) => await TestController.delete(req, res, options));
-  router.delete(`/`, async (req, res) => await TestController.delete(req, res, options));
-  return router;
-};
-
-const ApiRouter = TestRouter;
-
-export { ApiRouter, TestRouter };
+import { authMiddleware } from '../../server/auth.js';
+import { loggerFactory } from '../../server/logger.js';
+import { TestController } from './test.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const TestRouter = (options) => {
+  const router = express.Router();
+  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));
+  router.get(`/`, async (req, res) => await TestController.get(req, res, options));
+  router.delete(`/:id`, async (req, res) => await TestController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await TestController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = TestRouter;
+
+export { ApiRouter, TestRouter };

package/src/api/test/test.service.js

@@ -1,35 +1,35 @@
-import validator from 'validator';
-import { loggerFactory } from '../../server/logger.js';
-import { TestModel } from './test.model.js';
-import { getYouTubeID, validatePassword } from '../../client/components/core/CommonJs.js';
-
-const logger = loggerFactory(import.meta);
-
-const TestService = {
-  post: async (req, res, options) => {
-    switch (req.params.id) {
-      default:
-        break;
-    }
-  },
-  get: async (req, res, options) => {
-    switch (req.params.id) {
-      case 'verify-email':
-        return validator.isEmail(req.query.email);
-      case 'youtube-id':
-        return getYouTubeID(req.query.url);
-      case 'is-strong-password':
-        return validatePassword(req.query.password);
-
-      default:
-    }
-  },
-  delete: async (req, res, options) => {
-    switch (req.params.id) {
-      default:
-        break;
-    }
-  },
-};
-
-export { TestService };
+import validator from 'validator';
+import { loggerFactory } from '../../server/logger.js';
+import { TestModel } from './test.model.js';
+import { getYouTubeID, validatePassword } from '../../client/components/core/CommonJs.js';
+
+const logger = loggerFactory(import.meta);
+
+const TestService = {
+  post: async (req, res, options) => {
+    switch (req.params.id) {
+      default:
+        break;
+    }
+  },
+  get: async (req, res, options) => {
+    switch (req.params.id) {
+      case 'verify-email':
+        return validator.isEmail(req.query.email);
+      case 'youtube-id':
+        return getYouTubeID(req.query.url);
+      case 'is-strong-password':
+        return validatePassword(req.query.password);
+
+      default:
+    }
+  },
+  delete: async (req, res, options) => {
+    switch (req.params.id) {
+      default:
+        break;
+    }
+  },
+};
+
+export { TestService };

package/src/api/user/user.build.js

@@ -0,0 +1,16 @@
+import fs from 'fs-extra';
+import { faBase64Png, getBufferPngText } from '../../server/client-icons.js';
+
+process.exit(0);
+
+fs.writeFileSync(
+  './tmp/api-user-invalid-token.png',
+  await getBufferPngText({ text: 'Invalid token', textColor: '#ff0000' }),
+  'utf8',
+);
+fs.writeFileSync(
+  './tmp/api-user-recover.png',
+  Buffer.from(faBase64Png('rotate-left', 50, 50, '#ffffff'), 'base64'),
+  'utf8',
+);
+fs.writeFileSync('./tmp/api-user-check.png', Buffer.from(faBase64Png('check', 50, 50), 'base64'), 'utf8');

package/src/api/user/user.controller.js

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