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

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");
+  }
+}

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,
+      }),
+    ]);
+  }
+}