@editframe/api 0.10.0-beta.7 → 0.11.0-beta.2

package/dist/resources/image-file.d.ts

@@ -30,4 +30,4 @@ export interface CreateImageFileResult {
     asset_id: string;
 }
 export declare const createImageFile: (client: Client, payload: z.infer<typeof CreateImageFilePayload>) => Promise<CreateImageFileResult>;
-export declare const uploadImageFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => Promise<void>;
+export declare const uploadImageFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;

package/dist/resources/image-file.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import debug from "debug";
+import { z } from "zod";
 import { uploadChunks } from "../uploadChunks.js";
 const log = debug("ef:api:image-file");
 const MAX_IMAGE_SIZE = 1024 * 1024 * 16;
@@ -26,20 +26,14 @@ const createImageFile = async (client, payload) => {
     `Failed to create file ${response.status} ${response.statusText}`
   );
 };
-const uploadImageFile = async (client, fileId, fileStream, fileSize) => {
+const uploadImageFile = (client, fileId, fileStream, fileSize) => {
   log("Uploading image file", fileId);
-  if (fileSize > MAX_IMAGE_SIZE) {
-    throw new Error(
-      `File size ${fileSize} bytes exceeds limit ${MAX_IMAGE_SIZE} bytes`
-    );
-  }
-  const result = await uploadChunks(client, {
+  return uploadChunks(client, {
     url: `/api/v1/image_files/${fileId}/upload`,
     fileSize,
-    fileStream
+    fileStream,
+    maxSize: MAX_IMAGE_SIZE
   });
-  log("Image file upload complete");
-  return result;
 };
 export {
   CreateImageFilePayload,

package/dist/resources/isobmff-track.d.ts

@@ -269,4 +269,4 @@ export interface CreateISOBMFFTrackResult {
     complete: boolean;
 }
 export declare const createISOBMFFTrack: (client: Client, payload: z.infer<typeof CreateISOBMFFTrackPayload>) => Promise<CreateISOBMFFTrackResult>;
-export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: Readable, trackSize: number) => Promise<void>;
+export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: Readable, trackSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;

package/dist/resources/isobmff-track.js

@@ -39,14 +39,14 @@ const createISOBMFFTrack = async (client, payload) => {
     `Failed to create isobmff track ${response.status} ${response.statusText}`
   );
 };
-const uploadISOBMFFTrack = async (client, fileId, trackId, fileStream, trackSize) => {
+const uploadISOBMFFTrack = (client, fileId, trackId, fileStream, trackSize) => {
   log("Uploading fragment track", fileId);
-  await uploadChunks(client, {
+  return uploadChunks(client, {
     url: `/api/v1/isobmff_tracks/${fileId}/${trackId}/upload`,
     fileStream,
-    fileSize: trackSize
+    fileSize: trackSize,
+    maxSize: MAX_TRACK_SIZE
   });
-  log("Fragment track upload complete");
 };
 export {
   CreateISOBMFFTrackPayload,

package/dist/resources/unprocessed-file.d.ts

@@ -1,6 +1,7 @@
 import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
+import { IteratorWithPromise, UploadChunkEvent } from '../uploadChunks.ts';
 declare const FileProcessors: z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"image">, z.ZodLiteral<"captions">, z.ZodString]>, "many">, string[], string[]>;
 export declare const CreateUnprocessedFilePayload: z.ZodObject<{
     md5: z.ZodString;
@@ -45,9 +46,33 @@ export interface UpdateUnprocessedFileResult {
 }
 export declare const createUnprocessedFile: (client: Client, payload: z.infer<typeof CreateUnprocessedFilePayload>) => Promise<CreateUnprocessedFileResult>;
 export declare const updateUnprocessedFile: (client: Client, fileId: string, payload: Partial<z.infer<typeof UpdateUnprocessedFilePayload>>) => Promise<UpdateUnprocessedFileResult>;
-export declare const uploadUnprocessedFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => Promise<void>;
-export declare const processAVFileBuffer: (client: Client, buffer: Buffer, filename?: string) => Promise<UpdateUnprocessedFileResult>;
-export declare const processAVFile: (client: Client, filePath: string) => Promise<UpdateUnprocessedFileResult>;
-export declare const processImageFileBuffer: (client: Client, buffer: Buffer, filename?: string) => Promise<UpdateUnprocessedFileResult>;
-export declare const processImageFile: (client: Client, filePath: string) => Promise<UpdateUnprocessedFileResult>;
+export declare const uploadUnprocessedFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => IteratorWithPromise<UploadChunkEvent>;
+export declare const processAVFileBuffer: (client: Client, buffer: Buffer, filename?: string) => {
+    progress(): AsyncGenerator<{
+        type: string;
+        progress: number;
+    }, void, unknown>;
+    file: () => Promise<UpdateUnprocessedFileResult>;
+};
+export declare const processAVFile: (client: Client, filePath: string) => {
+    progress: () => Promise<AsyncGenerator<{
+        type: string;
+        progress: number;
+    }, void, unknown>>;
+    file: () => Promise<UpdateUnprocessedFileResult>;
+};
+export declare const processImageFileBuffer: (client: Client, buffer: Buffer, filename?: string) => {
+    progress(): AsyncGenerator<{
+        type: string;
+        progress: number;
+    }, void, unknown>;
+    file: () => Promise<UpdateUnprocessedFileResult>;
+};
+export declare const processImageFile: (client: Client, filePath: string) => {
+    progress: () => Promise<AsyncGenerator<{
+        type: string;
+        progress: number;
+    }, void, unknown>>;
+    file: () => Promise<UpdateUnprocessedFileResult>;
+};
 export {};

package/dist/resources/unprocessed-file.js

@@ -72,78 +72,95 @@ const updateUnprocessedFile = async (client, fileId, payload) => {
     `Failed to update unprocessed file ${response.status} ${response.statusText}`
   );
 };
-const uploadUnprocessedFile = async (client, fileId, fileStream, fileSize) => {
+const uploadUnprocessedFile = (client, fileId, fileStream, fileSize) => {
   log("Uploading unprocessed file", fileId);
-  await uploadChunks(client, {
+  return uploadChunks(client, {
     url: `/api/v1/unprocessed_files/${fileId}/upload`,
     fileSize,
-    fileStream
+    fileStream,
+    maxSize: MAX_FILE_SIZE
   });
-  log("Unprocessed file upload complete");
 };
-const processResource = async (client, filename, md5, byteSize, processor, doUpload) => {
+const processResource = (client, filename, md5, byteSize, processor, doUpload) => {
   log("Processing", { filename, md5, byteSize, processor });
-  const unprocessedFile = await createUnprocessedFile(client, {
+  const createFilePromise = createUnprocessedFile(client, {
     md5,
     processes: [],
     filename,
     byte_size: byteSize
   });
-  if (unprocessedFile.complete === false) {
-    await doUpload(unprocessedFile.id);
-  }
-  if (unprocessedFile.processes.includes(processor)) {
-    log("File already processed", unprocessedFile);
-    return unprocessedFile;
-  }
-  const fileInformation = await updateUnprocessedFile(
-    client,
-    unprocessedFile.id,
-    {
-      processes: [processor]
+  return {
+    async *progress() {
+      const unprocessedFile = await createFilePromise;
+      if (unprocessedFile.complete) {
+        yield { type: "progress", progress: 0 };
+        yield { type: "progress", progress: 1 };
+      }
+      yield* doUpload(unprocessedFile.id);
+    },
+    file: async () => {
+      const unprocessedFile = await createFilePromise;
+      if (unprocessedFile.complete) {
+        return unprocessedFile;
+      }
+      await doUpload(unprocessedFile.id).whenUploaded();
+      const fileInformation = await updateUnprocessedFile(
+        client,
+        unprocessedFile.id,
+        {
+          processes: [processor]
+        }
+      );
+      log("File processed", fileInformation);
+      return fileInformation;
     }
-  );
-  log("File processed", fileInformation);
-  return fileInformation;
+  };
 };
 const buildBufferProcessor = (processor) => {
-  return async (client, buffer, filename = "buffer") => {
+  return (client, buffer, filename = "buffer") => {
     log(`Processing file buffer: ${processor}`, filename);
     const md5 = md5Buffer(buffer);
-    return await processResource(
+    return processResource(
       client,
       filename,
       md5,
       buffer.byteLength,
       processor,
-      async (id) => {
+      (id) => {
         const readStream = new Readable({
           read() {
             readStream.push(buffer);
             readStream.push(null);
           }
         });
-        await uploadUnprocessedFile(client, id, readStream, buffer.byteLength);
+        return uploadUnprocessedFile(client, id, readStream, buffer.byteLength);
       }
     );
   };
 };
 const buildFileProcessor = (processor) => {
-  return async (client, filePath) => {
-    log(`Processing file ${processor}`, filePath);
-    const md5 = await md5FilePath(filePath);
-    const byteSize = (await stat(filePath)).size;
-    return await processResource(
-      client,
-      basename(filePath),
-      md5,
-      byteSize,
-      processor,
-      async (id) => {
-        const readStream = createReadStream(filePath);
-        return await uploadUnprocessedFile(client, id, readStream, byteSize);
-      }
-    );
+  return (client, filePath) => {
+    const processPromise = async () => {
+      const [md5, { size: byteSize }] = await Promise.all([
+        md5FilePath(filePath),
+        stat(filePath)
+      ]);
+      return processResource(
+        client,
+        basename(filePath),
+        md5,
+        byteSize,
+        processor,
+        (id) => {
+          const readStream = createReadStream(filePath);
+          return uploadUnprocessedFile(client, id, readStream, byteSize);
+        }
+      );
+    };
+    return {
+      progress: async () => (await processPromise()).progress(),
+      file: async () => (await processPromise()).file()
+    };
   };
 };
 const processAVFileBuffer = buildBufferProcessor("isobmff");

package/dist/uploadChunks.d.ts

@@ -1,10 +1,19 @@
 import { Readable } from 'node:stream';
 import { Client } from './client.ts';
+export interface IteratorWithPromise<T> extends AsyncGenerator<T, void, unknown> {
+    whenUploaded: () => Promise<T[]>;
+}
+export declare const fakeCompleteUpload: () => IteratorWithPromise<UploadChunkEvent>;
 interface UploadChunksOptions {
     url: string;
     fileStream: Readable;
     fileSize: number;
+    maxSize: number;
     chunkSizeBytes?: number;
 }
-export declare function uploadChunks(client: Client, { url, fileSize, fileStream, chunkSizeBytes, }: UploadChunksOptions): Promise<void>;
+export interface UploadChunkEvent {
+    type: "progress";
+    progress: number;
+}
+export declare function uploadChunks(client: Client, { url, fileSize, fileStream, maxSize, chunkSizeBytes, }: UploadChunksOptions): IteratorWithPromise<UploadChunkEvent>;
 export {};

package/dist/uploadChunks.js

@@ -1,6 +1,6 @@
 import debug from "debug";
-import { streamChunker } from "./streamChunker.js";
 import { CHUNK_SIZE_BYTES } from "./CHUNK_SIZE_BYTES.js";
+import { streamChunker } from "./streamChunker.js";
 const log = debug("ef:api:uploadChunk");
 const uploadChunk = async (client, {
   url,
@@ -34,37 +34,65 @@ const uploadChunk = async (client, {
     `Failed to upload chunk ${chunkNumber} for ${url} ${response.status} ${response.statusText}`
   );
 };
-async function uploadChunks(client, {
+function uploadChunks(client, {
   url,
   fileSize,
   fileStream,
+  maxSize,
   chunkSizeBytes = CHUNK_SIZE_BYTES
 }) {
-  log("Checking upload status", url);
-  const uploadStatus = await client.authenticatedFetch(url);
-  if (uploadStatus.status === 200) {
-    log("Fragment track already uploaded");
-    return;
-  }
-  let chunkNumber = 0;
-  let complete = false;
-  for await (const chunkBuffer of streamChunker(fileStream, chunkSizeBytes)) {
-    log(`Uploading chunk ${chunkNumber}`);
-    ({ complete } = await uploadChunk(client, {
-      url,
-      chunkBuffer,
-      chunkNumber,
-      fileSize,
-      chunkSizeBytes
-    }));
-    chunkNumber++;
-  }
-  if (!fileStream.readableEnded) {
-    throw new Error("Did not read entire file stream");
-  }
-  if (!complete) {
-    throw new Error("Did not complete upload");
-  }
+  const makeGenerator = async function* () {
+    if (fileSize > maxSize) {
+      throw new Error(
+        `File size ${fileSize} bytes exceeds limit ${maxSize} bytes`
+      );
+    }
+    log("Checking upload status", url);
+    const uploadStatus = await client.authenticatedFetch(url);
+    yield { type: "progress", progress: 0 };
+    if (uploadStatus.status === 200) {
+      log("Fragment track already uploaded");
+      yield { type: "progress", progress: 1 };
+      return;
+    }
+    let chunkNumber = 0;
+    let complete = false;
+    for await (const chunkBuffer of streamChunker(fileStream, chunkSizeBytes)) {
+      log(`Uploading chunk ${chunkNumber}`);
+      ({ complete } = await uploadChunk(client, {
+        url,
+        chunkBuffer,
+        chunkNumber,
+        fileSize,
+        chunkSizeBytes
+      }));
+      chunkNumber++;
+      yield {
+        type: "progress",
+        progress: Math.min(1, chunkNumber / (fileSize / chunkSizeBytes))
+      };
+    }
+    if (!fileStream.readableEnded) {
+      throw new Error("Did not read entire file stream");
+    }
+    if (!complete) {
+      throw new Error("Did not complete upload");
+    }
+  };
+  const generator = makeGenerator();
+  generator.whenUploaded = async () => {
+    if (fileSize > maxSize) {
+      throw new Error(
+        `File size ${fileSize} bytes exceeds limit ${maxSize} bytes`
+      );
+    }
+    const events = [];
+    for await (const event of generator) {
+      events.push(event);
+    }
+    return events;
+  };
+  return generator;
 }
 export {
   uploadChunks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/api",
-  "version": "0.10.0-beta.7",
+  "version": "0.11.0-beta.2",
   "description": "API functions for EditFrame",
   "exports": {
     ".": {
@@ -28,7 +28,7 @@
     "vite-tsconfig-paths": "^4.3.2"
   },
   "dependencies": {
-    "@editframe/assets": "0.10.0-beta.7",
+    "@editframe/assets": "0.11.0-beta.2",
     "debug": "^4.3.5",
     "jsonwebtoken": "^9.0.2",
     "node-fetch": "^3.3.2",

package/src/resources/image-file.test.ts

@@ -1,11 +1,11 @@
-import { test, expect, beforeAll, afterEach, afterAll, describe } from "vitest";
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 import { ZodError } from "zod";
 
 import { Client } from "../client.ts";
-import { createImageFile, uploadImageFile } from "./image-file.ts";
 import { readableFromBuffers } from "../readableFromBuffers.ts";
+import { createImageFile, uploadImageFile } from "./image-file.ts";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -96,7 +96,7 @@ describe("ImageFile", () => {
           "test-file-id",
           readableFromBuffers(Buffer.from("test")),
           1024 * 1024 * 17,
-        ),
+        ).whenUploaded(),
       ).rejects.toThrowError(
         "File size 17825792 bytes exceeds limit 16777216 bytes",
       );
@@ -117,7 +117,7 @@ describe("ImageFile", () => {
           "test-file-id",
           readableFromBuffers(Buffer.from("test")),
           4,
-        ),
+        ).whenUploaded(),
       ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/image_files/test-file-id/upload 500 Internal Server Error",
       );
@@ -138,8 +138,11 @@ describe("ImageFile", () => {
           "test-file-id",
           readableFromBuffers(Buffer.from("test")),
           4,
-        ),
-      ).resolves.toBeUndefined();
+        ).whenUploaded(),
+      ).resolves.toEqual([
+        { type: "progress", progress: 0 },
+        { type: "progress", progress: 1 },
+      ]);
     });
   });
 });

package/src/resources/image-file.ts

@@ -1,7 +1,7 @@
 import type { Readable } from "node:stream";
 
-import { z } from "zod";
 import debug from "debug";
+import { z } from "zod";
 
 import type { Client } from "../client.ts";
 import { uploadChunks } from "../uploadChunks.ts";
@@ -48,26 +48,18 @@ export const createImageFile = async (
   );
 };
 
-export const uploadImageFile = async (
+export const uploadImageFile = (
   client: Client,
   fileId: string,
   fileStream: Readable,
   fileSize: number,
 ) => {
   log("Uploading image file", fileId);
-  if (fileSize > MAX_IMAGE_SIZE) {
-    throw new Error(
-      `File size ${fileSize} bytes exceeds limit ${MAX_IMAGE_SIZE} bytes`,
-    );
-  }
 
-  const result = await uploadChunks(client, {
+  return uploadChunks(client, {
     url: `/api/v1/image_files/${fileId}/upload`,
     fileSize,
     fileStream,
+    maxSize: MAX_IMAGE_SIZE,
   });
-
-  log("Image file upload complete");
-
-  return result;
 };

package/src/resources/isobmff-track.test.ts

@@ -1,11 +1,12 @@
-import { test, expect, beforeAll, afterEach, afterAll, describe } from "vitest";
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 import { ZodError } from "zod";
 
+import { createTestTrack } from "TEST/createTestTrack.ts";
 import { Client } from "../client.ts";
-import { createISOBMFFTrack, uploadISOBMFFTrack } from "./isobmff-track.ts";
 import { readableFromBuffers } from "../readableFromBuffers.ts";
+import { createISOBMFFTrack, uploadISOBMFFTrack } from "./isobmff-track.ts";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -93,7 +94,7 @@ describe("ISOBMFF Track", () => {
           1,
           readableFromBuffers(Buffer.from("test")),
           4,
-        ),
+        ).whenUploaded(),
       ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/isobmff_tracks/test-file/1/upload 500 Internal Server Error",
       );
@@ -115,46 +116,11 @@ describe("ISOBMFF Track", () => {
           1,
           readableFromBuffers(Buffer.from("test")),
           4,
-        ),
-      ).resolves.toBeUndefined();
+        ).whenUploaded(),
+      ).resolves.toEqual([
+        { type: "progress", progress: 0 },
+        { type: "progress", progress: 1 },
+      ]);
     });
   });
 });
-
-function createTestTrack(
-  options: Partial<Parameters<typeof createISOBMFFTrack>[1]> = {},
-) {
-  return Object.assign(
-    {
-      file_id: "test-id",
-      track_id: 1,
-      type: "audio",
-      probe_info: {
-        channels: 2,
-        sample_rate: "44100",
-        duration: 1000,
-        duration_ts: 1000,
-        start_time: 0,
-        start_pts: 0,
-        r_frame_rate: "100",
-        channel_layout: "stereo",
-        codec_tag_string: "mp3",
-        codec_long_name: "MP3",
-        codec_type: "audio",
-        codec_tag: "0x0000",
-        codec_name: "aac",
-        bits_per_sample: 16,
-        index: 0,
-        sample_fmt: "s16",
-        time_base: "100",
-        avg_frame_rate: "100",
-        disposition: {},
-        bit_rate: "100",
-      },
-      duration_ms: 1000,
-      codec_name: "mp3",
-      byte_size: 1024 * 1024 * 5,
-    } as const,
-    options,
-  );
-}

package/src/resources/isobmff-track.ts

@@ -63,7 +63,7 @@ export const createISOBMFFTrack = async (
   );
 };
 
-export const uploadISOBMFFTrack = async (
+export const uploadISOBMFFTrack = (
   client: Client,
   fileId: string,
   trackId: number,
@@ -72,11 +72,10 @@ export const uploadISOBMFFTrack = async (
 ) => {
   log("Uploading fragment track", fileId);
 
-  await uploadChunks(client, {
+  return uploadChunks(client, {
     url: `/api/v1/isobmff_tracks/${fileId}/${trackId}/upload`,
     fileStream,
     fileSize: trackSize,
+    maxSize: MAX_TRACK_SIZE,
   });
-
-  log("Fragment track upload complete");
 };

package/src/resources/unprocessed-file.test.ts

@@ -1,11 +1,12 @@
 import { join } from "node:path";
 
-import { test, expect, beforeAll, afterEach, afterAll, describe } from "vitest";
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
 import { ZodError } from "zod";
 
 import { Client } from "../client.ts";
+import { readableFromBuffers } from "../readableFromBuffers.ts";
 import {
   createUnprocessedFile,
   processAVFile,
@@ -15,7 +16,6 @@ import {
   updateUnprocessedFile,
   uploadUnprocessedFile,
 } from "./unprocessed-file.ts";
-import { readableFromBuffers } from "../readableFromBuffers.ts";
 
 const server = setupServer();
 const client = new Client("ef_TEST_TOKEN", "http://localhost");
@@ -147,7 +147,7 @@ describe("Unprocessed File", () => {
           "test-file",
           readableFromBuffers(Buffer.from("test")),
           4,
-        ),
+        ).whenUploaded(),
       ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/unprocessed_files/test-file/upload 500 Internal Server Error",
       );
@@ -168,8 +168,11 @@ describe("Unprocessed File", () => {
           "test-file",
           readableFromBuffers(Buffer.from("test")),
           4,
-        ),
-      ).resolves.toBeUndefined();
+        ).whenUploaded(),
+      ).resolves.toEqual([
+        { type: "progress", progress: 0 },
+        { type: "progress", progress: 1 },
+      ]);
     });
   });
 
@@ -183,7 +186,7 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        processAVFileBuffer(client, Buffer.from("test"), "test-file"),
+        processAVFileBuffer(client, Buffer.from("test"), "test-file").file(),
       ).rejects.toThrowError(
         "Failed to create unprocessed file 500 Internal Server Error",
       );
@@ -209,7 +212,7 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        processAVFileBuffer(client, Buffer.from("test"), "test-file"),
+        processAVFileBuffer(client, Buffer.from("test"), "test-file").file(),
       ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload 500 Internal Server Error",
       );
@@ -239,7 +242,7 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        processAVFileBuffer(client, Buffer.from("test"), "test-file"),
+        processAVFileBuffer(client, Buffer.from("test"), "test-file").file(),
       ).rejects.toThrowError(
         "Failed to update unprocessed file 500 Internal Server Error",
       );
