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

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

@@ -0,0 +1,151 @@
+import { describe, expect, test } from "vitest";
+import { fixture, withFixtures } from "../../../test-fixtures/fixture.ts";
+import {
+  mockCreateIsobmffFile,
+  mockUploadIsobmffFileIndex,
+  useMSW,
+} from "../../../test-fixtures/network.ts";
+import { SyncFragmentIndex } from "./SyncFragmentIndex.ts";
+
+describe("SyncFragmentIndex", async () => {
+  const server = useMSW();
+  await withFixtures(
+    [fixture("test.mp4", "test.mp4")],
+    async ({ files: [video], generateTrackFragmentIndex }) => {
+      test("Reads byte size", async () => {
+        const syncFragmentIndex = new SyncFragmentIndex(
+          await generateTrackFragmentIndex(video!),
+          video!.md5,
+        );
+        await expect(syncFragmentIndex.byteSize()).resolves.toEqual(31);
+      });
+      test("prepare() is noop", async () => {
+        const syncFragmentIndex = new SyncFragmentIndex(
+          await generateTrackFragmentIndex(video!),
+          video!.md5,
+        );
+        await expect(syncFragmentIndex.prepare()).resolves.toBeUndefined();
+      });
+      test("validate() is noop", async () => {
+        const syncFragmentIndex = new SyncFragmentIndex(
+          await generateTrackFragmentIndex(video!),
+          video!.md5,
+        );
+        await expect(syncFragmentIndex.validate()).resolves.toBeUndefined();
+      });
+      describe(".create()", () => {
+        test("isComplete() returns false when not created", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: false,
+              id: "123",
+              filename: "test.mp4",
+              fixture: video!,
+            }),
+          );
+          const syncFragmentIndex = new SyncFragmentIndex(
+            await generateTrackFragmentIndex(video!),
+            video!.md5,
+          );
+          await syncFragmentIndex.create();
+          expect(syncFragmentIndex.isComplete()).toBe(false);
+        });
+        test("isComplete() returns true when created", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: video!,
+            }),
+          );
+          const syncFragmentIndex = new SyncFragmentIndex(
+            await generateTrackFragmentIndex(video!),
+            video!.md5,
+          );
+          await syncFragmentIndex.create();
+          expect(syncFragmentIndex.isComplete()).toBe(true);
+        });
+      });
+      describe(".upload()", () => {
+        test("throws when not created", async () => {
+          const syncFragmentIndex = new SyncFragmentIndex(
+            await generateTrackFragmentIndex(video!),
+            video!.md5,
+          );
+          await expect(syncFragmentIndex.upload()).rejects.toThrow();
+        });
+        test("uploads caption", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: video!,
+            }),
+            mockUploadIsobmffFileIndex({
+              id: "123",
+            }),
+          );
+          const syncFragmentIndex = new SyncFragmentIndex(
+            await generateTrackFragmentIndex(video!),
+            video!.md5,
+          );
+          await syncFragmentIndex.create();
+          await expect(syncFragmentIndex.upload()).resolves.toBeUndefined();
+        });
+      });
+      describe(".markSynced()", () => {
+        test("throws when not created", async () => {
+          const syncFragmentIndex = new SyncFragmentIndex(
+            await generateTrackFragmentIndex(video!),
+            video!.md5,
+          );
+          await expect(syncFragmentIndex.markSynced()).rejects.toThrow();
+        });
+        test("marks synced", async () => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              fixture: video!,
+            }),
+            mockUploadIsobmffFileIndex({
+              id: "123",
+            }),
+          );
+          const syncFragmentIndex = new SyncFragmentIndex(
+            await generateTrackFragmentIndex(video!),
+            video!.md5,
+          );
+          await syncFragmentIndex.create();
+          await syncFragmentIndex.markSynced();
+          await expect(syncFragmentIndex.syncStatus.isSynced()).resolves.toBe(
+            true,
+          );
+          await expect(
+            syncFragmentIndex.syncStatus.readInfo(),
+          ).resolves.toEqual({
+            version: "1",
+            complete: true,
+            id: "123",
+            md5: video!.md5,
+            asset_id: `${video!.md5}:test.mp4`,
+            byte_size: 31,
+          });
+
+          await expect(
+            syncFragmentIndex.fileSyncStatus.readInfo(),
+          ).resolves.toEqual({
+            version: "1",
+            complete: true,
+            id: "123",
+            md5: video!.md5,
+            asset_id: `${video!.md5}:test.mp4`,
+            byte_size: 31,
+          });
+        });
+      });
+    },
+  );
+});

package/src/operations/syncAssetsDirectory/SyncFragmentIndex.ts

