@freqhole/api-client 0.2.14 → 0.3.1

package/src/domains/upload.ts

@@ -7,9 +7,11 @@ import {
   ImageUploadResponseSchema,
   MusicImportResponseSchema,
   MusicUploadResponseSchema,
+  VideoUploadResponseSchema,
 } from "../codegen/schema.js";
 import type { Transport } from "../transport.js";
 import type { SafeParseResult } from "./types.js";
+import { toZodError } from "../errors.js";
 
 // helper to parse response and validate with schema
 function parseResponse<T>(
@@ -18,21 +20,7 @@ function parseResponse<T>(
   schema: z.ZodType<T>,
 ): SafeParseResult<T> {
   if (status >= 400) {
-    let errorMessage = `HTTP ${status}`;
-    try {
-      const errorBody = JSON.parse(responseBody);
-      if (errorBody?.error) {
-        errorMessage = `HTTP ${status}: ${errorBody.error}`;
-      }
-    } catch {
-      // body wasn't JSON
-    }
-    return {
-      success: false,
-      error: new z.ZodError([
-        { code: "custom", path: [], message: errorMessage },
-      ]),
-    };
+    return { success: false, error: toZodError(responseBody, status) };
   }
 
   try {
@@ -68,19 +56,17 @@ export function createUploadMethods(transport: Transport) {
     /**
      * upload a music file
      * returns job information for async processing
+     * @param onProgress - optional callback with (loaded, total) bytes sent so far
      */
     music: async (
       file: File | Blob,
+      onProgress?: (loaded: number, total: number) => void,
     ): Promise<SafeParseResult<s.MusicUploadResponse>> => {
       const formData = new FormData();
       formData.append("file", file);
 
-      const response = await transport.upload("/api/upload/music", formData);
-      return parseResponse(
-        response.body,
-        response.status,
-        MusicUploadResponseSchema,
-      );
+      const response = await transport.upload("/api/upload/music", formData, onProgress);
+      return parseResponse(response.body, response.status, MusicUploadResponseSchema);
     },
 
     /**
@@ -89,9 +75,7 @@ export function createUploadMethods(transport: Transport) {
      * peer to pull it via verified streaming.
      * requires transport.uploadByPath to be implemented (CharnelTransport).
      */
-    musicByPath: async (
-      filePath: string,
-    ): Promise<SafeParseResult<s.MusicUploadResponse>> => {
+    musicByPath: async (filePath: string): Promise<SafeParseResult<s.MusicUploadResponse>> => {
       if (!transport.uploadByPath) {
         return {
           success: false,
@@ -105,15 +89,48 @@ export function createUploadMethods(transport: Transport) {
         };
       }
 
-      const response = await transport.uploadByPath(
-        "/api/upload/music",
-        filePath,
-      );
-      return parseResponse(
-        response.body,
-        response.status,
-        MusicUploadResponseSchema,
-      );
+      const response = await transport.uploadByPath("/api/upload/music", filePath);
+      return parseResponse(response.body, response.status, MusicUploadResponseSchema);
+    },
+
+    /**
+     * upload a video file
+     * returns job information for async processing
+     * @param onProgress - optional callback with (loaded, total) bytes sent so far
+     */
+    video: async (
+      file: File | Blob,
+      onProgress?: (loaded: number, total: number) => void,
+    ): Promise<SafeParseResult<s.VideoUploadResponse>> => {
+      const formData = new FormData();
+      formData.append("file", file);
+
+      const response = await transport.upload("/api/upload/video", formData, onProgress);
+      return parseResponse(response.body, response.status, VideoUploadResponseSchema);
+    },
+
+    /**
+     * upload a video file by filesystem path (tauri P2P only).
+     * imports the file into the local iroh-blobs store, then tells the remote
+     * peer to pull it via verified streaming.
+     * requires transport.uploadByPath to be implemented (CharnelTransport).
+     */
+    videoByPath: async (filePath: string): Promise<SafeParseResult<s.VideoUploadResponse>> => {
+      if (!transport.uploadByPath) {
+        return {
+          success: false,
+          error: new z.ZodError([
+            {
+              code: "custom",
+              path: [],
+              message: "uploadByPath not supported by this transport",
+            },
+          ]),
+        };
+      }
+
+      const response = await transport.uploadByPath("/api/upload/video", filePath);
+      return parseResponse(response.body, response.status, VideoUploadResponseSchema);
     },
 
     /**
@@ -132,11 +149,7 @@ export function createUploadMethods(transport: Transport) {
       }
 
       const response = await transport.upload("/api/upload/image", formData);
-      return parseResponse(
-        response.body,
-        response.status,
-        ImageUploadResponseSchema,
-      );
+      return parseResponse(response.body, response.status, ImageUploadResponseSchema);
     },
 
     /**
@@ -166,16 +179,8 @@ export function createUploadMethods(transport: Transport) {
         metadata.associate_with = options.associate;
       }
 
-      const response = await transport.uploadByPath(
-        "/api/upload/image",
-        filePath,
-        metadata,
-      );
-      return parseResponse(
-        response.body,
-        response.status,
-        ImageUploadResponseSchema,
-      );
+      const response = await transport.uploadByPath("/api/upload/image", filePath, metadata);
+      return parseResponse(response.body, response.status, ImageUploadResponseSchema);
     },
 
     /**
@@ -202,11 +207,7 @@ export function createUploadMethods(transport: Transport) {
         "/api/upload/music-paths",
         JSON.stringify(body),
       );
-      return parseResponse(
-        response.body,
-        response.status,
-        MusicImportResponseSchema,
-      );
+      return parseResponse(response.body, response.status, MusicImportResponseSchema);
     },
   };
 }

package/src/domains/video.ts

@@ -0,0 +1,463 @@
+// video domain methods for FreqholeClient
+
+import { routes } from "../codegen/routes.js";
+import type * as s from "../codegen/schema.js";
+import {
+  UpdateVideoSeasonRequestSchema,
+  UpdateVideoSeriesRequestSchema,
+  UpdateVideosRequestSchema,
+} from "../codegen/schema.js";
+import type { CallFn } from "./types.js";
+
+// partial schemas for update operations
+const UpdateVideosRequestPartialSchema = UpdateVideosRequestSchema.partial().required({
+  video_ids: true,
+});
+const UpdateVideoSeriesRequestPartialSchema = UpdateVideoSeriesRequestSchema.partial().required({
+  series_id: true,
+});
+const UpdateVideoSeasonRequestPartialSchema = UpdateVideoSeasonRequestSchema.partial().required({
+  season_id: true,
+});
+
+export function createVideoMethods(call: CallFn) {
+  return {
+    // videos
+    queryVideos: (params: s.QueryVideosRequest) => {
+      return call(
+        "video",
+        "query_videos",
+        routes.video.query_videos.resp,
+        routes.video.query_videos.req,
+        routes.video.query_videos.method,
+        routes.video.query_videos.path,
+        params,
+      );
+    },
+
+    createVideo: (params: s.CreateVideoRequest) => {
+      return call(
+        "video",
+        "create_video",
+        routes.video.create_video.resp,
+        routes.video.create_video.req,
+        routes.video.create_video.method,
+        routes.video.create_video.path,
+        params,
+      );
+    },
+
+    getVideo: (params: s.GetVideoRequest) => {
+      return call(
+        "video",
+        "get_video",
+        routes.video.get_video.resp,
+        routes.video.get_video.req,
+        routes.video.get_video.method,
+        routes.video.get_video.path,
+        params,
+      );
+    },
+
+    getVideoWithMetadata: (params: s.GetVideoRequest) => {
+      return call(
+        "video",
+        "get_video_with_metadata",
+        routes.video.get_video_with_metadata.resp,
+        routes.video.get_video_with_metadata.req,
+        routes.video.get_video_with_metadata.method,
+        routes.video.get_video_with_metadata.path,
+        params,
+      );
+    },
+
+    listVideosBySeries: (params: s.ListVideosBySeriesRequest) => {
+      return call(
+        "video",
+        "list_videos_by_series",
+        routes.video.list_videos_by_series.resp,
+        routes.video.list_videos_by_series.req,
+        routes.video.list_videos_by_series.method,
+        routes.video.list_videos_by_series.path,
+        params,
+      );
+    },
+
+    listVideosBySeason: (params: s.ListVideosBySeasonRequest) => {
+      return call(
+        "video",
+        "list_videos_by_season",
+        routes.video.list_videos_by_season.resp,
+        routes.video.list_videos_by_season.req,
+        routes.video.list_videos_by_season.method,
+        routes.video.list_videos_by_season.path,
+        params,
+      );
+    },
+
+    listVideosUnattached: (params: s.ListVideosUnattachedRequest) => {
+      return call(
+        "video",
+        "list_videos_unattached",
+        routes.video.list_videos_unattached.resp,
+        routes.video.list_videos_unattached.req,
+        routes.video.list_videos_unattached.method,
+        routes.video.list_videos_unattached.path,
+        params,
+      );
+    },
+
+    updateVideos: (params: Partial<s.UpdateVideosRequest> & { video_ids: string[] }) => {
+      return call(
+        "video",
+        "update_videos",
+        routes.video.update_videos.resp,
+        UpdateVideosRequestPartialSchema,
+        routes.video.update_videos.method,
+        routes.video.update_videos.path,
+        params,
+      );
+    },
+
+    deleteVideo: (params: s.DeleteVideoRequest) => {
+      return call(
+        "video",
+        "delete_video",
+        routes.video.delete_video.resp,
+        routes.video.delete_video.req,
+        routes.video.delete_video.method,
+        routes.video.delete_video.path,
+        params,
+      );
+    },
+
+    bulkDeleteVideos: (params: s.BulkDeleteVideosRequest) => {
+      return call(
+        "video",
+        "bulk_delete_videos",
+        routes.video.bulk_delete_videos.resp,
+        routes.video.bulk_delete_videos.req,
+        routes.video.bulk_delete_videos.method,
+        routes.video.bulk_delete_videos.path,
+        params,
+      );
+    },
+
+    getVideoRenditions: (params: s.GetVideoRenditionsRequest) => {
+      return call(
+        "video",
+        "get_video_renditions",
+        routes.video.get_video_renditions.resp,
+        routes.video.get_video_renditions.req,
+        routes.video.get_video_renditions.method,
+        routes.video.get_video_renditions.path,
+        params,
+      );
+    },
+
+    deleteVideoRendition: (params: s.DeleteVideoRenditionRequest) => {
+      return call(
+        "video",
+        "delete_video_rendition",
+        routes.video.delete_video_rendition.resp,
+        routes.video.delete_video_rendition.req,
+        routes.video.delete_video_rendition.method,
+        routes.video.delete_video_rendition.path,
+        params,
+      );
+    },
+
+    // playback progress
+    upsertPlaybackProgress: (params: s.UpsertPlaybackProgressRequest) => {
+      return call(
+        "video",
+        "upsert_playback_progress",
+        routes.video.upsert_playback_progress.resp,
+        routes.video.upsert_playback_progress.req,
+        routes.video.upsert_playback_progress.method,
+        routes.video.upsert_playback_progress.path,
+        params,
+      );
+    },
+
+    getPlaybackProgress: (params: s.GetPlaybackProgressRequest) => {
+      return call(
+        "video",
+        "get_playback_progress",
+        routes.video.get_playback_progress.resp,
+        routes.video.get_playback_progress.req,
+        routes.video.get_playback_progress.method,
+        routes.video.get_playback_progress.path,
+        params,
+      );
+    },
+
+    listPlaybackProgress: (params: s.ListPlaybackProgressRequest) => {
+      return call(
+        "video",
+        "list_playback_progress",
+        routes.video.list_playback_progress.resp,
+        routes.video.list_playback_progress.req,
+        routes.video.list_playback_progress.method,
+        routes.video.list_playback_progress.path,
+        params,
+      );
+    },
+
+    // universal-domain relation hubs (era/recently_added/unassigned +
+    // generic categorical hubs like genre/mood/style), mirrors music's
+    // recentlyAddedAlbums/albumsByValue/unassignedAlbums.
+
+    // top-N most recently added videos, flat (not clustered by series)
+    // by created_at desc.
+    recentlyAddedVideos: (params: s.RecentlyAddedVideosRequest) => {
+      return call(
+        "video",
+        "recently_added_videos",
+        routes.video.recently_added_videos.resp,
+        routes.video.recently_added_videos.req,
+        routes.video.recently_added_videos.method,
+        routes.video.recently_added_videos.path,
+        params,
+      );
+    },
+
+    // fan out the synthesized "unassigned" hub to its member videos
+    // (videos with no entity_taxonz rows at all).
+    unassignedVideos: (params: s.UnassignedVideosRequest) => {
+      return call(
+        "video",
+        "unassigned_videos",
+        routes.video.unassigned_videos.resp,
+        routes.video.unassigned_videos.req,
+        routes.video.unassigned_videos.method,
+        routes.video.unassigned_videos.path,
+        params,
+      );
+    },
+
+    // fetch a (taxon_kind, taxon_value) hub's full video member set -
+    // used when the graph drills into a generic categorical relation
+    // hub (genre/mood/style/label/tag) with the video domain active.
+    videosByValue: (params: s.VideosByValueRequest) => {
+      return call(
+        "video",
+        "videos_by_value",
+        routes.video.videos_by_value.resp,
+        routes.video.videos_by_value.req,
+        routes.video.videos_by_value.method,
+        routes.video.videos_by_value.path,
+        params,
+      );
+    },
+
+    // video series
+    queryVideoSeries: (params: s.QueryParams) => {
+      return call(
+        "video",
+        "query_video_series",
+        routes.video.query_video_series.resp,
+        routes.video.query_video_series.req,
+        routes.video.query_video_series.method,
+        routes.video.query_video_series.path,
+        params,
+      );
+    },
+
+    createVideoSeries: (params: s.CreateVideoSeriesRequest) => {
+      return call(
+        "video",
+        "create_video_series",
+        routes.video.create_video_series.resp,
+        routes.video.create_video_series.req,
+        routes.video.create_video_series.method,
+        routes.video.create_video_series.path,
+        params,
+      );
+    },
+
+    listVideoSeries: (params: s.ListVideoSeriesRequest) => {
+      return call(
+        "video",
+        "list_video_series",
+        routes.video.list_video_series.resp,
+        routes.video.list_video_series.req,
+        routes.video.list_video_series.method,
+        routes.video.list_video_series.path,
+        params,
+      );
+    },
+
+    getVideoSeries: (params: s.GetVideoSeriesRequest) => {
+      return call(
+        "video",
+        "get_video_series",
+        routes.video.get_video_series.resp,
+        routes.video.get_video_series.req,
+        routes.video.get_video_series.method,
+        routes.video.get_video_series.path,
+        params,
+      );
+    },
+
+    getVideoSeriesDetail: (params: s.GetVideoSeriesRequest) => {
+      return call(
+        "video",
+        "get_video_series_detail",
+        routes.video.get_video_series_detail.resp,
+        routes.video.get_video_series_detail.req,
+        routes.video.get_video_series_detail.method,
+        routes.video.get_video_series_detail.path,
+        params,
+      );
+    },
+
+    updateVideoSeries: (params: Partial<s.UpdateVideoSeriesRequest> & { series_id: string }) => {
+      return call(
+        "video",
+        "update_video_series",
+        routes.video.update_video_series.resp,
+        UpdateVideoSeriesRequestPartialSchema,
+        routes.video.update_video_series.method,
+        routes.video.update_video_series.path,
+        params,
+      );
+    },
+
+    deleteVideoSeries: (params: s.DeleteVideoSeriesRequest) => {
+      return call(
+        "video",
+        "delete_video_series",
+        routes.video.delete_video_series.resp,
+        routes.video.delete_video_series.req,
+        routes.video.delete_video_series.method,
+        routes.video.delete_video_series.path,
+        params,
+      );
+    },
+
+    // video seasons
+    createVideoSeason: (params: s.CreateVideoSeasonRequest) => {
+      return call(
+        "video",
+        "create_video_season",
+        routes.video.create_video_season.resp,
+        routes.video.create_video_season.req,
+        routes.video.create_video_season.method,
+        routes.video.create_video_season.path,
+        params,
+      );
+    },
+
+    listVideoSeasons: (params: s.ListVideoSeasonsRequest) => {
+      return call(
+        "video",
+        "list_video_seasons",
+        routes.video.list_video_seasons.resp,
+        routes.video.list_video_seasons.req,
+        routes.video.list_video_seasons.method,
+        routes.video.list_video_seasons.path,
+        params,
+      );
+    },
+
+    getVideoSeason: (params: s.GetVideoSeasonRequest) => {
+      return call(
+        "video",
+        "get_video_season",
+        routes.video.get_video_season.resp,
+        routes.video.get_video_season.req,
+        routes.video.get_video_season.method,
+        routes.video.get_video_season.path,
+        params,
+      );
+    },
+
+    updateVideoSeason: (params: Partial<s.UpdateVideoSeasonRequest> & { season_id: string }) => {
+      return call(
+        "video",
+        "update_video_season",
+        routes.video.update_video_season.resp,
+        UpdateVideoSeasonRequestPartialSchema,
+        routes.video.update_video_season.method,
+        routes.video.update_video_season.path,
+        params,
+      );
+    },
+
+    deleteVideoSeason: (params: s.DeleteVideoSeasonRequest) => {
+      return call(
+        "video",
+        "delete_video_season",
+        routes.video.delete_video_season.resp,
+        routes.video.delete_video_season.req,
+        routes.video.delete_video_season.method,
+        routes.video.delete_video_season.path,
+        params,
+      );
+    },
+
+    // import review (grouped by detected series)
+    listPendingVideoImportReview: (params: s.ListPendingVideoReviewRequest) => {
+      return call(
+        "video",
+        "list_pending_video_import_review",
+        routes.video.list_pending_video_import_review.resp,
+        routes.video.list_pending_video_import_review.req,
+        routes.video.list_pending_video_import_review.method,
+        routes.video.list_pending_video_import_review.path,
+        params,
+      );
+    },
+
+    markVideoGroupReviewed: (params: s.MarkVideoGroupReviewedRequest) => {
+      return call(
+        "video",
+        "mark_video_group_reviewed",
+        routes.video.mark_video_group_reviewed.resp,
+        routes.video.mark_video_group_reviewed.req,
+        routes.video.mark_video_group_reviewed.method,
+        routes.video.mark_video_group_reviewed.path,
+        params,
+      );
+    },
+
+    patchVideoGroupReview: (params: s.PatchVideoGroupReviewRequest) => {
+      return call(
+        "video",
+        "patch_video_group_review",
+        routes.video.patch_video_group_review.resp,
+        routes.video.patch_video_group_review.req,
+        routes.video.patch_video_group_review.method,
+        routes.video.patch_video_group_review.path,
+        params,
+      );
+    },
+
+    moveVideoReview: (params: s.MoveVideoReviewRequest) => {
+      return call(
+        "video",
+        "move_video_review",
+        routes.video.move_video_review.resp,
+        routes.video.move_video_review.req,
+        routes.video.move_video_review.method,
+        routes.video.move_video_review.path,
+        params,
+      );
+    },
+
+    videoPending: (params: s.VideoPendingRequest) => {
+      return call(
+        "video",
+        "video_pending",
+        routes.video.video_pending.resp,
+        routes.video.video_pending.req,
+        routes.video.video_pending.method,
+        routes.video.video_pending.path,
+        params,
+      );
+    },
+  };
+}
+
+export type VideoMethods = ReturnType<typeof createVideoMethods>;