@@ -269,7 +272,7 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        processAVFileBuffer(client, Buffer.from("test"), "test-file"),
+        processAVFileBuffer(client, Buffer.from("test"), "test-file").file(),
       ).resolves.toEqual({ test: "response" });
     });
   });
@@ -282,7 +285,9 @@ describe("Unprocessed File", () => {
         ),
       );
 
-      await expect(processAVFile(client, TEST_AV_FILE)).rejects.toThrowError(
+      await expect(
+        processAVFile(client, TEST_AV_FILE).file(),
+      ).rejects.toThrowError(
         "Failed to create unprocessed file 500 Internal Server Error",
       );
     });
@@ -306,7 +311,9 @@ describe("Unprocessed File", () => {
         ),
       );
 
-      await expect(processAVFile(client, TEST_AV_FILE)).rejects.toThrowError(
+      await expect(
+        processAVFile(client, TEST_AV_FILE).file(),
+      ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload 500 Internal Server Error",
       );
     });
@@ -334,7 +341,9 @@ describe("Unprocessed File", () => {
         ),
       );
 
-      await expect(processAVFile(client, TEST_AV_FILE)).rejects.toThrowError(
+      await expect(
+        processAVFile(client, TEST_AV_FILE).file(),
+      ).rejects.toThrowError(
         "Failed to update unprocessed file 500 Internal Server Error",
       );
     });