@@ -0,0 +1,92 @@
+import fs from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Readable } from "node:stream";
+
+import {
+  type CreateISOBMFFFileResult,
+  createISOBMFFFile,
+  uploadFragmentIndex,
+} from "@editframe/api";
+
+import { getClient } from "../../utils/index.ts";
+import type { SubAssetSync } from "./SubAssetSync.ts";
+import { SyncStatus } from "./SyncStatus.ts";
+
+export class SyncFragmentIndex
+  implements SubAssetSync<CreateISOBMFFFileResult>
+{
+  icon = "📋";
+  label = "fragment index";
+  syncStatus: SyncStatus = new SyncStatus(this.path);
+  fileSyncStatus: SyncStatus = new SyncStatus(
+    join(dirname(this.path), "isobmff"),
+  );
+  created: CreateISOBMFFFileResult | null = null;
+
+  constructor(
+    public path: string,
+    public md5: string,
+  ) {}
+
+  async byteSize() {
+    return (await fs.stat(this.path)).size;
+  }
+
+  async prepare() {}
+
+  async validate() {}
+
+  async create() {
+    this.created = await createISOBMFFFile(getClient(), {
+      md5: this.md5,
+      filename: this.path.replace(/\.tracks.json$/, ""),
+    });
+  }
+
+  isComplete() {
+    return !!this.created?.fragment_index_complete;
+  }
+
+  async upload() {
+    if (!this.created) {
+      throw new Error(
+        "Fragment index not created. Should have been prevented by .isComplete()",
+      );
+    }
+    await uploadFragmentIndex(
+      getClient(),
+      this.created.id,
+      // It is unclear why we need to use Readable.from here
+      // Tests fail when using createReadStream
+      Readable.from(await fs.readFile(this.path)),
+      await this.byteSize(),
+    );
+  }
+
+  async markSynced() {
+    if (!this.created) {
+      throw new Error(
+        "Fragment index 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.id,
+        md5: this.md5,
+        asset_id: this.created.asset_id,
+        byte_size: byteSize,
+      }),
+      this.fileSyncStatus.markSynced({
+        version: "1",
+        complete: true,
+        id: this.created.id,
+        md5: this.md5,
+        asset_id: this.created.asset_id,
+        byte_size: byteSize,
+      }),
+    ]);
+  }
+}

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

@@ -0,0 +1,131 @@
+import { describe, expect, test } from "vitest";
+import { fixture, withFixtures } from "../../../test-fixtures/fixture.ts";
+import {
+  mockCreateImageFile,
+  mockGetUploadImageFile,
+  useMSW,
+} from "../../../test-fixtures/network.ts";
+import { SyncImage } from "./SyncImage.ts";
+
+describe("SyncImage", async () => {
+  const server = useMSW();
+  await withFixtures(
+    [fixture("test.png", "test.png")],
+    async ({ files: [image], cacheImage }) => {
+      test("Reads byte size", async () => {
+        const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+        await expect(syncImage.byteSize()).resolves.toEqual(276);
+      });
+      test("prepare() probes image", async () => {
+        const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+        await expect(syncImage.prepare()).resolves.toBeUndefined();
+        console.log(syncImage.probeResult);
+        expect(syncImage.probeResult.data.format).toMatchObject({
+          format_name: "png_pipe",
+        });
+      });
+      describe("validate()", () => {
+        test("Throws when prepare() is not called", async () => {
+          const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+          await expect(syncImage.validate()).rejects.toThrow();
+        });
+        test.skip("throws when probe is not a supported image", async () => {});
+      });
+
+      describe(".create()", () => {
+        test("Throws when prepare() is not called", async () => {
+          const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+          await expect(syncImage.create()).rejects.toThrow();
+        });
+        test("isComplete() returns false when not created", async () => {
+          server.use(
+            mockCreateImageFile({
+              complete: false,
+              id: "123",
+              filename: "test.mp4",
+              fixture: image!,
+            }),
+          );
+          const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+          await syncImage.prepare();
+          await syncImage.create();
+          expect(syncImage.isComplete()).toBe(false);
+        });
+        test("isComplete() returns true when created", async () => {
+          server.use(
+            mockCreateImageFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: image!,
+            }),
+          );
+          const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+          await syncImage.prepare();
+          await syncImage.create();
+          expect(syncImage.isComplete()).toBe(true);
+        });
+      });
+      describe(".upload()", () => {
+        test("throws when not created", async () => {
+          const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+          await syncImage.prepare();
+          // This is throwing syncronously because the error is thrown before
+          // any async operations are awaited.
+          expect(() => syncImage.upload()).toThrow();
+        });
+        test("uploads image", async () => {
+          server.use(
+            mockCreateImageFile({
+              complete: false,
+              id: "123",
+              filename: "test.mp4",
+              fixture: image!,
+            }),
+            mockGetUploadImageFile({
+              id: "123",
+              fixture: image!,
+            }),
+          );
+          const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+          await syncImage.prepare();
+          await syncImage.create();
+          await expect(syncImage.upload()).resolves.toBeUndefined();
+        });
+      });
+      describe(".markSynced()", () => {
+        test("throws when not created", async () => {
+          const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+          await expect(syncImage.markSynced()).rejects.toThrow();
+        });
+        test("marks synced", async () => {
+          server.use(
+            mockCreateImageFile({
+              complete: true,
+              id: "123",
+              fixture: image!,
+            }),
+            mockGetUploadImageFile({
+              id: "123",
+              fixture: image!,
+            }),
+          );
+          const syncImage = new SyncImage(await cacheImage(image!), image!.md5);
+          await syncImage.prepare();
+          await syncImage.create();
+          await syncImage.upload();
+          await syncImage.markSynced();
+          await expect(syncImage.syncStatus.isSynced()).resolves.toBe(true);
+          await expect(syncImage.syncStatus.readInfo()).resolves.toEqual({
+            version: "1",
+            complete: true,
+            id: "123",
+            md5: image!.md5,
+            asset_id: `${image!.md5}:test.png`,
+            byte_size: 276,
+          });
+        });
+      });
+    },
+  );
+});

