@freqhole/api-client 0.2.15 → 0.3.1

package/src/FreqholeClient.ts

@@ -6,20 +6,20 @@
 import { z } from "zod";
 import type { Transport, BlobData } from "./transport.js";
 import { HttpTransport } from "./transport.js";
+import { AUTH_ERROR_PATH, toZodError } from "./errors.js";
 import { createAdminMethods } from "./domains/admin.js";
 import { createAppMethods } from "./domains/app.js";
 import { createAuthMethods } from "./domains/auth.js";
+import { createEntitiesMethods } from "./domains/entities.js";
 import { createJobsMethods } from "./domains/jobs.js";
 import { createMusicMethods } from "./domains/music.js";
 import { createUploadMethods } from "./domains/upload.js";
+import { createVideoMethods } from "./domains/video.js";
 import type { CallFn, SafeParseResult } from "./domains/types.js";
 
 // re-export types for consumers
 export type { SafeParseResult } from "./domains/types.js";
 
-// sentinel for 401 detection
-const AUTH_ERROR_PATH = "__auth_expired__";
-
 // ============================================================================
 // FreqholeClient
 // ============================================================================
@@ -28,18 +28,22 @@ export class FreqholeClient {
   public readonly admin: ReturnType<typeof createAdminMethods>;
   public readonly app: ReturnType<typeof createAppMethods>;
   public readonly auth: ReturnType<typeof createAuthMethods>;
+  public readonly entities: ReturnType<typeof createEntitiesMethods>;
   public readonly jobs: ReturnType<typeof createJobsMethods>;
   public readonly music: ReturnType<typeof createMusicMethods>;
   public readonly upload: ReturnType<typeof createUploadMethods>;
+  public readonly video: ReturnType<typeof createVideoMethods>;
 
   constructor(public readonly transport: Transport) {
     const call = this.createCallFn();
     this.admin = createAdminMethods(call);
     this.app = createAppMethods(call);
     this.auth = createAuthMethods(call);
+    this.entities = createEntitiesMethods(call);
     this.jobs = createJobsMethods(transport);
     this.music = createMusicMethods(call);
     this.upload = createUploadMethods(transport);
+    this.video = createVideoMethods(call);
   }
 
   // -------------------------------------------------------------------------
@@ -58,7 +62,14 @@ export class FreqholeClient {
     ): Promise<SafeParseResult<Resp>> => {
       // validate request body for POST/PUT/PATCH
       const isFormData = params instanceof FormData;
-      if (method !== "GET" && method !== "DELETE" && method !== "HEAD" && reqSchema && params && !isFormData) {
+      if (
+        method !== "GET" &&
+        method !== "DELETE" &&
+        method !== "HEAD" &&
+        reqSchema &&
+        params &&
+        !isFormData
+      ) {
         const validated = reqSchema.safeParse(params);
         if (!validated.success) {
           return { success: false, error: validated.error };
@@ -75,51 +86,17 @@ export class FreqholeClient {
       }
 
       // prepare body
-      const body = method !== "GET" && method !== "DELETE" && method !== "HEAD" && params && !isFormData
-        ? JSON.stringify(params)
-        : undefined;
+      const body =
+        method !== "GET" && method !== "DELETE" && method !== "HEAD" && params && !isFormData
+          ? JSON.stringify(params)
+          : undefined;
 
       try {
         const response = await this.transport.request(method, finalPath, body);
 
         // handle errors: status >= 400 OR status 0 (IPC/network failure)
         if (response.status >= 400 || response.status === 0) {
-          // try to extract error details
-          let errorMessage = response.status === 0 ? "connection error" : `HTTP ${response.status}`;
-          let errorCode: string | undefined;
-          try {
-            const errorBody = JSON.parse(response.body);
-            if (errorBody?.error) {
-              errorMessage = response.status === 0
-                ? errorBody.error
-                : `HTTP ${response.status}: ${errorBody.error}`;
-            }
-            if (errorBody?.message) {
-              errorMessage = response.status === 0
-                ? errorBody.message
-                : `HTTP ${response.status}: ${errorBody.message}`;
-            }
-            if (errorBody?.code) {
-              errorCode = errorBody.code;
-            }
-          } catch {
-            // body wasn't JSON
-          }
-
-          const issuePath: (string | number)[] = [];
-          if (response.status === 401) {
-            issuePath.push(AUTH_ERROR_PATH);
-          }
-          if (errorCode) {
-            issuePath.push(errorCode);
-          }
-
-          return {
-            success: false,
-            error: new z.ZodError([
-              { code: "custom", path: issuePath, message: errorMessage },
-            ]),
-          };
+          return { success: false, error: toZodError(response.body, response.status) };
         }
 
         // no response schema (e.g., blob streaming)
@@ -132,21 +109,11 @@ export class FreqholeClient {
 
         // check for GrimoireResponse failure (success: false with errors)
         if (json.success === false) {
-          const errorMessage = json.message || json.errors?.[0]?.detail || "request failed";
-          const errorCode = json.errors?.[0]?.error_type;
-          const issuePath: (string | number)[] = [];
-          if (errorCode === "unauthorized") {
-            issuePath.push(AUTH_ERROR_PATH);
-          }
-          if (errorCode) {
-            issuePath.push(errorCode);
-          }
-          return {
-            success: false,
-            error: new z.ZodError([
-              { code: "custom", path: issuePath, message: errorMessage },
-            ]),
-          };
+          // this used to be silent - a business-logic failure (e.g. "video
+          // not found") would just surface as `null` data to the caller
+          // with no trace anywhere, making it look like a data-wiring bug.
+          console.warn(`[API] ${domain}.${routeName} failed:`, json.message, json.errors);
+          return { success: false, error: toZodError(response.body, response.status) };
         }
 
         const data = json.data ?? json;
@@ -176,9 +143,7 @@ export class FreqholeClient {
         }
         return {
           success: false,
-          error: new z.ZodError([
-            { code: "custom", path: [], message },
-          ]),
+          error: new z.ZodError([{ code: "custom", path: [], message }]),
         };
       }
     };
@@ -236,26 +201,24 @@ export function isAuthError<T>(result: SafeParseResult<T>): boolean {
 
 export function isNetworkError<T>(result: SafeParseResult<T>): boolean {
   if (result.success) return false;
-  return result.error.issues.some(
-    (issue) => {
-      if (issue.code !== "custom") return false;
-      const msg = issue.message.toLowerCase();
-      
-      // HTTP fetch errors
-      if (msg === "failed to fetch" || msg === "network error") return true;
-      
-      // P2P/iroh connection errors - be generous with matching
-      if (msg.includes("connection")) return true; // connection failed, closed, refused, etc
-      if (msg.includes("connect to peer")) return true; // "failed to connect to peer ..."
-      if (msg.includes("federation api error")) return true; // wrapper from p2p_client
-      if (msg.includes("no addressing information")) return true; // iroh: peer has no relay/direct addrs
-      if (msg.includes("timeout") || msg.includes("unreachable")) return true;
-      if (msg.includes("closed")) return true; // ClosedPath, stream closed, etc
-      if (msg.includes("no route") || msg.includes("endpoint")) return true;
-      if (msg.includes("stream") && (msg.includes("error") || msg.includes("failed"))) return true;
-      if (msg.includes("read") && msg.includes("error")) return true;
-      
-      return false;
-    }
-  );
+  return result.error.issues.some((issue) => {
+    if (issue.code !== "custom") return false;
+    const msg = issue.message.toLowerCase();
+
+    // HTTP fetch errors
+    if (msg === "failed to fetch" || msg === "network error") return true;
+
+    // P2P/iroh connection errors - be generous with matching
+    if (msg.includes("connection")) return true; // connection failed, closed, refused, etc
+    if (msg.includes("connect to peer")) return true; // "failed to connect to peer ..."
+    if (msg.includes("federation api error")) return true; // wrapper from p2p_client
+    if (msg.includes("no addressing information")) return true; // iroh: peer has no relay/direct addrs
+    if (msg.includes("timeout") || msg.includes("unreachable")) return true;
+    if (msg.includes("closed")) return true; // ClosedPath, stream closed, etc
+    if (msg.includes("no route") || msg.includes("endpoint")) return true;
+    if (msg.includes("stream") && (msg.includes("error") || msg.includes("failed"))) return true;
+    if (msg.includes("read") && msg.includes("error")) return true;
+
+    return false;
+  });
 }