@@ -362,9 +371,11 @@ describe("Unprocessed File", () => {
         ),
       );
 
-      await expect(processAVFile(client, TEST_AV_FILE)).resolves.toEqual({
-        test: "response",
-      });
+      await expect(processAVFile(client, TEST_AV_FILE).file()).resolves.toEqual(
+        {
+          test: "response",
+        },
+      );
     });
   });
 
@@ -377,7 +388,7 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        processImageFileBuffer(client, Buffer.from("test"), "test-file"),
+        processImageFileBuffer(client, Buffer.from("test"), "test-file").file(),
       ).rejects.toThrowError(
         "Failed to create unprocessed file 500 Internal Server Error",
       );
@@ -403,7 +414,7 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        processImageFileBuffer(client, Buffer.from("test"), "test-file"),
+        processImageFileBuffer(client, Buffer.from("test"), "test-file").file(),
       ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload 500 Internal Server Error",
       );
@@ -433,7 +444,7 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        processImageFileBuffer(client, Buffer.from("test"), "test-file"),
+        processImageFileBuffer(client, Buffer.from("test"), "test-file").file(),
       ).rejects.toThrowError(
         "Failed to update unprocessed file 500 Internal Server Error",
       );
@@ -463,7 +474,7 @@ describe("Unprocessed File", () => {
       );
 
       await expect(
-        processImageFileBuffer(client, Buffer.from("test"), "test-file"),
+        processImageFileBuffer(client, Buffer.from("test"), "test-file").file(),
       ).resolves.toEqual({ test: "response" });
     });
   });
