feat(model): add endpoint session

Author: masb0ymas

src/controllers/Session/controller.ts

@@ -0,0 +1,68 @@
+import { Request, Response } from 'express'
+import routes from 'routes/public'
+import asyncHandler from 'helpers/asyncHandler'
+import Authorization from 'middlewares/Authorization'
+import BuildResponse from 'modules/Response/BuildResponse'
+import SessionService from 'controllers/Session/service'
+
+routes.get(
+  '/session',
+  asyncHandler(async function getAll(req: Request, res: Response) {
+    const data = await SessionService.getAll(req)
+    const buildResponse = BuildResponse.get(data)
+
+    return res.status(200).json(buildResponse)
+  })
+)
+
+routes.get(
+  '/session/:id',
+  asyncHandler(async function getOne(req: Request, res: Response) {
+    const { id } = req.getParams()
+
+    const data = await SessionService.getOne(id)
+    const buildResponse = BuildResponse.get({ data })
+
+    return res.status(200).json(buildResponse)
+  })
+)
+
+routes.post(
+  '/session',
+  Authorization,
+  asyncHandler(async function createData(req: Request, res: Response) {
+    const formData = req.getBody()
+
+    const data = await SessionService.create(formData)
+    const buildResponse = BuildResponse.created({ data })
+
+    return res.status(201).json(buildResponse)
+  })
+)
+
+routes.put(
+  '/session/:id',
+  Authorization,
+  asyncHandler(async function updateData(req: Request, res: Response) {
+    const { id } = req.getParams()
+    const formData = req.getBody()
+
+    const data = await SessionService.update(id, formData)
+    const buildResponse = BuildResponse.updated({ data })
+
+    return res.status(200).json(buildResponse)
+  })
+)
+
+routes.delete(
+  '/session/:id',
+  Authorization,
+  asyncHandler(async function forceDelete(req: Request, res: Response) {
+    const { id } = req.getParams()
+
+    await SessionService.delete(id)
+    const buildResponse = BuildResponse.deleted({})
+
+    return res.status(200).json(buildResponse)
+  })
+)

src/controllers/Session/schema.ts

@@ -0,0 +1,13 @@
+import * as yup from 'yup'
+
+const create = yup.object().shape({
+  UserId: yup.string().required('user is required'),
+  token: yup.string().required('token is required'),
+  ipAddress: yup.string().nullable(),
+  device: yup.string().nullable(),
+  platform: yup.string().nullable(),
+})
+
+export default {
+  create,
+}

src/controllers/Session/service.ts

@@ -0,0 +1,116 @@
+import { Request } from 'express'
+import models from 'models'
+import ResponseError from 'modules/Response/ResponseError'
+import useValidation from 'helpers/useValidation'
+import PluginSqlizeQuery from 'modules/SqlizeQuery/PluginSqlizeQuery'
+import schema from 'controllers/Session/schema'
+import { SessionAttributes } from 'models/session'
+
+const { Session } = models
+
+class SessionService {
+  /**
+   *
+   * @param req Request
+   */
+  public static async getAll(req: Request) {
+    const { includeCount, order, ...queryFind } = PluginSqlizeQuery.generate(
+      req.query,
+      Session,
+      []
+    )
+
+    const data = await Session.findAll({
+      ...queryFind,
+      order: order.length ? order : [['createdAt', 'desc']],
+    })
+    const total = await Session.count({
+      include: includeCount,
+      where: queryFind.where,
+    })
+
+    return { message: `${total} data has been received.`, data, total }
+  }
+
+  /**
+   *
+   * @param id
+   */
+  public static async getOne(id: string) {
+    const data = await Session.findByPk(id)
+
+    if (!data) {
+      throw new ResponseError.NotFound(
+        'session data not found or has been deleted'
+      )
+    }
+
+    return data
+  }
+
+  /**
+   *
+   * @param UserId
+   * @param token
+   */
+  public static async findByTokenUser(UserId: string, token: string) {
+    const data = await Session.findOne({ where: { UserId, token } })
+
+    if (!data) {
+      throw new ResponseError.NotFound(
+        'the login session has ended, please re-login'
+      )
+    }
+
+    return data
+  }
+
+  /**
+   *
+   * @param formData
+   */
+  public static async create(formData: SessionAttributes) {
+    const value = useValidation(schema.create, formData)
+    const data = await Session.create(value)
+
+    return data
+  }
+
+  /**
+   *
+   * @param id
+   * @param formData
+   */
+  public static async update(id: string, formData: SessionAttributes) {
+    const data = await this.getOne(id)
+
+    const value = useValidation(schema.create, {
+      ...data.toJSON(),
+      ...formData,
+    })
+
+    await data.update(value || {})
+
+    return data
+  }
+
+  /**
+   *
+   * @param UserId
+   * @param token
+   */
+  public static async deleteByTokenUser(UserId: string, token: string) {
+    await Session.destroy({ where: { UserId, token } })
+  }
+
+  /**
+   *
+   * @param id - Force Delete
+   */
+  public static async delete(id: string) {
+    const data = await this.getOne(id)
+    await data.destroy()
+  }
+}
+
+export default SessionService

src/migrations/20210226064711-create-session.js

@@ -0,0 +1,38 @@
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('Sessions', {
+      id: {
+        allowNull: false,
+        primaryKey: true,
+        type: Sequelize.UUID,
+        defaultValue: Sequelize.UUIDV4,
+      },
+      UserId: {
+        type: Sequelize.UUID,
+      },
+      token: {
+        type: Sequelize.TEXT,
+      },
+      ipAddress: {
+        type: Sequelize.STRING,
+      },
+      device: {
+        type: Sequelize.STRING, // Desktop, Mobile, Tablet
+      },
+      platform: {
+        type: Sequelize.STRING, // Android, iOS, Web browser
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+    })
+  },
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('Sessions')
+  },
+}

src/models/index.ts

@@ -2,12 +2,14 @@ import Role from './role'
 import User from './user'
 import UserRole from './userrole'
 import RefreshToken from './refreshtoken'
+import Session from './session'
 
 const models = {
   Role,
   User,
   UserRole,
   RefreshToken,
+  Session,
 }
 
 export default models

src/models/session.ts

@@ -0,0 +1,28 @@
+import { Model, Optional } from 'sequelize'
+import SequelizeAttributes from '../utils/SequelizeAttributes'
+
+import db from './_instance'
+
+export interface SessionAttributes {
+  id?: string
+  UserId: string
+  token: string
+  ipAddress?: string | null
+  device?: string | null
+  platform?: string | null
+  createdAt?: Date
+  updatedAt?: Date
+  deletedAt?: Date | null
+}
+
+interface SessionCreationAttributes extends Optional<SessionAttributes, 'id'> {}
+
+export interface SessionInstance
+  extends Model<SessionAttributes, SessionCreationAttributes>,
+    SessionAttributes {}
+
+const Session = db.sequelize.define<SessionInstance>('Sessions', {
+  ...SequelizeAttributes.Sessions,
+})
+
+export default Session

src/routes/public.ts

@@ -8,3 +8,4 @@ require('controllers/Auth/controller')
 require('controllers/Role/controller')
 require('controllers/User/controller')
 require('controllers/RefreshToken/controller')
+require('controllers/Session/controller')