@visionfi/desktop-sdk/src/clients/package/PackageClient.ts

Desktop SDK for VisionFI Cloud Run services with Azure AD authentication

/**
 * Package Client - handles package-related operations in Desktop SDK
 * Copyright (c) 2024-2025 VisionFI. All Rights Reserved.
 */

import { AxiosInstance } from 'axios';
import { 
  PackageInfo, 
  CreatePackageOptions, 
  CreatePackageResponse, 
  ListPackagesOptions, 
  ListPackagesResponse, 
  PackageAuditHistoryResponse, 
  ExternalReferencesOptions, 
  ExternalReferencesResponse,
  VisionFiError
} from '@visionfi/core';
import { DocumentClient } from './DocumentClient.js';
import { ProcessingClient } from './ProcessingClient.js';

export class PackageClient {
  private apiClient: AxiosInstance;
  readonly documents: DocumentClient;
  readonly processing: ProcessingClient;

  constructor(apiClient: AxiosInstance) {
    this.apiClient = apiClient;
    this.documents = new DocumentClient(apiClient);
    this.processing = new ProcessingClient(apiClient);
  }

  /**
   * Create a new package
   */
  async create(options: CreatePackageOptions): Promise<CreatePackageResponse> {
    try {
      const response = await this.apiClient.post('/operations/packages', options);
      return response.data;
    } catch (error) {
      throw this.handleError(error, 'Failed to create package');
    }
  }

  /**
   * List packages with optional filters
   */
  async list(options?: ListPackagesOptions): Promise<ListPackagesResponse> {
    try {
      const response = await this.apiClient.get('/operations/packages', { params: options });
      return response.data;
    } catch (error) {
      throw this.handleError(error, 'Failed to list packages');
    }
  }

  /**
   * Get package details
   */
  async get(packageId: string): Promise<PackageInfo> {
    try {
      const response = await this.apiClient.get(`/operations/packages/${packageId}`);
      return response.data;
    } catch (error) {
      throw this.handleError(error, 'Failed to get package');
    }
  }

  /**
   * Get package audit history
   */
  async getAuditHistory(packageId: string, limit?: number): Promise<PackageAuditHistoryResponse> {
    try {
      const params = limit ? { limit } : {};
      const response = await this.apiClient.get(`/operations/packages/${packageId}/audit`, { params });
      return response.data;
    } catch (error) {
      throw this.handleError(error, 'Failed to get package audit history');
    }
  }

  /**
   * Add external references to a package
   */
  async addExternalReferences(packageId: string, options: ExternalReferencesOptions): Promise<ExternalReferencesResponse> {
    try {
      const response = await this.apiClient.post(`/operations/packages/${packageId}/external-references`, options);
      return response.data;
    } catch (error) {
      throw this.handleError(error, 'Failed to add external references');
    }
  }

  /**
   * Remove external references from a package
   */
  async removeExternalReferences(packageId: string, options: ExternalReferencesOptions): Promise<ExternalReferencesResponse> {
    try {
      const response = await this.apiClient.delete(`/operations/packages/${packageId}/external-references`, { data: options });
      return response.data;
    } catch (error) {
      throw this.handleError(error, 'Failed to remove external references');
    }
  }

  /**
   * Handle errors consistently
   */
  private handleError(error: any, defaultMessage: string): Error {
    if (error instanceof VisionFiError) {
      return error;
    }

    const message = error.response?.data?.message || error.message || defaultMessage;
    const statusCode = error.response?.status;
    const code = error.response?.data?.code || 'unknown_error';

    return new VisionFiError(message, statusCode, code);
  }
}