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

package/src/operations/syncAssetsDirectory/SyncTrack.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, test } from "vitest";
+import { fixture, withFixtures } from "../../../test-fixtures/fixture.ts";
+import {
+  mockCreateIsobmffFile,
+  mockCreateIsobmffTrack,
+  mockGetIsobmffTrackUpload,
+  useMSW,
+} from "../../../test-fixtures/network.ts";
+import { SyncTrack } from "./SyncTrack.ts";
+
+describe("SyncTrack", async () => {
+  const server = useMSW();
+  await withFixtures(
+    [fixture("test.mp4", "test.mp4")],
+    async ({ files: [video], generateTrack }) => {
+      test("Reads byte size", async () => {
+        const syncTrack = new SyncTrack(
+          await generateTrack(video!, 1),
+          video!.md5,
+        );
+        await expect(syncTrack.byteSize()).resolves.toEqual(26434);
+      });
+      describe("prepare()", () => {
+        test("Creates ISOBMFF file", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: video!,
+            }),
+          );
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await syncTrack.prepare();
+          expect(syncTrack.isoFile).toBeDefined();
+        });
+
+        test("Probes track", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: video!,
+            }),
+          );
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await syncTrack.prepare();
+          expect(syncTrack.probeResult).toBeDefined();
+        });
+      });
+
+      describe("validate()", () => {
+        test("throws when prepare() is not called", async () => {
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await expect(syncTrack.validate()).rejects.toThrow();
+        });
+
+        test.skip("throws when track has bad duration", async () => {});
+        test.skip("throws when track has bad codec_type", async () => {});
+        test.skip("throws when no isoFile exists", async () => {});
+      });
+
+      describe(".create()", () => {
+        test("throws if prepare() is not called", async () => {
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await expect(syncTrack.create()).rejects.toThrow();
+        });
+
+        test("isComplete() returns false when not complete", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: video!,
+            }),
+            mockCreateIsobmffTrack({
+              complete: false,
+              id: "track-1",
+              fileId: "123",
+              fixture: video!,
+            }),
+          );
+
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await syncTrack.prepare();
+          await syncTrack.create();
+          expect(syncTrack.isComplete()).toBe(false);
+        });
+
+        test("isComplete() returns true when complete", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: video!,
+            }),
+            mockCreateIsobmffTrack({
+              complete: true,
+              id: "track-1",
+              fileId: "123",
+              fixture: video!,
+            }),
+          );
+
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await syncTrack.prepare();
+          await syncTrack.create();
+          expect(syncTrack.isComplete()).toBe(true);
+        });
+      });
+
+      describe(".upload()", () => {
+        test("throws when not created", async () => {
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await expect(syncTrack.upload()).rejects.toThrow();
+        });
+        test("uploads track", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: video!,
+            }),
+            mockCreateIsobmffTrack({
+              complete: true,
+              id: "track-1",
+              fileId: "123",
+              fixture: video!,
+            }),
+            mockGetIsobmffTrackUpload({
+              complete: true,
+              id: "track-1",
+              trackId: 1,
+              fileId: "123",
+            }),
+          );
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await syncTrack.prepare();
+          await syncTrack.create();
+          await expect(syncTrack.upload()).resolves.toBeUndefined();
+        });
+      });
+      describe(".markSynced()", () => {
+        test("throws when not created", async () => {
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await expect(syncTrack.markSynced()).rejects.toThrow();
+        });
+        test("marks synced", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              fixture: video!,
+            }),
+            mockCreateIsobmffTrack({
+              complete: true,
+              id: "track-1",
+              fileId: "123",
+              fixture: video!,
+            }),
+          );
+          const syncTrack = new SyncTrack(
+            await generateTrack(video!, 1),
+            video!.md5,
+          );
+          await syncTrack.prepare();
+          await syncTrack.create();
+          await syncTrack.markSynced();
+          await expect(syncTrack.syncStatus.isSynced()).resolves.toBe(true);
+          await expect(syncTrack.syncStatus.readInfo()).resolves.toEqual({
+            version: "1",
+            complete: true,
+            id: "123:track-1",
+            md5: video!.md5,
+            asset_id: `${video!.md5}:test.mp4`,
+            byte_size: 26434,
+          });
+
+          await expect(syncTrack.fileSyncStatus.readInfo()).resolves.toEqual({
+            version: "1",
+            complete: true,
+            id: "123",
+            md5: video!.md5,
+            asset_id: `${video!.md5}:test.mp4`,
+            byte_size: 26434,
+          });
+        });
+      });
+    },
+  );
+});

package/src/operations/syncAssetsDirectory/SyncTrack.ts

