@underpostnet/underpost 2.7.9

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

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

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

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

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

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

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

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

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

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

package/src/api/user/user.model.js

@@ -0,0 +1,65 @@
+import { Schema, model } from 'mongoose';
+import validator from 'validator';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const userRoleEnum = ['admin', 'moderator', 'user', 'guest'];
+
+const UserSchema = new Schema(
+  {
+    email: {
+      type: String,
+      trim: true,
+      lowercase: true,
+      unique: true,
+      required: 'Email address is required',
+      validate: [validator.isEmail, 'Please fill a valid email address'],
+      // match: [/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/, 'Please fill a valid email address'],
+    },
+    emailConfirmed: { type: Boolean, default: false },
+    recoverTimeOut: { type: Date },
+    lastLoginDate: { type: Date },
+    failedLoginAttempts: { type: Number, default: 0 },
+    password: { type: String, trim: true, required: 'Password is required' },
+    username: { type: String, trim: true, unique: true, required: 'Username is required' },
+    role: { type: String, enum: userRoleEnum, default: 'guest' },
+    profileImageId: { type: Schema.Types.ObjectId, ref: 'File' },
+    phoneNumbers: [
+      {
+        type: { type: String, enum: ['office', 'home', 'private'], number: { type: String } },
+      },
+    ],
+    publicKey: {
+      type: [
+        {
+          type: Schema.Types.ObjectId,
+          ref: 'Crypto',
+        },
+      ],
+      default: [],
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+const UserModel = model('User', UserSchema);
+
+const ProviderSchema = UserSchema;
+
+const UserDto = {
+  select: {
+    get: () => {
+      return { _id: 1, username: 1, email: 1, role: 1, emailConfirmed: 1, profileImageId: 1 };
+    },
+    getAll: () => {
+      return { _id: 1, name: 1 };
+    },
+  },
+  auth: {
+    payload: (user) => ({ _id: user._id.toString(), role: user.role }),
+  },
+};
+
+export { UserSchema, UserModel, userRoleEnum, ProviderSchema, UserDto };

package/src/api/user/user.router.js

@@ -0,0 +1,345 @@
+import { authMiddleware } from '../../server/auth.js';
+import fs from 'fs-extra';
+import { loggerFactory } from '../../server/logger.js';
+import { UserController } from './user.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const UserRouter = (options) => {
+  const router = express.Router();
+
+  (async () => {
+    options.png = {
+      buffer: {
+        'invalid-token': fs.readFileSync(`./src/client/public/default/assets/mailer/api-user-invalid-token.png`),
+        recover: fs.readFileSync(`./src/client/public/default/assets/mailer/api-user-recover.png`),
+        check: fs.readFileSync(`./src/client/public/default/assets/mailer/api-user-check.png`),
+      },
+      header: (res) => {
+        res.set('Content-Type', 'image/png');
+      },
+    };
+  })();
+
+  router.post(`/mailer/:id`, authMiddleware, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.post(req, res, options);
+  });
+
+  router.get(`/mailer/:id`, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.get(req, res, options);
+  });
+
+  router.get(`/email/:email`, authMiddleware, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.get(req, res, options);
+  });
+
+  router.post(`/:id`, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.post(req, res, options);
+  });
+
+  // #swagger.start
+
+  /*
+    #swagger.auto = false
+    #swagger.tags = ['user']
+    #swagger.summary = 'Log in'
+    #swagger.description = 'This endpoint get a JWT for authenticated user'
+    #swagger.path = '/user/auth'
+    #swagger.method = 'post'
+    #swagger.produces = ['application/json']
+    #swagger.consumes = ['application/json']
+
+    #swagger.requestBody = {
+      in: 'body',
+      description: 'User data',
+      required: true,
+      content: {
+          'application/json': {
+              schema: {
+                  $ref: '#/components/schemas/userLogInRequest'
+              }  
+          }
+      }
+    }
+    
+    #swagger.responses[200] = {
+      description: 'User created successfully',
+      content: {
+          'application/json': {
+              schema: {
+                $ref: '#/components/schemas/userResponse'
+              }
+          }           
+      }
+    }   
+
+    #swagger.responses[400] = {
+      description: 'Bad request. Please check the input data',
+      content: {
+          'application/json': {
+              schema: {
+                $ref: '#/components/schemas/userBadRequestResponse'
+              }
+          }           
+      }
+    } 
+  */
+
+  // #swagger.end
+
+  router.post(`/`, async (req, res) => {
+    /*
+      #swagger.auto = false
+      #swagger.tags = ['user']
+      #swagger.summary = 'Create user'
+      #swagger.description = 'This endpoint will create a new user account'
+      #swagger.path = '/user'
+      #swagger.method = 'post'
+      #swagger.produces = ['application/json']
+      #swagger.consumes = ['application/json']
+
+      #swagger.requestBody = {
+        in: 'body',
+        description: 'User data',
+        required: true,
+        content: {
+            'application/json': {
+                schema: {
+                    $ref: '#/components/schemas/userRequest'
+                }  
+            }
+        }
+      }
+      
+      #swagger.responses[200] = {
+        description: 'User created successfully',
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/userResponse'
+                }
+            }           
+        }
+      }   
+
+      #swagger.responses[400] = {
+        description: 'Bad request. Please check the input data',
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/userBadRequestResponse'
+                }
+            }           
+        }
+      } 
+    */
+    return await UserController.post(req, res, options);
+  });
+
+  router.get(`/recover/:id`, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.get(req, res, options);
+  });
+
+  router.get(`/:id`, authMiddleware, async (req, res) => {
+    /*
+      #swagger.auto = false
+      #swagger.tags = ['user']
+      #swagger.summary = 'Get user data by ID'
+      #swagger.description = 'This endpoint get user data by ID'
+      #swagger.path = '/user/{id}'
+      #swagger.method = 'get'
+      #swagger.produces = ['application/json']
+      #swagger.consumes = ['application/json']
+      #swagger.security = [{
+        'bearerAuth': []
+      }] 
+
+      #swagger.parameters['id'] = {
+          in: 'path',
+          description: 'User ID',
+          required: true,
+          type: 'string'
+      }
+
+      #swagger.responses[200] = {
+        description: 'get user successfully',
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/userGetResponse'
+                }
+            }           
+        }
+      }   
+
+      #swagger.responses[400] = {
+        description: 'Bad request. Please check the input data',
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/userBadRequestResponse'
+                }
+            }           
+        }
+      } 
+    */
+    return await UserController.get(req, res, options);
+  });
+  router.get(`/`, authMiddleware, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.get(req, res, options);
+  });
+  router.put(`/recover/:id`, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.put(req, res, options);
+  });
+  router.put(`/profile-image/:id`, authMiddleware, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.put(req, res, options);
+  });
+  router.put(`/:id`, authMiddleware, async (req, res) => {
+    /*
+      #swagger.auto = false
+      #swagger.tags = ['user']
+      #swagger.summary = 'Update user data by ID'
+      #swagger.description = 'This endpoint will update user data by ID'
+      #swagger.path = '/user/{id}'
+      #swagger.method = 'put'
+      #swagger.produces = ['application/json']
+      #swagger.consumes = ['application/json']
+      #swagger.security = [{
+        'bearerAuth': []
+      }] 
+      
+      #swagger.parameters['id'] = {
+          in: 'path',
+          description: 'User ID',
+          required: true,
+          type: 'string'
+      }
+
+      #swagger.requestBody = {
+        in: 'body',
+        description: 'User data',
+        required: true,
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/userRequest'
+                }  
+            }
+        }
+      }
+
+      #swagger.responses[200] = {
+        description: 'User updated successfully',
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/userUpdateResponse'
+                }
+            }           
+        }
+      }   
+
+      #swagger.responses[400] = {
+        description: 'Bad request. Please check the input data',
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/userBadRequestResponse'
+                }
+            }           
+        }
+      } 
+    */
+    return await UserController.put(req, res, options);
+  });
+  router.put(`/`, authMiddleware, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.put(req, res, options);
+  });
+
+  router.delete(`/:id`, authMiddleware, async (req, res) => {
+    /*
+      #swagger.auto = false
+      #swagger.tags = ['user']
+      #swagger.summary = 'Delete user data by ID'
+      #swagger.description = 'This endpoint deletes user data by ID, the path ID must match with the ID of the authenticated user'
+      #swagger.path = '/user/{id}'
+      #swagger.method = 'delete'
+      #swagger.produces = ['application/json']
+      #swagger.consumes = ['application/json']
+      #swagger.security = [{
+        'bearerAuth': []
+      }] 
+
+      #swagger.parameters['id'] = {
+          in: 'path',
+          description: 'User ID',
+          required: true,
+          type: 'string'
+      }
+
+      #swagger.responses[200] = {
+        description: 'get user successfully',
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/userGetResponse'
+                }
+            }           
+        }
+      }   
+
+      #swagger.responses[400] = {
+        description: 'Bad request. Please check the input data',
+        content: {
+            'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/userBadRequestResponse'
+                }
+            }           
+        }
+      } 
+    */
+    return await UserController.delete(req, res, options);
+  });
+
+  router.delete(`/`, authMiddleware, async (req, res) => {
+    /*  
+      #swagger.ignore = true
+    */
+    return await UserController.delete(req, res, options);
+  });
+
+  return router;
+};
+
+const ApiRouter = UserRouter;
+
+export { ApiRouter, UserRouter };