@sparkvault/sdk-mobile 0.1.3

package/src/vaults.ts

@@ -0,0 +1,271 @@
+import type { MobileHttpClient } from './http.js';
+import type {
+  CreateVaultRequest,
+  CreateVaultResponse,
+  ListVaultsResponse,
+  UnsealVaultRequest,
+  UnsealVaultResponse,
+  UpdateVaultRequest,
+  UpdateVaultResponse,
+  Vault,
+} from './types.js';
+import { validateVaultId } from './validation.js';
+
+export interface SharingConfig {
+  vault_id: string;
+  public_sharing_enabled: boolean;
+  all_ingots_public: boolean;
+  session_length_seconds: number | null;
+  enabled_at: number | null;
+}
+
+export class MobileVaultsClient {
+  private readonly http: MobileHttpClient;
+
+  constructor(http: MobileHttpClient) {
+    this.http = http;
+  }
+
+  async create(request: CreateVaultRequest): Promise<CreateVaultResponse> {
+    const response = await this.http.post<CreateVaultResponse>('/vaults', request);
+    return response.data;
+  }
+
+  async list(options?: {
+    status?: 'sealed' | 'unsealed';
+    limit?: number;
+    cursor?: string;
+  }): Promise<ListVaultsResponse> {
+    const params = new URLSearchParams();
+    if (options?.status) params.append('status', options.status);
+    if (options?.limit) params.append('limit', options.limit.toString());
+    if (options?.cursor) params.append('cursor', options.cursor);
+
+    const query = params.toString();
+    const response = await this.http.get<ListVaultsResponse>(query ? `/vaults?${query}` : '/vaults');
+    return response.data;
+  }
+
+  async get(vaultId: string): Promise<Vault> {
+    validateVaultId(vaultId);
+    const response = await this.http.get<Vault>(`/vaults/${vaultId}`);
+    return response.data;
+  }
+
+  async update(vaultId: string, request: UpdateVaultRequest): Promise<UpdateVaultResponse> {
+    validateVaultId(vaultId);
+    const response = await this.http.put<UpdateVaultResponse>(`/vaults/${vaultId}`, request);
+    return response.data;
+  }
+
+  async delete(vaultId: string): Promise<void> {
+    validateVaultId(vaultId);
+    await this.http.delete(`/vaults/${vaultId}`);
+  }
+
+  async unseal(vaultId: string, request: UnsealVaultRequest): Promise<UnsealVaultResponse> {
+    validateVaultId(vaultId);
+    const response = await this.http.post<UnsealVaultResponse>(`/vaults/${vaultId}/unseal`, request);
+    return response.data;
+  }
+
+  async seal(vaultId: string): Promise<void> {
+    validateVaultId(vaultId);
+    await this.http.post(`/vaults/${vaultId}/seal`);
+  }
+
+  async getSharingConfig(vaultId: string): Promise<SharingConfig> {
+    validateVaultId(vaultId);
+    const response = await this.http.get<SharingConfig>(`/vaults/${vaultId}/sharing`);
+    return response.data;
+  }
+
+  async enableSharing(
+    vaultId: string,
+    vmk: string,
+    options?: {
+      all_ingots_public?: boolean;
+      session_length_seconds?: number;
+    }
+  ): Promise<{
+    vault_id: string;
+    public_sharing_enabled: boolean;
+    all_ingots_public: boolean;
+    session_length_seconds: number;
+    enabled_at: number;
+  }> {
+    validateVaultId(vaultId);
+    const response = await this.http.post<{
+      vault_id: string;
+      public_sharing_enabled: boolean;
+      all_ingots_public: boolean;
+      session_length_seconds: number;
+      enabled_at: number;
+    }>(`/vaults/${vaultId}/sharing/enable`, {
+      vmk,
+      all_ingots_public: options?.all_ingots_public,
+      session_length_seconds: options?.session_length_seconds,
+    });
+    return response.data;
+  }
+
+  async disableSharing(vaultId: string): Promise<{
+    vault_id: string;
+    public_sharing_enabled: false;
+    disabled_at: number;
+    shares_revoked: number;
+  }> {
+    validateVaultId(vaultId);
+    const response = await this.http.post<{
+      vault_id: string;
+      public_sharing_enabled: false;
+      disabled_at: number;
+      shares_revoked: number;
+    }>(`/vaults/${vaultId}/sharing/disable`);
+    return response.data;
+  }
+
+  async updateSharingConfig(
+    vaultId: string,
+    config: {
+      all_ingots_public?: boolean;
+      session_length_seconds?: number;
+    }
+  ): Promise<{
+    vault_id: string;
+    public_sharing_enabled: boolean;
+    all_ingots_public: boolean;
+    session_length_seconds: number;
+    updated_at: number;
+  }> {
+    validateVaultId(vaultId);
+    const response = await this.http.put<{
+      vault_id: string;
+      public_sharing_enabled: boolean;
+      all_ingots_public: boolean;
+      session_length_seconds: number;
+      updated_at: number;
+    }>(`/vaults/${vaultId}/sharing`, config);
+    return response.data;
+  }
+
+  async getAccessLogRetention(vaultId: string): Promise<{
+    vault_id: string;
+    access_log_retention_seconds: number;
+  }> {
+    validateVaultId(vaultId);
+    const response = await this.http.get<{
+      vault_id: string;
+      access_log_retention_seconds: number;
+    }>(`/vaults/${vaultId}/access-log-retention`);
+    return response.data;
+  }
+
+  async updateAccessLogRetention(
+    vaultId: string,
+    retentionSeconds: number
+  ): Promise<{
+    vault_id: string;
+    access_log_retention_seconds: number;
+    updated_at: number;
+  }> {
+    validateVaultId(vaultId);
+    const response = await this.http.put<{
+      vault_id: string;
+      access_log_retention_seconds: number;
+      updated_at: number;
+    }>(`/vaults/${vaultId}/access-log-retention`, {
+      access_log_retention_seconds: retentionSeconds,
+    });
+    return response.data;
+  }
+
+  async getUploadConfig(vaultId: string): Promise<{
+    vault_id: string;
+    public_upload_enabled: boolean;
+    upload_url: string | null;
+    max_size_bytes: number | null;
+    notification_email: string | null;
+    enabled_at: number | null;
+  }> {
+    validateVaultId(vaultId);
+    const response = await this.http.get<{
+      vault_id: string;
+      public_upload_enabled: boolean;
+      upload_url: string | null;
+      max_size_bytes: number | null;
+      notification_email: string | null;
+      enabled_at: number | null;
+    }>(`/vaults/${vaultId}/upload`);
+    return response.data;
+  }
+
+  async enableUpload(
+    vaultId: string,
+    vmk: string | null,
+    options?: {
+      max_size_bytes?: number;
+      notification_email?: string;
+    }
+  ): Promise<{
+    vault_id: string;
+    public_upload_enabled: boolean;
+    upload_url: string;
+    max_size_bytes: number;
+    notification_email: string | null;
+    enabled_at: number;
+  }> {
+    validateVaultId(vaultId);
+    const response = await this.http.post<{
+      vault_id: string;
+      public_upload_enabled: boolean;
+      upload_url: string;
+      max_size_bytes: number;
+      notification_email: string | null;
+      enabled_at: number;
+    }>(`/vaults/${vaultId}/upload/enable`, {
+      vmk,
+      max_size_bytes: options?.max_size_bytes ?? null,
+      notification_email: options?.notification_email ?? null,
+    });
+    return response.data;
+  }
+
+  async disableUpload(vaultId: string): Promise<{
+    vault_id: string;
+    public_upload_enabled: false;
+    disabled_at: number;
+  }> {
+    validateVaultId(vaultId);
+    const response = await this.http.post<{
+      vault_id: string;
+      public_upload_enabled: false;
+      disabled_at: number;
+    }>(`/vaults/${vaultId}/upload/disable`);
+    return response.data;
+  }
+
+  async updateUploadConfig(
+    vaultId: string,
+    config: {
+      max_size_bytes?: number;
+      notification_email?: string | null;
+    }
+  ): Promise<{
+    vault_id: string;
+    public_upload_enabled: boolean;
+    max_size_bytes: number;
+    notification_email: string | null;
+    updated_at: number;
+  }> {
+    validateVaultId(vaultId);
+    const response = await this.http.put<{
+      vault_id: string;
+      public_upload_enabled: boolean;
+      max_size_bytes: number;
+      notification_email: string | null;
+      updated_at: number;
+    }>(`/vaults/${vaultId}/upload`, config);
+    return response.data;
+  }
+}