underpost 2.7.1 → 2.7.2

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

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

package/src/api/core/core.service.js

@@ -1,29 +1,29 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
-import { loggerFactory } from '../../server/logger.js';
-
-const logger = loggerFactory(import.meta);
-
-const CoreService = {
-  post: async (req, res, options) => {
-    /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
-    return await new Core(req.body).save();
-  },
-  get: async (req, res, options) => {
-    /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
-    return await Core.findById(req.params.id);
-  },
-  put: async (req, res, options) => {
-    /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
-    return await Core.findByIdAndUpdate(req.params.id, req.body);
-  },
-  delete: async (req, res, options) => {
-    /** @type {import('./core.model.js').CoreModel} */
-    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
-    return await Core.findByIdAndDelete(req.params.id);
-  },
-};
-
-export { CoreService };
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+const CoreService = {
+  post: async (req, res, options) => {
+    /** @type {import('./core.model.js').CoreModel} */
+    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
+    return await new Core(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./core.model.js').CoreModel} */
+    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
+    return await Core.findById(req.params.id);
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./core.model.js').CoreModel} */
+    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
+    return await Core.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./core.model.js').CoreModel} */
+    const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.Core;
+    return await Core.findByIdAndDelete(req.params.id);
+  },
+};
+
+export { CoreService };

package/src/api/crypto/crypto.controller.js

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

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

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

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

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

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

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