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

package/src/api/services/auth.service.ts

@@ -0,0 +1,210 @@
+import { mergeWith } from '@camera.ui/common/utils';
+import safeTimers from 'safe-timers';
+import { container, delay, registry } from 'tsyringe';
+
+import { SocketService } from '../websocket/index.js';
+
+import type { Timeout } from 'safe-timers';
+import type { Database } from '../database/index.js';
+import type { ClientData, JwtTokenEncoded, UserData } from '../types/index.js';
+
+const loginSessionMap = new Map<string, Timeout>();
+
+@registry([
+  {
+    token: 'socketService',
+    useValue: delay(() => SocketService),
+  },
+])
+export class AuthService {
+  private dbs: Database;
+  private socketService: SocketService;
+
+  constructor() {
+    this.dbs = container.resolve<Database>('dbs');
+    this.socketService = container.resolve<SocketService>('socketService');
+  }
+
+  public checkToken(token: string): boolean {
+    const { tokens } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    const tokenData = tokens.find((jwtToken) => jwtToken.access_token === token);
+    if (tokenData) {
+      const expireData = tokenData.expires_at;
+      const now = new Date();
+      if (expireData && expireData > now) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public findById(id: string): JwtTokenEncoded | undefined {
+    const { tokens } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    return tokens.find((jwtToken) => jwtToken._id === id);
+  }
+
+  public findByRefreshToken(refresh_token: string): JwtTokenEncoded | undefined {
+    const { tokens } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    return tokens.find((jwtToken) => jwtToken.refresh_token === refresh_token);
+  }
+
+  public findByToken(access_token: string): JwtTokenEncoded | undefined {
+    const { tokens } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    return tokens.find((jwtToken) => jwtToken.access_token === access_token);
+  }
+
+  public clientDataById(id: string): ClientData | undefined {
+    const { clients } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    return clients.find((client) => client._id === id);
+  }
+
+  public clientDataByToken(acces_token: string): ClientData | undefined {
+    const { clients } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    return clients.find((client) => client.access_token === acces_token);
+  }
+
+  public async insert(userData: UserData, clientData?: ClientData): Promise<void> {
+    const { tokens, clients } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    tokens.push(userData);
+
+    if (clientData) {
+      clients.push(clientData);
+    }
+
+    await this.dbs.authDB.put('auth', {
+      tokens,
+      clients,
+    });
+  }
+
+  public async invalidateAll(): Promise<void> {
+    const { tokens } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    tokens.forEach((jwtToken) => this.unauthenticateToken(jwtToken.access_token));
+
+    await this.dbs.authDB.put('auth', {
+      tokens: [],
+      clients: [],
+    });
+  }
+
+  public async invalidateById(id: string): Promise<void> {
+    let { tokens, clients } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+
+    const oldTokens = tokens.filter((jwtToken) => jwtToken._id === id);
+    if (oldTokens.length) {
+      oldTokens.forEach((jwtToken) => this.unauthenticateToken(jwtToken.access_token));
+    }
+
+    tokens = tokens.filter((jwtToken) => jwtToken._id !== id);
+    clients = clients.filter((client) => client._id !== id);
+
+    await this.dbs.authDB.put('auth', {
+      tokens,
+      clients,
+    });
+  }
+
+  public async invalidateByRefreshToken(refresh_token: string): Promise<void> {
+    let { tokens, clients } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    const token = tokens.find((token) => token.refresh_token === refresh_token);
+
+    if (token) {
+      clients = clients.filter((client) => client.access_token !== token.access_token);
+      tokens = tokens.filter((jwtToken) => jwtToken.refresh_token !== refresh_token);
+
+      this.unauthenticateToken(token.access_token);
+    }
+
+    await this.dbs.authDB.put('auth', {
+      tokens,
+      clients,
+    });
+  }
+
+  public async invalidateByToken(access_token: string): Promise<void> {
+    let { tokens, clients } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+
+    tokens = tokens.filter((jwtToken) => jwtToken.access_token !== access_token);
+    clients = clients.filter((client) => client.access_token !== access_token);
+
+    this.unauthenticateToken(access_token);
+
+    await this.dbs.authDB.put('auth', {
+      tokens,
+      clients,
+    });
+  }
+
+  public listTokens(): JwtTokenEncoded[] {
+    const { tokens } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    return tokens;
+  }
+
+  public listClientData(): ClientData[] {
+    const { clients } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+    return clients;
+  }
+
+  public async patchTokenByRefreshToken(refresh_token: string, newJwtToken: JwtTokenEncoded): Promise<void> {
+    const { tokens, clients } = this.dbs.authDB.get('auth') ?? { tokens: [], clients: [] };
+
+    tokens.forEach((jwtToken) => {
+      if (jwtToken.refresh_token === refresh_token) {
+        clients.forEach((clientData) => {
+          if (clientData.access_token === jwtToken.access_token) {
+            clientData.access_token = newJwtToken.access_token;
+          }
+        });
+
+        mergeWith(jwtToken, newJwtToken, (source: any, target: any) => {
+          if (Array.isArray(source)) {
+            return target;
+          }
+        });
+      }
+    });
+
+    await this.dbs.authDB.put('auth', {
+      tokens,
+      clients,
+    });
+  }
+
+  public addSessionTimer(token: string, sessionTimer: number): void {
+    if (sessionTimer > 0) {
+      if (loginSessionMap.has(token)) {
+        this.clearSessionTimer(token);
+        loginSessionMap.delete(token);
+      }
+
+      const sessionTimeout = safeTimers.setTimeout(() => {
+        this.invalidateByToken(token);
+        loginSessionMap.delete(token);
+      }, sessionTimer * 1000);
+
+      loginSessionMap.set(token, sessionTimeout);
+    }
+  }
+
+  public clearSessionTimer(token?: string): void {
+    if (token) {
+      const sessionTimeout = loginSessionMap.get(token);
+      if (sessionTimeout) {
+        safeTimers.clearTimeout(sessionTimeout);
+        loginSessionMap.delete(token);
+      }
+    } else {
+      loginSessionMap.forEach((sessionTimeout) => safeTimers.clearTimeout(sessionTimeout));
+      loginSessionMap.clear();
+    }
+  }
+
+  public refreshSessionTimer(oldToken: string, newToken: string, sessionTimer: number): void {
+    this.clearSessionTimer(oldToken);
+    this.addSessionTimer(newToken, sessionTimer);
+  }
+
+  private unauthenticateToken(token: string): void {
+    this.socketService?.io?.of('/camera.ui').emit('invalidToken', token);
+  }
+}

package/src/api/services/backup.service.ts

@@ -0,0 +1,144 @@
+import { copy, pathExists, readJson, remove, writeJson } from 'fs-extra/esm';
+import { lstat, mkdtemp, writeFile } from 'node:fs/promises';
+import { platform, tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { c, x } from 'tar';
+import { container } from 'tsyringe';
+
+import { ConfigService } from '../../services/config/index.js';
+import { moveFiles } from '../utils/moveFiles.js';
+import { PluginsService } from './plugins.service.js';
+
+import type { MultipartFile } from '@fastify/multipart';
+import type { LoggerService } from '../../services/logger/index.js';
+import type { BackupInfo, BackupStorage, PluginBackupInfo, UiLocalStorage } from '../types/index.js';
+
+export class BackupService {
+  private logger: LoggerService;
+  private configService: ConfigService;
+
+  private pluginsService: PluginsService;
+
+  constructor() {
+    this.logger = container.resolve<LoggerService>('logger');
+    this.configService = container.resolve<ConfigService>('configService');
+
+    this.pluginsService = new PluginsService();
+  }
+
+  public async createBackup(localStorage: Partial<UiLocalStorage> = {}): Promise<BackupStorage> {
+    const timestamp = Date.now();
+    const backupDirectory = await mkdtemp(join(tmpdir(), 'camera.ui-backup-'));
+    const backupFileName = `camera.ui-backup-${timestamp}.tar.gz`;
+    const backupFile = join(backupDirectory, backupFileName);
+
+    this.logger.log('Creating new backup...');
+
+    const plugins = this.pluginsService.listPlugins();
+    const pluginsInfo: PluginBackupInfo[] = plugins.map(
+      (plugin): PluginBackupInfo => ({
+        id: plugin.id,
+        name: plugin.pluginName,
+        version: plugin.info.installedVersion ?? 'latest',
+      }),
+    );
+
+    await copy(this.configService.STORAGE_PATH, join(backupDirectory, 'storage'), {
+      filter: async (filePath: string) => {
+        try {
+          const stat = await lstat(filePath);
+          return stat.isDirectory() || stat.isFile();
+        } catch {
+          return false;
+        }
+      },
+    });
+
+    const info: BackupInfo = {
+      timestamp,
+      platform: platform(),
+      node: process.version,
+      version: ConfigService.VERSION,
+      plugins: pluginsInfo,
+      localStorage: localStorage,
+    };
+
+    // create a camera.ui.backup.json
+    await writeJson(join(backupDirectory, 'camera.ui.backup.json'), info);
+
+    // create a tar with the copied files
+    await c(
+      {
+        portable: true,
+        gzip: true,
+        file: backupFile,
+        cwd: backupDirectory,
+        filter: (filePath, stat) => {
+          if (stat.size > 5e7) {
+            this.logger.warn(`Backup is skipping "${filePath}" because it is larger than 50MB.`);
+            return false;
+          }
+          return true;
+        },
+      },
+      ['storage', 'camera.ui.backup.json'],
+    );
+
+    this.logger.log('Backup was successfully created');
+
+    return {
+      backupDirectory,
+      backupFile,
+      backupFileName,
+    };
+  }
+
+  public async restoreBackup(file: MultipartFile): Promise<any> {
+    const backupDirectory = await mkdtemp(join(tmpdir(), 'cameraui-restore-'));
+    const backupFileName = file.filename;
+    const backupFile = join(backupDirectory, backupFileName);
+    const fileBuffer = await file.toBuffer();
+
+    await writeFile(backupFile, fileBuffer);
+
+    // extract the tar
+    await x({
+      cwd: backupDirectory,
+      file: backupFile,
+    });
+
+    const infoPath = join(backupDirectory, 'camera.ui.backup.json');
+    const storagePath = join(backupDirectory, 'storage');
+
+    if (!(await pathExists(infoPath)) || !(await pathExists(storagePath))) {
+      await remove(backupDirectory);
+      throw new Error('Uploaded file is not a valid camera.ui Backup Archive.');
+    }
+
+    this.logger.attention('Starting backup restore...');
+
+    const infoFile: BackupInfo = await readJson(infoPath);
+
+    this.logger.debug('Backup Archive Information:', infoFile);
+
+    // move the content to desired directories
+    await moveFiles(storagePath, this.configService.STORAGE_PATH, {
+      overwrite: true,
+    });
+
+    await moveFiles(infoPath, join(this.configService.STORAGE_PATH, 'camera.ui.backup.json'), {
+      overwrite: true,
+    });
+
+    // remove tmp
+    await remove(backupDirectory);
+
+    this.logger.log('Backup was successfully restored');
+
+    return infoFile.localStorage;
+  }
+
+  public async removeBackup(backup: BackupStorage): Promise<void> {
+    await remove(backup.backupDirectory);
+  }
+}