@smartsamurai/krapi-sdk/src/http-clients/backup-http-client.ts

KRAPI TypeScript SDK - Easy-to-use client SDK for connecting to self-hosted KRAPI servers (like Appwrite SDK)

/**
 * Backup HTTP Client for KRAPI SDK
 * 
 * HTTP-based backup operations for frontend applications.
 * Provides backup creation, listing, restoration, and deletion.
 * 
 * @module http-clients/backup-http-client
 * @example
 * const client = new BackupHttpClient({ baseUrl: 'https://api.example.com' });
 * const backup = await client.createProjectBackup('project-id', { password: 'encryption-key' });
 */
import { BackupMetadata } from "../backup-service";
import { ApiResponse, PaginatedResponse } from "../core";

import { BaseHttpClient } from "./base-http-client";

/**
 * Backup HTTP Client
 * 
 * HTTP client for backup operations.
 * 
 * @class BackupHttpClient
 * @extends {BaseHttpClient}
 */
export class BackupHttpClient extends BaseHttpClient {
  /**
   * Create a project backup
   * 
   * @param {string} projectId - Project ID
   * @param {Object} [options] - Backup options
   * @param {string} [options.description] - Backup description
   * @param {string} [options.password] - Encryption password
   * @returns {Promise<ApiResponse<BackupMetadata & { password: string }>>} Backup metadata with password
   */
  async createProjectBackup(
    projectId: string,
    options?: {
      description?: string;
      password?: string;
      includeFiles?: boolean;
    }
  ): Promise<ApiResponse<BackupMetadata & { password: string }>> {
    return this.post<BackupMetadata & { password: string }>(
      `/projects/${projectId}/backup`,
      options || {}
    );
  }

  /**
   * Create a system backup
   * 
   * @param {Object} [options] - Backup options
   * @param {string} [options.description] - Backup description
   * @param {string} [options.password] - Encryption password
   * @returns {Promise<ApiResponse<BackupMetadata & { password: string }>>} Backup metadata with password
   */
  async createSystemBackup(
    options?: {
      description?: string;
      password?: string;
    }
  ): Promise<ApiResponse<BackupMetadata & { password: string }>> {
    return this.post<BackupMetadata & { password: string }>(
      "/backup/system",
      options || {}
    );
  }

  /**
   * List backups
   * 
   * @param {Object} [options] - Query options
   * @param {string} [options.type] - Backup type ('project' | 'system')
   * @param {string} [options.projectId] - Project ID (for project backups)
   * @param {number} [options.limit] - Maximum number of results
   * @param {number} [options.offset] - Number of results to skip
   * @returns {Promise<PaginatedResponse<BackupMetadata>>} List of backups
   */
  async list(
    options?: {
      type?: "project" | "system";
      projectId?: string;
      limit?: number;
      offset?: number;
    }
  ): Promise<PaginatedResponse<BackupMetadata>> {
    const params = new URLSearchParams();
    if (options?.type) params.append("type", options.type);
    if (options?.projectId) params.append("project_id", options.projectId);
    if (options?.limit) params.append("limit", options.limit.toString());
    if (options?.offset) params.append("offset", options.offset.toString());

    const url = options?.projectId
      ? `/projects/${options.projectId}/backups?${params.toString()}`
      : `/backups?${params.toString()}`;

    return this.getPaginated<BackupMetadata>(url);
  }

  /**
   * Get backup details
   * 
   * @param {string} backupId - Backup ID
   * @returns {Promise<ApiResponse<BackupMetadata>>} Backup metadata
   */
  async getBackup(backupId: string): Promise<ApiResponse<BackupMetadata>> {
    return this.get<BackupMetadata>(`/backups/${backupId}`);
  }

  /**
   * Delete a backup
   * 
   * @param {string} backupId - Backup ID
   * @returns {Promise<ApiResponse<{ success: boolean }>>} Delete result
   */
  async deleteBackup(backupId: string): Promise<ApiResponse<{ success: boolean }>> {
    return this.delete<{ success: boolean }>(`/backups/${backupId}`);
  }

  /**
   * Restore from backup
   * 
   * @param {string} backupId - Backup ID
   * @param {Object} [options] - Restore options
   * @param {string} [options.password] - Backup encryption password
   * @param {string} [options.targetProjectId] - Target project ID (for project backups)
   * @param {boolean} [options.overwrite] - Whether to overwrite existing data
   * @returns {Promise<ApiResponse<{ success: boolean; message?: string }>>} Restore result
   */
  async restore(
    backupId: string,
    options?: {
      password?: string;
      targetProjectId?: string;
      overwrite?: boolean;
    }
  ): Promise<ApiResponse<{ success: boolean; message?: string }>> {
    return this.post<{ success: boolean; message?: string }>(
      `/backups/${backupId}/restore`,
      options || {}
    );
  }
}