@editframe/api 0.11.0-beta.9 → 0.12.0-beta.2

package/src/resources/unprocessed-file.ts

@@ -1,69 +1,37 @@
-import { createReadStream } from "node:fs";
-import { stat } from "node:fs/promises";
-import { basename } from "node:path";
-import { Readable } from "node:stream";
-
 import debug from "debug";
 import { z } from "zod";
 
-import { md5Buffer, md5FilePath } from "@editframe/assets";
-
 import type { Client } from "../client.ts";
-import {
-  type IteratorWithPromise,
-  type UploadChunkEvent,
-  uploadChunks,
-} from "../uploadChunks.ts";
+import { uploadChunks } from "../uploadChunks.ts";
 
 const log = debug("ef:api:unprocessed-file");
 
-const FileProcessor = z.union([
-  z.literal("isobmff"),
-  z.literal("image"),
-  z.literal("captions"),
-  z.string(),
-]);
-
-const FileProcessors = z.array(FileProcessor).refine(
-  (value) => {
-    return new Set(value).size === value.length;
-  },
-  {
-    message: "Processors list must not include duplicates",
-  },
-);
-
 const MAX_FILE_SIZE = 1024 * 1024 * 1024; // 1GiB
 
 export const CreateUnprocessedFilePayload = z.object({
   md5: z.string(),
   filename: z.string(),
-  processes: FileProcessors.optional(),
   byte_size: z.number().int().max(MAX_FILE_SIZE),
 });
 
-export const UpdateUnprocessedFilePayload = z.object({
-  processes: FileProcessors.optional(),
-});
+export const UpdateUnprocessedFilePayload = z.object({});
 
-export interface CreateUnprocessedFileResult {
+interface UnprocessedFile {
   byte_size: number;
   next_byte: number;
   complete: boolean;
   id: string;
   md5: string;
-  processes: z.infer<typeof FileProcessors> & string[];
-  asset_id: string;
 }
 
-export interface UpdateUnprocessedFileResult {
-  byte_size?: number;
-  next_byte: number;
-  complete: boolean;
+export interface CreateUnprocessedFileResult extends UnprocessedFile {}
+
+export interface LookupUnprocessedFileByMd5Result extends UnprocessedFile {}
+
+export interface UpdateUnprocessedFileResult extends UnprocessedFile {}
+
+export interface ProcessIsobmffFileResult {
   id: string;
-  md5: string;
-  processes: z.infer<typeof FileProcessors>;
-  asset_id: string;
 }
 
 export const createUnprocessedFile = async (
@@ -96,36 +64,10 @@ export const createUnprocessedFile = async (
   );
 };
 
-export const updateUnprocessedFile = async (
-  client: Client,
-  fileId: string,
-  payload: Partial<z.infer<typeof UpdateUnprocessedFilePayload>>,
-) => {
-  log("Updating unprocessed file", fileId, payload);
-  UpdateUnprocessedFilePayload.parse(payload);
-  const response = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/${fileId}`,
-    {
-      method: "POST",
-      body: JSON.stringify(payload),
-    },
-  );
-
-  log("Unprocessed file updated", response);
-
-  if (response.ok) {
-    return (await response.json()) as UpdateUnprocessedFileResult;
-  }
-
-  throw new Error(
-    `Failed to update unprocessed file ${response.status} ${response.statusText}`,
-  );
-};
-
 export const uploadUnprocessedFile = (
   client: Client,
   fileId: string,
-  fileStream: Readable,
+  fileStream: ReadableStream,
   fileSize: number,
 ) => {
   log("Uploading unprocessed file", fileId);
@@ -138,104 +80,46 @@ export const uploadUnprocessedFile = (
   });
 };
 
-const processResource = (
+export const lookupUnprocessedFileByMd5 = async (
   client: Client,
-  filename: string,
   md5: string,
-  byteSize: number,
-  processor: z.infer<typeof FileProcessor>,
-  doUpload: (id: string) => IteratorWithPromise<UploadChunkEvent>,
-) => {
-  log("Processing", { filename, md5, byteSize, processor });
+): Promise<LookupUnprocessedFileByMd5Result | null> => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/md5/${md5}`,
+    {
+      method: "GET",
+    },
+  );
 
-  const createFilePromise = createUnprocessedFile(client, {
-    md5: md5,
-    processes: [],
-    filename,
-    byte_size: byteSize,
-  });
+  if (response.ok) {
+    return (await response.json()) as LookupUnprocessedFileByMd5Result;
+  }
 
-  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;
-    },
-  };
-};
+  if (response.status === 404) {
+    return null;
+  }
 
-const buildBufferProcessor = (processor: z.infer<typeof FileProcessor>) => {
-  return (client: Client, buffer: Buffer, filename = "buffer") => {
-    log(`Processing file buffer: ${processor}`, filename);
-    const md5 = md5Buffer(buffer);
-
-    return processResource(
-      client,
-      filename,
-      md5,
-      buffer.byteLength,
-      processor,
-      (id: string) => {
-        const readStream = new Readable({
-          read() {
-            readStream.push(buffer);
-            readStream.push(null);
-          },
-        });
-
-        return uploadUnprocessedFile(client, id, readStream, buffer.byteLength);
-      },
-    );
-  };
+  throw new Error(
+    `Failed to lookup unprocessed file by md5 ${md5} ${response.status} ${response.statusText}`,
+  );
 };
 
-const buildFileProcessor = (processor: z.infer<typeof FileProcessor>) => {
-  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(),
-    };
-  };
-};
+export const processIsobmffFile = async (
+  client: Client,
+  unprocessedFileId: LookupUnprocessedFileByMd5Result["id"],
+) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/${unprocessedFileId}/isobmff`,
+    {
+      method: "POST",
+    },
+  );
 
-export const processAVFileBuffer = buildBufferProcessor("isobmff");
-export const processAVFile = buildFileProcessor("isobmff");
+  if (response.ok) {
+    return (await response.json()) as ProcessIsobmffFileResult;
+  }
 
-export const processImageFileBuffer = buildBufferProcessor("image");
-export const processImageFile = buildFileProcessor("image");
+  throw new Error(
+    `Failed to process isobmff file ${response.status} ${response.statusText}`,
+  );
+};