@@ -476,7 +487,9 @@ describe("Unprocessed File", () => {
         ),
       );
 
-      await expect(processImageFile(client, TEST_AV_FILE)).rejects.toThrowError(
+      await expect(
+        processImageFile(client, TEST_AV_FILE).file(),
+      ).rejects.toThrowError(
         "Failed to create unprocessed file 500 Internal Server Error",
       );
     });
@@ -500,7 +513,9 @@ describe("Unprocessed File", () => {
         ),
       );
 
-      await expect(processImageFile(client, TEST_AV_FILE)).rejects.toThrowError(
+      await expect(
+        processImageFile(client, TEST_AV_FILE).file(),
+      ).rejects.toThrowError(
         "Failed to upload chunk 0 for /api/v1/unprocessed_files/098f6bcd-4621-d373-cade-4e832627b4f6/upload 500 Internal Server Error",
       );
     });
@@ -528,7 +543,9 @@ describe("Unprocessed File", () => {
         ),
       );
 
-      await expect(processImageFile(client, TEST_AV_FILE)).rejects.toThrowError(
+      await expect(
+        processImageFile(client, TEST_AV_FILE).file(),
+      ).rejects.toThrowError(
         "Failed to update unprocessed file 500 Internal Server Error",
       );
     });
@@ -555,6 +572,12 @@ describe("Unprocessed File", () => {
           () => HttpResponse.json({ test: "response" }, { status: 200 }),
         ),
       );