package/src/operations/syncAssetsDirectory/SyncImage.ts

@@ -0,0 +1,112 @@
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import path, { basename } from "node:path";
+
+import {
+  type CreateImageFileResult,
+  createImageFile,
+  uploadImageFile,
+} 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 SyncImage implements SubAssetSync<CreateImageFileResult> {
+  icon = "🖼️";
+  label = "image";
+  syncStatus: SyncStatus = new SyncStatus(this.path);
+  created: CreateImageFileResult | null = null;
+
+  constructor(
+    public path: string,
+    public md5: string,
+  ) {}
+
+  private _probeResult: Probe | null = null;
+
+  async prepare() {
+    this._probeResult = await Probe.probePath(this.path);
+  }
+
+  get probeResult() {
+    if (!this._probeResult) {
+      throw new Error("Probe result not found. Call prepare() first.");
+    }
+    return this._probeResult;
+  }
+
+  get extension() {
+    return path.extname(this.path).slice(1);
+  }
+
+  async byteSize() {
+    return (await fs.stat(this.path)).size;
+  }
+
+  async validate() {
+    const [videoProbe] = this.probeResult.videoStreams;
+    if (!videoProbe) {
+      throw new Error(`No media info found in image: ${this.path}`);
+    }
+    const ext = this.extension;
+    if (!(ext === "jpg" || ext === "jpeg" || ext === "png" || ext === "webp")) {
+      throw new Error(`Invalid image format: ${this.path}`);
+    }
+  }
+  async create() {
+    const byteSize = (await fs.stat(this.path)).size;
+    const [videoProbe] = this.probeResult.videoStreams;
+    if (!videoProbe) {
+      throw new Error(
+        "No video stream found in image. Should have been prevented by .validate()",
+      );
+    }
+    this.created = await createImageFile(getClient(), {
+      md5: this.md5,
+      filename: basename(this.path),
+      width: videoProbe.width,
+      height: videoProbe.height,
+      mime_type: `image/${this.extension}` as
+        | "image/jpeg"
+        | "image/png"
+        | "image/jpg"
+        | "image/webp",
+      byte_size: byteSize,
+    });
+  }
+  isComplete() {
+    return !!this.created?.complete;
+  }
+  upload() {
+    if (!this.created) {
+      throw new Error(
+        "Image not created. Should have been prevented by .isComplete()",
+      );
+    }
+    return uploadImageFile(
+      getClient(),
+      this.created.id,
+      createReadStream(this.path),
+      Number.parseInt(this.probeResult.format.size || "0"),
+    );
+  }
+  async markSynced() {
+    if (!this.created) {
+      throw new Error(
+        "Image not created. Should have been prevented by .isComplete()",
+      );
+    }
+    const byteSize = await this.byteSize();
+    return this.syncStatus.markSynced({
+      version: "1",
+      complete: true,
+      id: this.created.id,
+      md5: this.md5,
+      asset_id: this.created.asset_id,
+      byte_size: byteSize,
+    });
+  }
+}

package/src/operations/syncAssetsDirectory/SyncStatus.ts

@@ -0,0 +1,51 @@
+import fs from "node:fs/promises";
+
+import { z } from "zod";
+
+const SYNC_VERSION = "1";
+
+const SyncStatusSchema = z.object({
+  version: z.string(),
+  complete: z.boolean(),
+  id: z.string(),
+  md5: z.string(),
+  asset_id: z.string(),
+  byte_size: z.number(),
+});
+
+export interface SyncStatusInfo extends z.infer<typeof SyncStatusSchema> {}
+
+export class SyncStatus {
+  constructor(private basePath: string) {}
+
+  infoPath = `${this.basePath}.info`;
+
+  async isSynced() {
+    const syncInfo = await this.readInfo();
+    if (!syncInfo) {
+      return false;
+    }
+    return syncInfo.version === SYNC_VERSION && syncInfo.complete;
+  }
+
+  async readInfo() {
+    try {
+      const info = await fs.readFile(this.infoPath, "utf-8");
+      return SyncStatusSchema.parse(JSON.parse(info));
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        error.code === "ENOENT"
+      ) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  async markSynced(info: SyncStatusInfo) {
+    process.stderr.write(`✏️  Marking asset as synced: ${this.basePath}\n`);
+    await fs.writeFile(this.infoPath, JSON.stringify(info, null, 2), "utf-8");
+  }
+}