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

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

@@ -1,210 +0,0 @@
-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

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