+
+      await expect(
+        processImageFile(client, TEST_AV_FILE).file(),
+      ).resolves.toEqual({
+        test: "response",
+      });
     });
   });
 });

package/src/resources/unprocessed-file.ts

@@ -9,7 +9,11 @@ import { z } from "zod";
 import { md5Buffer, md5FilePath } from "@editframe/assets";
 
 import type { Client } from "../client.ts";
-import { uploadChunks } from "../uploadChunks.ts";
+import {
+  type IteratorWithPromise,
+  type UploadChunkEvent,
+  uploadChunks,
+} from "../uploadChunks.ts";
 
 const log = debug("ef:api:unprocessed-file");
 
@@ -118,7 +122,7 @@ export const updateUnprocessedFile = async (
   );
 };
 
-export const uploadUnprocessedFile = async (
+export const uploadUnprocessedFile = (
   client: Client,
   fileId: string,
   fileStream: Readable,
@@ -126,64 +130,71 @@ export const uploadUnprocessedFile = async (
 ) => {
   log("Uploading unprocessed file", fileId);
 
-  await uploadChunks(client, {
+  return uploadChunks(client, {
     url: `/api/v1/unprocessed_files/${fileId}/upload`,
     fileSize,
     fileStream,
+    maxSize: MAX_FILE_SIZE,
   });
-
-  log("Unprocessed file upload complete");
 };
 
-const processResource = async (
+const processResource = (
   client: Client,
   filename: string,
   md5: string,
   byteSize: number,
   processor: z.infer<typeof FileProcessor>,
-  doUpload: (id: string) => Promise<void>,
+  doUpload: (id: string) => IteratorWithPromise<UploadChunkEvent>,
 ) => {
   log("Processing", { filename, md5, byteSize, processor });
 
-  const unprocessedFile = await createUnprocessedFile(client, {
+  const createFilePromise = createUnprocessedFile(client, {
     md5: md5,
     processes: [],
     filename,
     byte_size: byteSize,
   });
 
-  if (unprocessedFile.complete === false) {
-    await doUpload(unprocessedFile.id);
-  }
-
-  if (unprocessedFile.processes.includes(processor)) {
-    log("File already processed", unprocessedFile);
-    return unprocessedFile;
-  }
-
-  const fileInformation = await updateUnprocessedFile(
-    client,
-    unprocessedFile.id,
-    {
-      processes: [processor],
+  return {
+    async *progress() {
+      const unprocessedFile = await createFilePromise;
+      if (unprocessedFile.complete) {
+        yield { type: "progress", progress: 0 };
+        yield { type: "progress", progress: 1 };
+      }
+      yield* doUpload(unprocessedFile.id);
     },
-  );
-  log("File processed", fileInformation);
-  return fileInformation;
+    file: async () => {
+      const unprocessedFile = await createFilePromise;
+      if (unprocessedFile.complete) {
+        return unprocessedFile;
+      }
+      await doUpload(unprocessedFile.id).whenUploaded();
+      const fileInformation = await updateUnprocessedFile(
+        client,
+        unprocessedFile.id,
+        {
+          processes: [processor],
+        },
+      );
+      log("File processed", fileInformation);
+      return fileInformation;
+    },
+  };
 };
 
 const buildBufferProcessor = (processor: z.infer<typeof FileProcessor>) => {
-  return async (client: Client, buffer: Buffer, filename = "buffer") => {
+  return (client: Client, buffer: Buffer, filename = "buffer") => {
     log(`Processing file buffer: ${processor}`, filename);
     const md5 = md5Buffer(buffer);
 
-    return await processResource(
+    return processResource(
       client,
       filename,
       md5,
       buffer.byteLength,
       processor,
-      async (id: string) => {
+      (id: string) => {
         const readStream = new Readable({
           read() {
             readStream.push(buffer);
@@ -191,29 +202,35 @@ const buildBufferProcessor = (processor: z.infer<typeof FileProcessor>) => {
           },
         });
 
-        await uploadUnprocessedFile(client, id, readStream, buffer.byteLength);
+        return uploadUnprocessedFile(client, id, readStream, buffer.byteLength);
       },
     );
   };
 };
 
 const buildFileProcessor = (processor: z.infer<typeof FileProcessor>) => {
-  return async (client: Client, filePath: string) => {
-    log(`Processing file ${processor}`, filePath);
-    const md5 = await md5FilePath(filePath);
-    const byteSize = (await stat(filePath)).size;
-
-    return await processResource(
-      client,
-      basename(filePath),
-      md5,
-      byteSize,
-      processor,
-      async (id: string) => {
-        const readStream = createReadStream(filePath);
-        return await uploadUnprocessedFile(client, id, readStream, byteSize);
-      },
-    );
+  return (client: Client, filePath: string) => {
+    const processPromise = async () => {
+      const [md5, { size: byteSize }] = await Promise.all([
+        md5FilePath(filePath),
+        stat(filePath),
+      ]);
+      return processResource(
+        client,
+        basename(filePath),
+        md5,
+        byteSize,
+        processor,
+        (id: string) => {
+          const readStream = createReadStream(filePath);
+          return uploadUnprocessedFile(client, id, readStream, byteSize);
+        },
+      );
+    };
+    return {
+      progress: async () => (await processPromise()).progress(),
+      file: async () => (await processPromise()).file(),
+    };
   };
 };