@editframe/cli 0.10.0-beta.5 → 0.10.0-beta.6

package/src/operations/syncAssetsDirectory.ts

@@ -1,63 +1,16 @@
-import { Probe } from "@editframe/assets";
 import fs from "node:fs/promises";
 import path from "node:path";
-import {
-  createCaptionFile,
-  createImageFile,
-  createISOBMFFFile,
-  createISOBMFFTrack,
-  uploadCaptionFile,
-  uploadFragmentIndex,
-  uploadImageFile,
-  uploadISOBMFFTrack,
-  type CreateISOBMFFTrackPayload,
-} from "@editframe/api";
-import { statSync } from "node:fs";
-
-import { createReadStream } from "node:fs";
-import type { z } from "zod";
-import { getClient } from "../utils/index.ts";
-
-const imageMatch = /\.(png|jpe?g|gif|webp)$/i;
-const trackMatch = /\.track-[\d]+.mp4$/i;
-const fragmentIndexMatch = /\.tracks.json$/i;
-const captionsMatch = /\.captions.json$/i;
-
-class SyncStatus {
-  constructor(private assetPath: string) {}
-
-  infoPath = `${this.assetPath}.info`;
-
-  async isSynced() {
-    const result = await fs.stat(this.infoPath).catch((error) => {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    });
-    return !!result;
-  }
-
-  async markSynced() {
-    process.stderr.write(`✏️  Marking asset as synced: ${this.assetPath}\n`);
-    await fs.writeFile(this.infoPath, "{}", "utf-8");
-  }
-}
+import { getAssetSync } from "./syncAssetsDirectory/SubAssetSync.ts";
+import { doAssetSync } from "./syncAssetsDirectory/doAssetSync.ts";
 
 export const syncAssetDirectory = async (
-  /** Project directory will be used as the base to find an assets directory.
+  /**
+   * Project directory will be used as the base to find an assets directory.
    * Assets will be synced from `<projectDirectory>/src/assets`
    */
-  projectDirectory: string,
+  cacheDir: string,
 ) => {
-  const fullPath = path.join(
-    process.cwd(),
-    projectDirectory,
-    "src",
-    "assets",
-    ".cache",
-  );
-  const stat = await fs.stat(fullPath).catch((error) => {
+  const stat = await fs.stat(cacheDir).catch((error) => {
     if (error.code === "ENOENT") {
       return;
     }
@@ -65,12 +18,12 @@ export const syncAssetDirectory = async (
   });
 
   if (!stat?.isDirectory()) {
-    console.error(`No assets cache directory found at ${fullPath}`);
+    console.error(`No assets cache directory found at ${cacheDir}`);
     return;
   }
-  const assets = await fs.readdir(fullPath);
+  const assets = await fs.readdir(cacheDir);
 
-  process.stderr.write(`Syncing asset dir: ${fullPath}\n`);
+  process.stderr.write(`Syncing asset dir: ${cacheDir}\n`);
 
   const errors: Record<string, string[]> = {};
 
@@ -90,7 +43,7 @@ export const syncAssetDirectory = async (
 
   for (const assetMd5 of assets) {
     reportInfo(assetMd5, `Syncing asset: ${assetMd5}`);
-    const assetDir = path.join(fullPath, assetMd5);
+    const assetDir = path.join(cacheDir, assetMd5);
     const stat = await fs.stat(assetDir);
     if (!stat.isDirectory()) {
       reportError(assetMd5, "Invalid asset. Did not find asset directory.");
@@ -104,235 +57,21 @@ export const syncAssetDirectory = async (
         continue;
       }
       const subAssetPath = path.join(assetDir, subAsset);
-      const syncStatus = new SyncStatus(subAssetPath);
-      if (await syncStatus.isSynced()) {
-        reportInfo(
-          subAsset,
-          `✔ Sub-asset has already been synced: ${subAsset}`,
-        );
-        continue;
-      }
-      switch (true) {
-        case imageMatch.test(subAsset): {
-          const probeResult = await Probe.probePath(subAssetPath);
-          const [videoProbe] = probeResult.videoStreams;
-          const { format } = probeResult;
-          if (!videoProbe) {
-            reportError(subAsset, `No media info found in image: ${subAsset}`);
-            break;
-          }
-          const ext = path.extname(subAsset).slice(1);
-          if (
-            !(
-              ext === "jpg" ||
-              ext === "jpeg" ||
-              ext === "png" ||
-              ext === "webp"
-            )
-          ) {
-            reportError(subAsset, `Invalid image format: ${subAsset}`);
-            break;
-          }
-          reportInfo(subAsset, `🖼️  Syncing image: ${subAsset}`);
-          const created = await createImageFile(getClient(), {
-            md5: assetMd5,
-            filename: subAsset,
-            width: videoProbe.width,
-            height: videoProbe.height,
-            mime_type: `image/${ext}`,
-            byte_size: (await fs.stat(subAssetPath)).size,
-          });
-          if (created) {
-            if (created.complete) {
-              reportInfo(subAsset, " ✔ Image has already been synced");
-              await syncStatus.markSynced();
-            } else {
-              await uploadImageFile(
-                getClient(),
-                created.id,
-                createReadStream(subAssetPath),
-                Number.parseInt(format.size || "0"),
-              )
-                .then(() => {
-                  reportSuccess(subAsset, "Image has been synced.");
-                  return syncStatus.markSynced();
-                })
-                .catch((error) => {
-                  reportError(
-                    subAsset,
-                    `Error uploading image: ${error.message}`,
-                  );
-                });
-            }
-          }
-          break;
-        }
-        case trackMatch.test(subAsset): {
-          reportInfo(subAsset, `📼 Syncing a/v track: ${subAsset}`);
-          const createdFile = await createISOBMFFFile(getClient(), {
-            md5: assetMd5,
-            filename: subAsset.replace(/\.track-[\d]+.mp4$/, ""),
-          });
-          if (createdFile) {
-            const probe = await Probe.probePath(subAssetPath);
-            const trackId = subAsset.match(/track-([\d]+).mp4/)?.[1];
-            if (!trackId) {
-              reportError(subAsset, `No track ID found for track: ${subAsset}`);
-              break;
-            }
-            const [track] = probe.streams;
-            if (!track) {
-              reportError(
-                subAsset,
-                `No track stream found in track: ${subAsset}`,
-              );
-              break;
-            }
-            if (track.duration === undefined) {
-              reportError(subAsset, `No duration found in track: ${subAsset}`);
-              break;
-            }
-
-            const stat = await fs.stat(subAssetPath);
-
-            /**
-             * Because the payload is a discriminated union, we need to create these objects
-             * only after the value for type has been narrowed, otherwise the object will
-             * have type: "audio" | "video" which doesnt' match the payload type that
-             * looks more like { type: "audio", ... } | { type: "video", ... }
-             */
-            const createPayload: z.infer<typeof CreateISOBMFFTrackPayload> =
-              track.codec_type === "audio"
-                ? {
-                    type: track.codec_type,
-                    file_id: createdFile.id,
-                    track_id: Number(trackId),
-                    probe_info: track,
-                    duration_ms: Math.round(track.duration * 1000),
-                    codec_name: track.codec_name,
-                    byte_size: stat.size,
-                  }
-                : {
-                    type: track.codec_type,
-                    file_id: createdFile.id,
-                    track_id: Number(trackId),
-                    probe_info: track,
-                    duration_ms: Math.round(track.duration * 1000),
-                    codec_name: track.codec_name,
-                    byte_size: stat.size,
-                  };
-            const createdTrack = await createISOBMFFTrack(
-              getClient(),
-              createPayload,
-            );
 
-            if (createdTrack) {
-              if (createdTrack.next_byte === createdTrack.byte_size) {
-                reportInfo(subAsset, "✔ Track has already been synced.");
-                await syncStatus.markSynced();
-              } else {
-                await uploadISOBMFFTrack(
-                  getClient(),
-                  createdFile.id,
-                  Number(trackId),
-                  createReadStream(subAssetPath),
-                  createdTrack.byte_size,
-                )
-                  .then(() => {
-                    reportSuccess(subAsset, "Track has been synced.");
-                    return syncStatus.markSynced();
-                  })
-                  .catch((error) => {
-                    reportError(
-                      subAsset,
-                      `Error uploading track: ${error.message}`,
-                    );
-                  });
-              }
-            }
-          }
-
-          break;
-        }
-        case fragmentIndexMatch.test(subAsset): {
-          reportInfo(subAsset, `📋 Syncing fragment index: ${subAsset}`);
-          const createdFile = await createISOBMFFFile(getClient(), {
-            md5: assetMd5,
-            filename: subAsset.replace(/\.tracks.json$/, ""),
-          });
-          if (createdFile) {
-            if (createdFile.fragment_index_complete) {
-              reportInfo(subAsset, "✔ Fragment index has already been synced.");
-              await syncStatus.markSynced();
-            } else {
-              const stats = statSync(subAssetPath);
-              const readStream = createReadStream(subAssetPath);
-              await uploadFragmentIndex(
-                getClient(),
-                createdFile.id,
-                readStream,
-                stats.size,
-              )
-                .then(() => {
-                  reportSuccess(subAsset, "Fragment index has been synced.");
-                  return syncStatus.markSynced();
-                })
-                .catch((error) => {
-                  reportError(
-                    subAsset,
-                    `Error uploading fragment index: ${error.message}`,
-                  );
-                });
-            }
-          } else {
-            reportError(
-              subAsset,
-              `No file found for fragment index: ${subAsset}`,
-            );
-            break;
-          }
-          break;
-        }
-        case captionsMatch.test(subAsset): {
-          reportInfo(subAsset, `📝 Syncing captions: ${subAsset}`);
-          const createdFile = await createCaptionFile(getClient(), {
-            md5: assetMd5,
-            filename: subAsset.replace(/\.captions.json$/, ""),
-            byte_size: (await fs.stat(subAsset)).size,
-          });
-          if (createdFile) {
-            if (createdFile.complete) {
-              reportInfo(subAsset, "✔ Captions have already been synced.");
-              await syncStatus.markSynced();
-            } else {
-              const readStream = createReadStream(subAssetPath);
-              const stats = statSync(subAssetPath);
-              await uploadCaptionFile(
-                getClient(),
-                createdFile.id,
-                readStream,
-                stats.size,
-              )
-                .then(() => {
-                  reportSuccess(subAsset, "Captions have been synced.");
-                  return syncStatus.markSynced();
-                })
-                .catch((error) => {
-                  reportError(
-                    subAsset,
-                    `Error uploading captions: ${error.message}`,
-                  );
-                });
-            }
-          } else {
-            reportError(subAsset, `No file found for captions: ${subAsset}`);
-            break;
+      try {
+        const assetSync = getAssetSync(subAssetPath, assetMd5);
+        for await (const { status, message } of doAssetSync(assetSync)) {
+          if (status === "success") {
+            reportSuccess(subAsset, message);
+          } else if (status === "info") {
+            reportInfo(subAsset, message);
           }
-          break;
         }
-        default: {
-          reportError(subAsset, `Unknown sub-asset: ${subAsset}`);
-          break;
+      } catch (error) {
+        if (error instanceof Error) {
+          reportError(subAsset, error.message);
+        } else {
+          reportError(subAsset, "Unknown error");
         }
       }
     }

package/src/utils/index.ts

@@ -7,7 +7,10 @@ let client: Client;
 export const getClient = () => {
   if (!client) {
     const programOpts = program.opts();
-    client = new Client(programOpts.token, programOpts.efHost);
+    client = new Client(
+      programOpts.token || process.env.EF_TOKEN,
+      programOpts.efHost || process.env.EF_HOST,
+    );
   }
   return client;
 };

package/test-fixtures/fixture.ts

@@ -0,0 +1,141 @@
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { v4 } from "uuid";
+import { expect } from "vitest";
+
+import { md5Buffer } from "@editframe/assets";
+
+import { syncAssetDirectory } from "../src/operations/syncAssetsDirectory.ts";
+import type { SyncStatusInfo } from "../src/operations/syncAssetsDirectory/SyncStatus.ts";
+
+export const fixture = async (
+  fixture: string,
+  name: string,
+): Promise<Fixture> => {
+  const originalPath = join(__dirname, fixture);
+  const content = await readFile(originalPath);
+  return {
+    name,
+    fixture,
+    content,
+    originalPath,
+    md5: md5Buffer(content),
+    write: async (dir: string) => {
+      await writeFile(join(dir, name), content);
+    },
+  };
+};
+export interface Fixture {
+  name: string;
+  fixture: string;
+  md5: string;
+  content: Buffer;
+  originalPath: string;
+  write: (dir: string) => Promise<void>;
+}
+export const withFixtures = async (
+  fixtures: Promise<Fixture>[],
+  fn: (props: {
+    files: Fixture[];
+    rootDir: string;
+    srcDir: string;
+    assetsDir: string;
+    cacheDir: string;
+    expectCacheFiles: (fixture: Fixture, files: string[]) => Promise<void>;
+    expectInfoFileContent: (
+      fileName: string,
+      fixture: Fixture,
+      expectedContent: Pick<SyncStatusInfo, "complete" | "id"> & {
+        byte_size?: number;
+      },
+    ) => Promise<void>;
+    syncAssetsDirectory: () => Promise<void>;
+    cacheImage: (fixture: Fixture) => Promise<string>;
+    generateTrack: (fixture: Fixture, trackId: number) => Promise<string>;
+    generateTrackFragmentIndex: (fixture: Fixture) => Promise<string>;
+    generateCaptions: (fixture: Fixture) => Promise<string>;
+  }) => Promise<void>,
+) => {
+  const files = await Promise.all(fixtures);
+  const tempDir = `${tmpdir()}/${v4()}`;
+  const srcDir = join(tempDir, "src");
+  const assetsDir = join(srcDir, "assets");
+  const cacheDir = join(assetsDir, ".cache");
+  await mkdir(assetsDir, { recursive: true });
+  await Promise.all(files.map(async (file) => file.write(assetsDir)));
+
+  await fn({
+    files,
+    rootDir: tempDir,
+    srcDir,
+    assetsDir,
+    cacheDir,
+    expectCacheFiles: async (fixture, expectedFiles) => {
+      const files = await readdir(join(assetsDir, ".cache", fixture.md5));
+      expect(files).toEqual(expectedFiles);
+    },
+    expectInfoFileContent: async (fileName, fixture, expectedContent) => {
+      const filePath = join(cacheDir, fixture.md5, fileName);
+      const content = JSON.parse(await readFile(filePath, "utf-8"));
+      expect(content).toMatchObject({
+        asset_id: `${fixture.md5}:${fixture.name}`,
+        md5: fixture.md5,
+        version: "1",
+        byte_size: fixture.content.length,
+        ...expectedContent,
+      });
+    },
+    syncAssetsDirectory: () => {
+      return syncAssetDirectory(cacheDir);
+    },
+    cacheImage: async (fixture) => {
+      await mkdir(join(cacheDir, fixture.md5), { recursive: true });
+      const filePath = join(cacheDir, fixture.md5, fixture.name);
+      await writeFile(filePath, fixture.content);
+      return filePath;
+    },
+    generateTrack: async (fixture, trackId: number) => {
+      await mkdir(join(cacheDir, fixture.md5), { recursive: true });
+      const filePath = join(
+        cacheDir,
+        fixture.md5,
+        `${fixture.name}.track-${trackId}.mp4`,
+      );
+      await writeFile(filePath, fixture.content);
+      return filePath;
+    },
+    generateTrackFragmentIndex: async (fixture) => {
+      await mkdir(join(cacheDir, fixture.md5), { recursive: true });
+      const filePath = join(
+        cacheDir,
+        fixture.md5,
+        `${fixture.name}.tracks.json`,
+      );
+      await writeFile(
+        filePath,
+        JSON.stringify({
+          tracks: ["FAKE_TRACK_INDEX"],
+        }),
+      );
+      return filePath;
+    },
+    generateCaptions: async (fixture) => {
+      await mkdir(join(cacheDir, fixture.md5), { recursive: true });
+      const filePath = join(
+        cacheDir,
+        fixture.md5,
+        `${fixture.name}.captions.json`,
+      );
+      await writeFile(
+        filePath,
+        JSON.stringify({
+          captions: ["FAKE_CAPTION_INDEX"],
+        }),
+      );
+      return filePath;
+    },
+  });
+  await rm(tempDir, { recursive: true });
+};

package/test-fixtures/network.ts

@@ -0,0 +1,181 @@
+import { http, HttpResponse } from "msw";
+import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll } from "vitest";
+import type { Fixture } from "./fixture.ts";
+
+const server = setupServer();
+
+export const useMSW = () => {
+  beforeAll(() => {
+    server.listen();
+    process.env.EF_TOKEN = "ef_SECRET_TOKEN";
+    process.env.EF_HOST = "http://localhost:3000";
+  });
+  afterAll(() => server.close());
+  afterEach(() => server.resetHandlers());
+  return server;
+};
+
+export const mockCreateImageFile = ({
+  complete = true,
+  id = "123",
+  filename = "test.png",
+  fixture,
+}: { complete?: boolean; id?: string; filename?: string; fixture: Fixture }) =>
+  http.post(
+    "http://localhost:3000/api/v1/image_files",
+    async () => {
+      return HttpResponse.json({
+        id,
+        asset_id: `${fixture.md5}:${filename}`,
+        complete,
+      });
+    },
+    { once: true },
+  );
+
+export const mockGetUploadImageFile = ({
+  complete = true,
+  id = "123",
+  filename = "test.png",
+  fixture,
+}: { complete?: boolean; id?: string; filename?: string; fixture: Fixture }) =>
+  http.get(
+    `http://localhost:3000/api/v1/image_files/${id}/upload`,
+    async () => {
+      return HttpResponse.json({
+        id,
+        complete,
+        filename,
+        asset_id: `${fixture.md5}:${filename}`,
+      });
+    },
+  );
+
+export const mockCreateIsobmffFile = ({
+  complete = true,
+  id = "123",
+  filename = "test.mp4",
+  fixture,
+}: {
+  complete?: boolean;
+  id?: string;
+  filename?: string;
+  fixture: Fixture;
+}) =>
+  http.post(
+    "http://localhost:3000/api/v1/isobmff_files",
+    async () => {
+      return HttpResponse.json({
+        id,
+        asset_id: `${fixture.md5}:${filename}`,
+        fragment_index_complete: complete,
+      });
+    },
+    { once: true },
+  );
+
+export const mockCreateIsobmffTrack = ({
+  complete = true,
+  id = "123",
+  fileId = "123",
+  filename = "test.mp4",
+  fixture,
+}: {
+  complete?: boolean;
+  id?: string;
+  fileId?: string;
+  filename?: string;
+  fixture: Fixture;
+}) =>
+  http.post(
+    "http://localhost:3000/api/v1/isobmff_tracks",
+    async () => {
+      return HttpResponse.json({
+        id,
+        asset_id: `${fixture.md5}:${filename}`,
+        complete,
+        file_id: fileId,
+        track_id: id,
+      });
+    },
+    { once: true },
+  );
+
+export const mockGetIsobmffTrackUpload = ({
+  complete = true,
+  fileId = "123",
+  trackId = 1,
+  id = "123",
+}: {
+  complete?: boolean;
+  id?: string;
+  fileId?: string;
+  trackId?: number;
+}) =>
+  http.get(
+    `http://localhost:3000/api/v1/isobmff_tracks/${fileId}/${trackId}/upload`,
+    async () => {
+      return HttpResponse.json({
+        id,
+        complete,
+      });
+    },
+  );
+export const mockUploadIsobmffFileIndex = ({
+  complete = true,
+  id = "123",
+}: { complete?: boolean; id?: string }) =>
+  http.post(
+    "http://localhost:3000/api/v1/isobmff_files/123/index/upload",
+    async () => {
+      return HttpResponse.json({
+        id,
+        complete,
+      });
+    },
+    { once: true },
+  );
+
+export const mockCreateCaptionFile = ({
+  complete = true,
+  id = "123",
+  filename = "test.captions.json",
+  fixture,
+}: {
+  complete?: boolean;
+  id?: string;
+  filename?: string;
+  fixture: Fixture;
+}) =>
+  http.post(
+    "http://localhost:3000/api/v1/caption_files",
+    async () => {
+      return HttpResponse.json({
+        id,
+        complete,
+        asset_id: `${fixture.md5}:${filename}`,
+      });
+    },
+    { once: true },
+  );
+
+export const mockUploadCaptionFile = ({
+  complete = true,
+  id = "123",
+}: {
+  complete?: boolean;
+  id?: string;
+  filename?: string;
+  fixture: Fixture;
+}) =>
+  http.post(
+    "http://localhost:3000/api/v1/caption_files/123/upload",
+    async () => {
+      return HttpResponse.json({
+        id,
+        complete,
+      });
+    },
+    { once: true },
+  );

package/test-fixtures/test-captions.json

@@ -0,0 +1,9 @@
+{
+  "captions": [
+    {
+      "start_time": 0,
+      "end_time": 10,
+      "text": "Hello, world!"
+    }
+  ]
+}