@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/src/api/controllers/auth.controller.ts

@@ -0,0 +1,294 @@
+import jwt from 'jsonwebtoken';
+import { container } from 'tsyringe';
+
+import { AuthService } from '../services/auth.service.js';
+import { UsersService } from '../services/users.service.js';
+import { REFRESH_TOKEN } from '../types/index.js';
+import { parseJwt } from '../utils/parse.js';
+
+import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import type { ConfigService } from '../../services/config/index.js';
+import type {
+  AuthLoginRequest,
+  AuthNewLoginRequest,
+  AuthParamsRequest,
+  AuthRefreshRequest,
+  ClientData,
+  JwtPayload,
+  JwtRefreshPayload,
+  JwtRefreshTokenDecoded,
+  JwtTokenClientData,
+  JwtTokenEncoded,
+  JwtTokenResponse,
+  PaginationRequest,
+  UserData,
+} from '../types/index.js';
+
+export class AuthController {
+  private app: FastifyInstance;
+  private configService: ConfigService;
+  private service: AuthService;
+  private userService: UsersService;
+
+  constructor(app: FastifyInstance) {
+    this.app = app;
+    this.configService = container.resolve<ConfigService>('configService');
+    this.service = new AuthService();
+    this.userService = new UsersService();
+  }
+
+  public check(req: FastifyRequest<AuthLoginRequest>, reply: FastifyReply): FastifyReply {
+    try {
+      return reply.code(200).send({
+        status: 'OK',
+      });
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public list(req: FastifyRequest<AuthLoginRequest & PaginationRequest>, reply: FastifyReply): FastifyReply | JwtTokenClientData[] {
+    try {
+      const tokens = this.service.listTokens();
+      const clients = this.service.listClientData();
+
+      const tokensAndClientData: JwtTokenClientData[] = tokens.map((token) => {
+        return {
+          token: token,
+          clientData: clients.find((client) => client.access_token === token.access_token),
+        };
+      });
+
+      return tokensAndClientData;
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async login(req: FastifyRequest<AuthNewLoginRequest>, reply: FastifyReply): Promise<FastifyReply | void> {
+    try {
+      const user = req.locals.user!;
+
+      const payload: JwtPayload = {
+        _id: user._id,
+        // avatar: user.avatar,
+        username: user.username,
+        // role: user.role,
+        rememberMe: user.rememberMe,
+        // firstLogin: user.firstLogin,
+        // singleSession: user.singleSession,
+        sessionTimer: user.sessionTimer,
+      };
+
+      const payloadRefresh: JwtRefreshPayload = {
+        _id: user._id,
+      };
+
+      const access_token = jwt.sign(payload, this.configService.SECRETS.jwtAccessKey, { expiresIn: user.rememberMe ? '100y' : user.sessionTimer });
+      const refresh_token = jwt.sign(payloadRefresh, this.configService.SECRETS.jwtRefreshKey, {
+        expiresIn: user.rememberMe ? '100y' : REFRESH_TOKEN.EXPIRES_IN,
+      });
+
+      if (!user.rememberMe && user.sessionTimer > 0) {
+        this.service.addSessionTimer(access_token, user.sessionTimer);
+      }
+
+      const token: JwtTokenEncoded = {
+        _id: user._id,
+        access_token: access_token,
+        refresh_token: refresh_token,
+        token_type: 'Bearer',
+        expires_in: user.rememberMe ? 100 * 365 * 24 * 60 * 60 : user.sessionTimer,
+        expires_at: user.rememberMe ? new Date((Date.now() / 1000 + 100 * 365 * 24 * 60 * 60) * 1000) : new Date((Date.now() / 1000 + user.sessionTimer) * 1000),
+      };
+
+      const clientData: ClientData = {
+        _id: user._id,
+        access_token: access_token,
+        address: req.ip,
+        device: `${req.useragent?.platform} (${req.useragent?.source.includes('Electron') ? 'camera.ui App' : req.useragent?.browser})`,
+      };
+
+      const userData: UserData = {
+        ...token,
+        username: user.username,
+        avatar: user.avatar,
+        role: user.role,
+        rememberMe: user.rememberMe,
+        firstLogin: user.firstLogin,
+        singleSession: user.singleSession,
+        sessionTimer: user.sessionTimer,
+      };
+
+      if (user.singleSession) {
+        await this.service.invalidateById(user._id);
+      }
+
+      await this.service.insert(userData, clientData);
+
+      return reply.code(201).send(userData);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async logout(req: FastifyRequest, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const authorization = req.headers.authorization?.split(/\s+/);
+      const token = authorization && authorization[0] === 'Bearer' ? authorization[1] : false;
+
+      if (token) {
+        await this.service.invalidateByToken(token);
+        this.service.clearSessionTimer(token);
+
+        this.app.io.of('/camera.ui').emit('invalidToken', token);
+      }
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async logoutByToken(req: FastifyRequest<AuthLoginRequest & AuthParamsRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      let token: JwtTokenEncoded | undefined;
+
+      if (req.query.token) {
+        token = this.service.findByToken(req.query.token);
+      } else {
+        token = this.service.findById(req.params.id);
+      }
+
+      if (!token) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Token not exists',
+        });
+      }
+
+      await this.service.invalidateByToken(token.access_token);
+      this.service.clearSessionTimer(token.access_token);
+
+      this.app.io.of('/camera.ui').emit('invalidToken', token.access_token);
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async logoutAll(req: FastifyRequest<AuthLoginRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const tokens = this.service.listTokens();
+
+      await this.service.invalidateAll();
+      this.service.clearSessionTimer();
+
+      tokens.forEach((token) => {
+        this.app.io.of('/camera.ui').emit('invalidToken', token.access_token);
+      });
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async refresh(req: FastifyRequest<AuthRefreshRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    if (!req.body.refresh_token) {
+      return reply.code(403).send({
+        statusCode: 403,
+        message: 'Refresh Token is required!',
+      });
+    }
+
+    try {
+      const token = this.service.findByRefreshToken(req.body.refresh_token);
+
+      if (!token) {
+        return reply.code(403).send({
+          statusCode: 403,
+          message: 'Refresh token is not in database!',
+        });
+      }
+
+      const user = this.userService.findById(token._id);
+
+      // todo: need this?
+      if (!user) {
+        return reply.code(403).send({
+          statusCode: 403,
+          message: 'User is not in database!',
+        });
+      }
+
+      const refreshToken = parseJwt(req.body.refresh_token) as unknown as JwtRefreshTokenDecoded;
+
+      if (new Date(refreshToken.expires_at).getTime() < new Date().getTime()) {
+        await this.service.invalidateByRefreshToken(token.refresh_token);
+        this.service.clearSessionTimer(token.access_token);
+
+        return reply.code(403).send({
+          statusCode: 403,
+          message: 'Refresh token was expired. Please make a new signin request',
+        });
+      }
+
+      const payload: JwtPayload = {
+        _id: user._id,
+        username: user.username,
+        // avatar: user.avatar,
+        // role: user.role,
+        rememberMe: user.rememberMe,
+        // firstLogin: user.firstLogin,
+        // singleSession: user.singleSession,
+        sessionTimer: user.sessionTimer,
+      };
+
+      const access_token = jwt.sign(payload, this.configService.SECRETS.jwtAccessKey, { expiresIn: user.rememberMe ? '100y' : user.sessionTimer });
+
+      const jwtToken: JwtTokenEncoded = {
+        _id: user._id,
+        access_token: access_token,
+        refresh_token: token.refresh_token,
+        token_type: 'Bearer',
+        expires_in: user.rememberMe ? 100 * 365 * 24 * 60 * 60 : user.sessionTimer,
+        expires_at: user.rememberMe ? new Date((Date.now() / 1000 + 100 * 365 * 24 * 60 * 60) * 1000) : new Date((Date.now() / 1000 + user.sessionTimer) * 1000),
+      };
+
+      const jwtTokenResponse: JwtTokenResponse = {
+        access_token: access_token,
+        refresh_token: token.refresh_token,
+      };
+
+      await this.service.patchTokenByRefreshToken(token.refresh_token, jwtToken);
+      this.service.refreshSessionTimer(token.access_token, access_token, user.sessionTimer);
+
+      return reply.code(200).send(jwtTokenResponse);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+}

package/src/api/controllers/backup.controller.ts

@@ -0,0 +1,72 @@
+import { readFile } from 'node:fs';
+import { container } from 'tsyringe';
+import { BackupService } from '../services/backup.service.js';
+
+import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import type { LoggerService } from '../../services/logger/index.js';
+import type { AuthLoginRequest, BackupCreateRequest, BackupRestoreRequest } from '../types/index.js';
+
+export class BackupController {
+  private app: FastifyInstance;
+  private logger: LoggerService;
+  private service: BackupService;
+
+  constructor(app: FastifyInstance) {
+    this.app = app;
+    this.logger = container.resolve<LoggerService>('logger');
+    this.service = new BackupService();
+  }
+
+  public async download(req: FastifyRequest<AuthLoginRequest & BackupCreateRequest>, reply: FastifyReply): Promise<FastifyReply | void> {
+    try {
+      const backup = await this.service.createBackup(req.body.localStorage);
+
+      readFile(backup.backupFile, (error, fileBuffer) => {
+        if (error) {
+          this.logger.error(error);
+        }
+
+        this.service.removeBackup(backup);
+        reply.send(error ?? fileBuffer);
+      });
+
+      reply.header('Content-Type', 'application/octet-stream');
+      reply.header('Content-Disposition', `attachment; filename=${backup.backupFileName}`);
+
+      return reply;
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async restore(req: FastifyRequest<AuthLoginRequest & BackupRestoreRequest>, reply: FastifyReply): Promise<FastifyReply | void> {
+    try {
+      if (!req.isMultipart()) {
+        throw new Error('No multipart request!');
+      }
+
+      const file = req.body.upload;
+      if (!file) {
+        return reply.code(400).send({
+          statusCode: 400,
+          message: 'No file uploaded',
+        });
+      }
+
+      const localStorage = await this.service.restoreBackup(file);
+
+      // inform main process
+      process.send?.('restored');
+
+      return reply.code(201).send(localStorage);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+}