@@ -0,0 +1,164 @@
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import type { z } from "zod";
+
+import {
+  type CreateISOBMFFFileResult,
+  type CreateISOBMFFTrackPayload,
+  type CreateISOBMFFTrackResult,
+  createISOBMFFFile,
+  createISOBMFFTrack,
+  uploadISOBMFFTrack,
+} from "@editframe/api";
+import { Probe } from "@editframe/assets";
+
+import { getClient } from "../../utils/index.ts";
+import type { SubAssetSync } from "./SubAssetSync.ts";
+import { SyncStatus } from "./SyncStatus.ts";
+
+export class SyncTrack implements SubAssetSync<CreateISOBMFFTrackResult> {
+  icon = "📼";
+  label = "track";
+  syncStatus: SyncStatus = new SyncStatus(this.path);
+  fileSyncStatus: SyncStatus = new SyncStatus(
+    join(dirname(this.path), "isobmff"),
+  );
+  created: CreateISOBMFFTrackResult | null = null;
+
+  constructor(
+    public path: string,
+    public md5: string,
+  ) {}
+
+  private _isoFile: CreateISOBMFFFileResult | null = null;
+
+  get isoFile() {
+    if (this._isoFile) {
+      return this._isoFile;
+    }
+    throw new Error("ISOBMFF file not found. Call prepare() first.");
+  }
+
+  async byteSize() {
+    return (await fs.stat(this.path)).size;
+  }
+
+  private _probeResult: Probe | null = null;
+  get probeResult() {
+    if (this._probeResult) {
+      return this._probeResult;
+    }
+    throw new Error("Probe result not found. Call prepare() first.");
+  }
+
+  get track() {
+    const [track] = this.probeResult.streams;
+    if (track) {
+      return track;
+    }
+    throw new Error(`No track found in track: ${this.path}`);
+  }
+
+  async prepare() {
+    this._isoFile = await createISOBMFFFile(getClient(), {
+      md5: this.md5,
+      filename: this.path.replace(/\.track-[\d]+.mp4$/, ""),
+    });
+    this._probeResult = await Probe.probePath(this.path);
+  }
+
+  get trackId() {
+    const trackId = this.path.match(/track-([\d]+).mp4/)?.[1];
+    if (!trackId) {
+      throw new Error(`No track ID  found for track: ${this.path}`);
+    }
+    return trackId;
+  }
+
+  get trackDuration() {
+    const track = this.track;
+    if (!track.duration) {
+      throw new Error(`No duration found in track: ${this.path}`);
+    }
+    return track.duration;
+  }
+
+  async validate() {
+    this.trackId;
+    this.isoFile;
+    this.trackDuration;
+  }
+
+  async create(): Promise<void> {
+    const track = this.track;
+    const isoFile = this.isoFile;
+
+    const createPayload: z.infer<typeof CreateISOBMFFTrackPayload> =
+      track.codec_type === "audio"
+        ? {
+            type: track.codec_type,
+            file_id: isoFile.id,
+            track_id: Number(this.trackId),
+            probe_info: track,
+            duration_ms: Math.round(this.trackDuration * 1000),
+            codec_name: track.codec_name,
+            byte_size: await this.byteSize(),
+          }
+        : {
+            type: track.codec_type,
+            file_id: isoFile.id,
+            track_id: Number(this.trackId),
+            probe_info: track,
+            duration_ms: Math.round(this.trackDuration * 1000),
+            codec_name: track.codec_name,
+            byte_size: await this.byteSize(),
+          };
+
+    this.created = await createISOBMFFTrack(getClient(), createPayload);
+  }
+  isComplete() {
+    return !!this.created?.complete;
+  }
+  async upload() {
+    if (!this.created) {
+      throw new Error(
+        "Track not created. Should have been prevented by .isComplete()",
+      );
+    }
+    return uploadISOBMFFTrack(
+      getClient(),
+      this.isoFile.id,
+      Number(this.trackId),
+      createReadStream(this.path),
+      this.created?.byte_size,
+    );
+  }
+  async markSynced() {
+    if (!this.created) {
+      throw new Error(
+        "Track not created. Should have been prevented by .isComplete()",
+      );
+    }
+    const byteSize = await this.byteSize();
+    await Promise.all([
+      this.syncStatus.markSynced({
+        version: "1",
+        complete: true,
+        id: `${this.created.file_id}:${this.created.track_id}`,
+        md5: this.md5,
+        asset_id: this.created.asset_id,
+        byte_size: byteSize,
+      }),
+      this.fileSyncStatus.markSynced({
+        version: "1",
+        complete: true,
+        id: this.created.file_id,
+        md5: this.md5,
+        asset_id: this.created.asset_id,
+        byte_size: byteSize,
+      }),
+    ]);
+  }
+}

