sea-dev 1.0.0

package/packages/widget-ng/src/lib/services/api-client.service.ts

@@ -0,0 +1,715 @@
+import { Injectable, signal, computed, inject } from "@angular/core";
+import {
+  Observable,
+  throwError,
+  catchError,
+  map,
+  tap,
+  retry,
+  timer,
+  switchMap,
+  of,
+} from "rxjs";
+import { SeaWidgetConfigService } from "./config.service";
+import type {
+  Submission,
+  SubmissionData,
+  UploadResult,
+  ApiError,
+  Document,
+} from "../models/submission.model";
+
+/**
+ * API Client service for Sea.dev widget
+ * Handles all HTTP requests with reactive state management
+ */
+@Injectable({
+  providedIn: "root",
+})
+export class SeaApiClientService {
+  private readonly config = inject(SeaWidgetConfigService);
+
+  // Reactive state with signals
+  private readonly _submissions = signal<Submission[]>([]);
+  private readonly _loading = signal<boolean>(false);
+  private readonly _error = signal<ApiError | null>(null);
+  private _lastFilters?: {
+    formId?: string;
+    dealId?: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+  };
+
+  // Public read-only signals
+  readonly submissions = this._submissions.asReadonly();
+  readonly loading = this._loading.asReadonly();
+  readonly error = this._error.asReadonly();
+
+  // Computed values
+  readonly hasSubmissions = computed(() => this._submissions().length > 0);
+  readonly hasError = computed(() => this._error() !== null);
+
+  /**
+   * Get a single submission by ID
+   */
+  getSubmission(id: string): Observable<Submission> {
+    return this.request<Submission>(`/v2/submissions/${id}`, {
+      method: "GET",
+    }).pipe(
+      tap((submission) => {
+        // Update cache if submission exists
+        const current = this._submissions();
+        const index = current.findIndex((s) => s.id === id);
+        if (index >= 0) {
+          const updated = [...current];
+          updated[index] = submission;
+          this._submissions.set(updated);
+        } else {
+          this._submissions.set([...current, submission]);
+        }
+      }),
+    );
+  }
+
+  /**
+   * Get submission data with form groups and extracted values
+   */
+  getSubmissionData(id: string): Observable<SubmissionData> {
+    this.debug("[API] getSubmissionData called for:", id);
+    return this.request<SubmissionData>(`/v2/submissions/${id}/data`, {
+      method: "GET",
+    }).pipe(
+      tap((data) => {
+        this.debug("[API] Submission data loaded:", data);
+      }),
+    );
+  }
+
+  /**
+   * List submissions with optional filters
+   */
+  listSubmissions(filters?: {
+    formId?: string;
+    dealId?: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+  }): Observable<Submission[]> {
+    // Store filters for future refresh
+    if (filters) {
+      this._lastFilters = filters;
+    }
+
+    const params = new URLSearchParams();
+    if (filters?.formId) params.append("formId", filters.formId);
+    if (filters?.dealId) params.append("dealId", filters.dealId);
+    if (filters?.status) params.append("status", filters.status);
+    if (filters?.limit) params.append("limit", filters.limit.toString());
+    if (filters?.offset) params.append("offset", filters.offset.toString());
+
+    const queryString = params.toString();
+    const url = queryString
+      ? `/v2/submissions?${queryString}`
+      : "/v2/submissions";
+
+    return this.request<Submission[]>(url, {
+      method: "GET",
+    }).pipe(
+      tap((submissions) => {
+        this.debug(
+          "[API] Loaded submissions:",
+          submissions.map((s) => ({
+            id: s.id,
+            status: s.status,
+            documentsCount: s.documents?.length ?? 0,
+            fieldsCount: s.fields?.length ?? 0,
+            hasDocuments: !!s.documents,
+            hasFields: !!s.fields,
+          })),
+        );
+        this._submissions.set(submissions);
+      }),
+    );
+  }
+
+  /**
+   * Refresh submissions using last used filters
+   */
+  refreshSubmissions(): Observable<Submission[]> {
+    return this.listSubmissions(this._lastFilters);
+  }
+
+  /**
+   * Create a new submission
+   */
+  createSubmission(data: {
+    formId?: string;
+    dealId?: string;
+    name?: string;
+  }): Observable<Submission> {
+    const { name, ...createData } = data;
+
+    return this.request<Submission>("/v2/submissions", {
+      method: "POST",
+      body: JSON.stringify(createData),
+    }).pipe(
+      // If name is provided, chain an update request
+      switchMap((submission) => {
+        if (name) {
+          return this.updateSubmission(submission.id, { name }).pipe(
+            map((updated) => ({ ...submission, ...updated })),
+          );
+        }
+        return of(submission);
+      }),
+      tap((submission) => {
+        this._submissions.set([...this._submissions(), submission]);
+      }),
+    );
+  }
+
+  /**
+   * Update submission metadata
+   */
+  updateSubmission(
+    submissionId: string,
+    data: { name?: string; summary?: string },
+  ): Observable<Submission> {
+    return this.request<Submission>(`/v2/submissions/${submissionId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data),
+    }).pipe(
+      tap((submission) => {
+        const current = this._submissions();
+        const index = current.findIndex((s) => s.id === submissionId);
+        if (index >= 0) {
+          const updated = [...current];
+          updated[index] = submission;
+          this._submissions.set(updated);
+        }
+      }),
+    );
+  }
+
+  /**
+   * Update a submission field
+   */
+  updateSubmissionField(
+    submissionId: string,
+    itemId: string,
+    value: unknown,
+  ): Observable<Submission> {
+    return this.request<Submission>(
+      `/v2/submissions/${submissionId}/items/${itemId}`,
+      {
+        method: "POST",
+        body: JSON.stringify({ value }),
+      },
+    ).pipe(
+      tap((submission) => {
+        const current = this._submissions();
+        const index = current.findIndex((s) => s.id === submissionId);
+        if (index >= 0) {
+          const updated = [...current];
+          updated[index] = submission;
+          this._submissions.set(updated);
+        }
+      }),
+    );
+  }
+
+  /**
+   * Get submission processing status
+   */
+  getSubmissionStatus(
+    submissionId: string,
+  ): Observable<{ status: "pending" | "done" }> {
+    return this.request<{ status: "pending" | "done" }>(
+      `/v2/submissions/${submissionId}/status`,
+      {
+        method: "GET",
+      },
+    );
+  }
+
+  /**
+   * Update submission status (e.g., draft -> final)
+   */
+  updateSubmissionStatus(
+    submissionId: string,
+    status: string,
+  ): Observable<Submission> {
+    this.debug("[API] updateSubmissionStatus called:", {
+      submissionId,
+      status,
+    });
+    const normalizedStatus = status === "finalised" ? "final" : status;
+    return this.request<Submission>(`/v2/submissions/${submissionId}/status`, {
+      method: "POST",
+      body: JSON.stringify({ status: normalizedStatus }),
+    }).pipe(
+      tap((submission) => {
+        this.debug("[API] updateSubmissionStatus response:", submission);
+        const current = this._submissions();
+        const index = current.findIndex((s) => s.id === submissionId);
+        if (index >= 0) {
+          const updated = [...current];
+          updated[index] = submission;
+          this._submissions.set(updated);
+        }
+      }),
+      catchError((error) => {
+        console.error("[API] updateSubmissionStatus error:", error);
+        return throwError(() => error);
+      }),
+    );
+  }
+
+  /**
+   * Submit field feedback for incorrect extraction
+   */
+  submitFieldFeedback(
+    submissionId: string,
+    submissionItemId: string,
+    extractedValue: unknown,
+    correctedValue: string,
+    feedback: string,
+  ): Observable<void> {
+    this.debug("[API] submitFieldFeedback called:", {
+      submissionId,
+      submissionItemId,
+      extractedValue,
+      correctedValue,
+      feedback,
+    });
+
+    return this.request<void>(
+      `/v2/submissions/${submissionId}/items/${submissionItemId}/corrections`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          extractedValue,
+          correctedValue: correctedValue || null,
+          feedback: feedback || null,
+        }),
+      },
+    ).pipe(
+      tap(() => {
+        this.debug("[API] Field feedback submitted successfully");
+      }),
+      catchError((error) => {
+        console.error("[API] submitFieldFeedback error:", error);
+        return throwError(() => error);
+      }),
+    );
+  }
+
+  /**
+   * Update a submission item value
+   */
+  updateSubmissionItemValue(
+    submissionId: string,
+    submissionItemId: string,
+    value: unknown,
+  ): Observable<void> {
+    this.debug("[API] updateSubmissionItemValue called:", {
+      submissionId,
+      submissionItemId,
+      value,
+    });
+
+    return this.request<void>(
+      `/v2/submissions/${submissionId}/items/${submissionItemId}`,
+      {
+        method: "POST",
+        body: JSON.stringify({ value }),
+      },
+    ).pipe(
+      tap(() => {
+        this.debug("[API] Submission item value updated successfully");
+      }),
+      catchError((error) => {
+        console.error("[API] updateSubmissionItemValue error:", error);
+        return throwError(() => error);
+      }),
+    );
+  }
+
+  /**
+   * Upload a document to a submission and start extraction
+   */
+  uploadDocument(
+    submissionId: string,
+    file: File,
+    model: string = "general",
+    onProgress?: (progress: number) => void,
+  ): Observable<UploadResult> {
+    const formData = new FormData();
+    formData.append("files", file);
+    formData.append("model", model);
+
+    const apiKey = this.config.apiKey();
+    if (!apiKey) {
+      return throwError(
+        () =>
+          ({
+            code: "NO_API_KEY",
+            message: "API key not configured",
+          }) as ApiError,
+      );
+    }
+
+    const baseUrl = this.config.apiBaseUrl();
+    const url = `${baseUrl}/v2/submissions/${submissionId}/extractions`;
+
+    this._loading.set(true);
+    this._error.set(null);
+
+    return new Observable<UploadResult>((observer) => {
+      const xhr = new XMLHttpRequest();
+
+      xhr.upload.addEventListener("progress", (event) => {
+        if (event.lengthComputable && onProgress) {
+          const progress = (event.loaded / event.total) * 100;
+          onProgress(progress);
+        }
+      });
+
+      xhr.addEventListener("load", () => {
+        this._loading.set(false);
+        if (xhr.status >= 200 && xhr.status < 300) {
+          try {
+            const response = JSON.parse(xhr.responseText);
+            this.debug("[API] Upload response:", response);
+            observer.next({
+              documentId: response.extractions?.[0]?.id || "unknown",
+              url: "",
+              name: file.name,
+              size: file.size,
+            });
+            observer.complete();
+          } catch (e) {
+            console.error("[API] Upload parse error:", e);
+            observer.error({
+              code: "PARSE_ERROR",
+              message: "Failed to parse upload response",
+            } as ApiError);
+          }
+        } else {
+          console.error("[API] Upload failed:", xhr.status, xhr.responseText);
+          observer.error({
+            code: "UPLOAD_FAILED",
+            message: `Upload failed with status ${xhr.status}`,
+          } as ApiError);
+        }
+      });
+
+      xhr.addEventListener("error", () => {
+        this._loading.set(false);
+        observer.error({
+          code: "NETWORK_ERROR",
+          message: "Network error during upload",
+        } as ApiError);
+      });
+
+      xhr.open("POST", url);
+      xhr.setRequestHeader("Authorization", `Bearer ${apiKey}`);
+      xhr.send(formData);
+
+      // Teardown: abort XHR on unsubscribe
+      return () => {
+        try {
+          if (xhr.readyState !== XMLHttpRequest.DONE) {
+            xhr.abort();
+            this._loading.set(false);
+          }
+        } catch {
+          // no-op
+        }
+      };
+    });
+  }
+
+  /**
+   * Delete a document from a submission
+   */
+  deleteDocument(submissionId: string, documentId: string): Observable<void> {
+    return this.request<void>(
+      `/v2/submissions/${submissionId}/documents/${documentId}`,
+      {
+        method: "DELETE",
+      },
+    );
+  }
+
+  /**
+   * Get documents for a submission
+   */
+  getDocuments(submissionId: string): Observable<Document[]> {
+    return this.request<{ documents: Document[] }>(
+      `/v2/submissions/${submissionId}/documents`,
+      {
+        method: "GET",
+      },
+    ).pipe(map((response) => response.documents));
+  }
+
+  /**
+   * Get all deals
+   */
+  getDeals(): Observable<any[]> {
+    return this.request<any[]>("/v2/deals", {
+      method: "GET",
+    });
+  }
+
+  /**
+   * Get all forms
+   */
+  getForms(): Observable<any[]> {
+    return this.request<any[]>("/v2/forms", {
+      method: "GET",
+    });
+  }
+
+  /**
+   * Get field correction history for a submission item
+   */
+  getFieldCorrections(submissionId: string, itemId: string): Observable<any[]> {
+    return this.request<any[]>(
+      `/v2/submissions/${submissionId}/items/${itemId}/corrections`,
+      {
+        method: "GET",
+      },
+    );
+  }
+
+  /**
+   * Clear all cached data
+   */
+  clearCache(): void {
+    this._submissions.set([]);
+    this._error.set(null);
+  }
+
+  /**
+   * Core HTTP request method with auth, error handling, and retries
+   */
+  private request<T>(endpoint: string, options: RequestInit): Observable<T> {
+    const apiKey = this.config.apiKey();
+    if (!apiKey) {
+      return throwError(
+        () =>
+          ({
+            code: "NO_API_KEY",
+            message: "API key not configured",
+          }) as ApiError,
+      );
+    }
+
+    const baseUrl = this.config.apiBaseUrl();
+    const url = `${baseUrl}${endpoint}`;
+
+    this.debug("[API] Making request:", {
+      method: options.method,
+      url,
+      endpoint,
+      body: options.body,
+    });
+
+    this._loading.set(true);
+    this._error.set(null);
+
+    return new Observable<T>((observer) => {
+      // Normalize and merge headers using the Headers API to support all shapes
+      const headers = new Headers(options.headers as HeadersInit | undefined);
+      // Only set Authorization if caller hasn't provided one
+      if (!headers.has("Authorization")) {
+        headers.set("Authorization", `Bearer ${apiKey}`);
+      }
+
+      // Set JSON content-type only when it appears to be JSON and caller hasn't specified one
+      if (
+        options.body &&
+        typeof options.body === "string" &&
+        !headers.has("Content-Type") &&
+        /^(\s*[{\[])/.test(options.body)
+      ) {
+        headers.set("Content-Type", "application/json");
+      }
+
+      // Abort support: tie fetch to both an external signal (if provided)
+      // and this observable's unsubscription lifecycle
+      const controller = new AbortController();
+      const externalSignal = options.signal as AbortSignal | undefined;
+      if (externalSignal) {
+        if (externalSignal.aborted) controller.abort();
+        else
+          externalSignal.addEventListener("abort", () => controller.abort(), {
+            once: true,
+          });
+      }
+
+      fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal,
+      })
+        .then(async (response) => {
+          this.debug("[API] Response received:", {
+            status: response.status,
+            statusText: response.statusText,
+            ok: response.ok,
+            url: response.url,
+          });
+
+          if (!response.ok) {
+            const error = await this.parseError(response);
+            console.error("[API] Response error:", error);
+            throw error;
+          }
+
+          // Handle empty responses
+          if (
+            response.status === 204 ||
+            response.headers.get("content-length") === "0"
+          ) {
+            return null as T;
+          }
+
+          return response.json() as Promise<T>;
+        })
+        .then((data) => {
+          this.debug("[API] Request successful, data:", data);
+          this._loading.set(false);
+          observer.next(data);
+          observer.complete();
+        })
+        .catch((error) => {
+          if (error?.name === "AbortError") {
+            // Treat abort as a non-retryable, non-error signal for consumers
+            this.debug("[API] Request aborted");
+            this._loading.set(false);
+            // Do not call observer.error on abort; just complete
+            observer.complete();
+            return;
+          }
+          console.error("[API] Request failed:", error);
+          this._loading.set(false);
+          this._error.set(error);
+          observer.error(error);
+        });
+
+      // Teardown: abort fetch on unsubscribe
+      return () => {
+        try {
+          controller.abort();
+          this._loading.set(false);
+        } catch {
+          // no-op
+        }
+      };
+    }).pipe(
+      retry({
+        count: 2,
+        delay: (error, retryCount) => {
+          // Only retry on network errors or 5xx errors
+          if (error?.name === "AbortError") {
+            // never retry aborts
+            return throwError(() => error);
+          }
+          const rawCode = String(error.code ?? "");
+          const normalizedCode = rawCode.startsWith("HTTP_")
+            ? rawCode.slice(5)
+            : rawCode;
+          if (
+            error.code === "NETWORK_ERROR" ||
+            normalizedCode.startsWith("5")
+          ) {
+            return timer(retryCount * 1000);
+          }
+          return throwError(() => error);
+        },
+      }),
+      catchError((error) => {
+        this._error.set(error);
+        return throwError(() => error);
+      }),
+    );
+  }
+
+  /**
+   * Upload file to signed URL with progress tracking
+   */
+  private uploadToSignedUrl(
+    url: string,
+    file: File,
+    onProgress?: (progress: number) => void,
+  ): Observable<void> {
+    return new Observable<void>((observer) => {
+      const xhr = new XMLHttpRequest();
+
+      xhr.upload.addEventListener("progress", (event) => {
+        if (event.lengthComputable && onProgress) {
+          const progress = (event.loaded / event.total) * 100;
+          onProgress(progress);
+        }
+      });
+
+      xhr.addEventListener("load", () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          observer.next();
+          observer.complete();
+        } else {
+          observer.error({
+            code: "UPLOAD_FAILED",
+            message: `Upload failed with status ${xhr.status}`,
+          } as ApiError);
+        }
+      });
+
+      xhr.addEventListener("error", () => {
+        observer.error({
+          code: "NETWORK_ERROR",
+          message: "Network error during upload",
+        } as ApiError);
+      });
+
+      xhr.open("PUT", url);
+      xhr.setRequestHeader("Content-Type", file.type);
+      xhr.send(file);
+    });
+  }
+
+  /**
+   * Parse error response
+   */
+  private async parseError(response: Response): Promise<ApiError> {
+    try {
+      const body = await response.json();
+      return {
+        code: body.code || `HTTP_${response.status}`,
+        message: body.message || response.statusText,
+        details: body.details,
+      };
+    } catch {
+      return {
+        code: `HTTP_${response.status}`,
+        message: response.statusText || "Unknown error",
+      };
+    }
+  }
+
+  /** Convenience: gated debug logger */
+  private debug(...args: unknown[]): void {
+    try {
+      if (this.config.debug()) {
+        // eslint-disable-next-line no-console
+        console.log(...args);
+      }
+    } catch {
+      // ignore
+    }
+  }
+}