@editframe/cli 0.26.3-beta.0 → 0.26.4-beta.0

package/src/operations/syncAssetsDirectory/SyncTrack.ts

@@ -1,175 +0,0 @@
-import { createReadStream } from "node:fs";
-import fs from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-
-import {
-  type CreateISOBMFFFileResult,
-  type CreateISOBMFFTrackPayload,
-  type CreateISOBMFFTrackResult,
-  createISOBMFFFile,
-  createISOBMFFTrack,
-  type LookupISOBMFFFileByMd5Result,
-  lookupISOBMFFFileByMd5,
-  uploadISOBMFFTrack,
-} from "@editframe/api";
-import { Probe } from "@editframe/assets";
-
-import { createReadableStreamFromReadable } from "../../utils/createReadableStreamFromReadable.js";
-import { getClient } from "../../utils/index.js";
-import type { SubAssetSync } from "./SubAssetSync.js";
-import { SyncStatus } from "./SyncStatus.js";
-
-export class SyncTrack implements SubAssetSync<CreateISOBMFFTrackResult> {
-  icon = "📼";
-  label = "track";
-  syncStatus = new SyncStatus(this.path);
-  fileSyncStatus = new SyncStatus(join(dirname(this.path), "isobmff"));
-  created: CreateISOBMFFTrackResult | null = null;
-
-  constructor(
-    public path: string,
-    public md5: string,
-  ) {}
-
-  private _isoFile:
-    | CreateISOBMFFFileResult
-    | LookupISOBMFFFileByMd5Result
-    | 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() {
-    const maybeIsoFile = await lookupISOBMFFFileByMd5(getClient(), this.md5);
-    if (maybeIsoFile) {
-      this._isoFile = maybeIsoFile;
-    } else {
-      this._isoFile = await createISOBMFFFile(getClient(), {
-        md5: this.md5,
-        filename: basename(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}`);
-    }
-    if (typeof track.duration === "string") {
-      return Number.parseFloat(track.duration);
-    }
-    return track.duration;
-  }
-
-  async validate() {
-    this.trackId;
-    this.isoFile;
-    this.trackDuration;
-  }
-
-  async create(): Promise<void> {
-    const track = this.track;
-    const isoFile = this.isoFile;
-
-    if (track.codec_type === "data") {
-      throw new Error(`Unsupported codec type: ${track.codec_type}`);
-    }
-    const createPayload: 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()",
-      );
-    }
-    await uploadISOBMFFTrack(
-      getClient(),
-      this.isoFile.id,
-      Number(this.trackId),
-      createReadableStreamFromReadable(createReadStream(this.path)),
-      this.created?.byte_size,
-    ).whenUploaded();
-  }
-  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,
-        byte_size: byteSize,
-      }),
-      this.fileSyncStatus.markSynced({
-        version: "1",
-        complete: true,
-        id: this.created.file_id,
-        md5: this.md5,
-        byte_size: byteSize,
-      }),
-    ]);
-  }
-}

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

@@ -1,134 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import { doAssetSync } from "./doAssetSync.js";
-import type { SubAssetSync } from "./SubAssetSync.js";
-import type { SyncStatusInfo } from "./SyncStatus.js";
-
-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

@@ -1,62 +0,0 @@
-import type { SubAssetSync } from "./SubAssetSync.js";
-
-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;
-};