package/src/operations/syncAssetsDirectory/doAssetSync.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, test, vi } from "vitest";
+import type { SubAssetSync } from "./SubAssetSync.ts";
+import type { SyncStatusInfo } from "./SyncStatus.ts";
+import { doAssetSync } from "./doAssetSync.ts";
+
+const collectAsyncGenerator = async (
+  generator: SubAssetSync<unknown>,
+): Promise<
+  {
+    status: "info" | "success";
+    message: string;
+  }[]
+> => {
+  const result = [];
+  for await (const item of doAssetSync(generator)) {
+    result.push(item);
+  }
+  return result;
+};
+
+const buildFakeSync = (): SubAssetSync<unknown> => {
+  const fakeSyncStatus = {
+    isSynced: vi.fn().mockReturnValue(false),
+  } as unknown as SyncStatusInfo;
+  const fakeSync = {
+    label: "TEST_LABEL",
+    icon: "🧪",
+    path: "TEST_PATH",
+    readInfo: vi.fn().mockReturnValue(Promise.resolve(null)),
+    syncStatus: fakeSyncStatus,
+    markSynced: vi.fn().mockReturnValue(Promise.resolve()),
+    isComplete: vi.fn().mockReturnValue(false),
+    prepare: vi.fn().mockReturnValue(Promise.resolve()),
+    validate: vi.fn().mockReturnValue(Promise.resolve()),
+    create: vi.fn().mockReturnValue(Promise.resolve()),
+    upload: vi.fn().mockReturnValue(Promise.resolve()),
+  } as unknown as SubAssetSync<unknown>;
+  return fakeSync;
+};
+
+describe("doAssetSync", () => {
+  test("Succeeds if all steps are executed without error", async () => {
+    const fakeSync = buildFakeSync();
+    const messages = await collectAsyncGenerator(fakeSync);
+    expect(messages).toEqual([
+      {
+        status: "info",
+        message: "🧪  Syncing TEST_LABEL: TEST_PATH",
+      },
+      {
+        status: "success",
+        message: "Synced TEST_LABEL: TEST_PATH",
+      },
+    ]);
+  });
+
+  test("Succeeds if asset is already synced", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.syncStatus.isSynced = vi.fn().mockReturnValue(true);
+    const messages = await collectAsyncGenerator(fakeSync);
+    expect(messages).toEqual([
+      {
+        status: "info",
+        message: "Sub-asset has already been synced: TEST_PATH",
+      },
+    ]);
+  });
+
+  test("Succeeds if asset is already uploaded", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.isComplete = vi.fn().mockReturnValue(true);
+    const messages = await collectAsyncGenerator(fakeSync);
+    expect(messages).toEqual([
+      {
+        status: "info",
+        message: "🧪  Syncing TEST_LABEL: TEST_PATH",
+      },
+      {
+        status: "success",
+        message: "Synced TEST_LABEL: TEST_PATH",
+      },
+    ]);
+  });
+
+  test("Throws if prepare fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.prepare = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error validating TEST_LABEL: TEST_ERROR",
+    );
+  });
+
+  test("Throws if validate fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.validate = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error validating TEST_LABEL: TEST_ERROR",
+    );
+  });
+
+  test("Throws if create fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.create = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error creating TEST_LABEL: TEST_ERROR",
+    );
+  });
+
+  test("Throws if upload fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.upload = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error uploading TEST_LABEL: TEST_ERROR",
+    );
+  });
+
+  test("Throws if markSynced fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.markSynced = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error marking TEST_LABEL as synced: TEST_ERROR",
+    );
+  });
+});

package/src/operations/syncAssetsDirectory/doAssetSync.ts

@@ -0,0 +1,62 @@
+import type { SubAssetSync } from "./SubAssetSync.ts";
+
+export const doAssetSync = async function* (
+  assetSync: SubAssetSync<unknown>,
+): AsyncGenerator<{
+  status: "info" | "success";
+  message: string;
+}> {
+  if (await assetSync.syncStatus.isSynced()) {
+    yield {
+      status: "info",
+      message: `Sub-asset has already been synced: ${assetSync.path}`,
+    };
+    return;
+  }
+
+  try {
+    await assetSync.prepare();
+    await assetSync.validate();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+
+    throw new Error(`Error validating ${assetSync.label}: ${message}`);
+  }
+
+  yield {
+    status: "info",
+    message: `${assetSync.icon}  Syncing ${assetSync.label}: ${assetSync.path}`,
+  };
+
+  try {
+    await assetSync.create();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+
+    throw new Error(`Error creating ${assetSync.label}: ${message}`);
+  }
+
+  if (!assetSync.isComplete()) {
+    try {
+      await assetSync.upload();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+
+      throw new Error(`Error uploading ${assetSync.label}: ${message}`);
+    }
+  }
+
+  try {
+    await assetSync.markSynced();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+
+    throw new Error(`Error marking ${assetSync.label} as synced: ${message}`);
+  }
+
+  yield {
+    status: "success",
+    message: `Synced ${assetSync.label}: ${assetSync.path}`,
+  };
+  return;
+};