@editframe/cli 0.26.3-beta.0 → 0.30.0-beta.13

package/src/operations/syncAssetsDirectory.test.ts

@@ -1,510 +0,0 @@
-import { setupServer } from "msw/node";
-import { afterAll, afterEach, beforeAll, describe, it } from "vitest";
-import { fixture, withFixtures } from "../../test-fixtures/fixture.js";
-import {
-  mockCreateImageFile,
-  mockCreateIsobmffFile,
-  mockCreateIsobmffTrack,
-  mockGetUploadImageFile,
-  mockLookupImageFileByMd5NotFound,
-  mockLookupISOBMFFFileByMd5NotFound,
-  mockUploadIsobmffFileIndex,
-} from "../../test-fixtures/network.js";
-
-const server = setupServer();
-
-describe("syncAssetsDirectory", () => {
-  beforeAll(() => {
-    server.listen();
-    process.env.EF_TOKEN = "ef_SECRET_TOKEN";
-    process.env.EF_HOST = "http://localhost:3000";
-  });
-  afterAll(() => server.close());
-  afterEach(() => server.resetHandlers());
-
-  describe("Image sync", () => {
-    it("Syncs assets directory when file is already uploaded", async () => {
-      await withFixtures(
-        [fixture("test.png", "test.png")],
-        async ({
-          files: [testPng],
-          expectCacheFiles,
-          expectInfoFileContent,
-          syncAssetsDirectory,
-          cacheImage,
-        }) => {
-          server.use(
-            mockLookupImageFileByMd5NotFound({
-              md5: testPng!.md5,
-            }),
-            mockCreateImageFile({
-              complete: true,
-              id: "123",
-              filename: "test.png",
-              fixture: testPng!,
-            }),
-          );
-          await cacheImage(testPng!);
-          await syncAssetsDirectory();
-          await expectCacheFiles(testPng!, ["test.png", "test.png.info"]);
-
-          await expectInfoFileContent("test.png.info", testPng!, {
-            complete: true,
-            id: "123",
-          });
-        },
-      );
-    });
-
-    it("Syncs assets directory when file is not uploaded", async () => {
-      await withFixtures(
-        [fixture("test.png", "test.png")],
-        async ({
-          files: [testPng],
-          expectCacheFiles,
-          expectInfoFileContent,
-          cacheImage,
-          syncAssetsDirectory,
-        }) => {
-          server.use(
-            mockLookupImageFileByMd5NotFound({
-              md5: testPng!.md5,
-            }),
-            mockCreateImageFile({
-              complete: false,
-              id: "123",
-              filename: "test.png",
-              fixture: testPng!,
-            }),
-            mockGetUploadImageFile({
-              complete: true,
-              id: "123",
-              filename: "test.png",
-              fixture: testPng!,
-            }),
-          );
-          await cacheImage(testPng!);
-          await syncAssetsDirectory();
-          await expectCacheFiles(testPng!, ["test.png", "test.png.info"]);
-
-          await expectInfoFileContent("test.png.info", testPng!, {
-            complete: true,
-            id: "123",
-          });
-        },
-      );
-    });
-
-    it("Syncs assets directory when file is present with different name", async () => {
-      await withFixtures(
-        [fixture("test.png", "test.png"), fixture("test.png", "test2.png")],
-        async ({
-          files: [testPng, test2Png],
-          cacheImage,
-          syncAssetsDirectory,
-          expectCacheFiles,
-          expectInfoFileContent,
-        }) => {
-          server.use(
-            mockLookupImageFileByMd5NotFound({
-              md5: testPng!.md5,
-            }),
-            mockCreateImageFile({
-              complete: false,
-              id: "123",
-              filename: "test.png",
-              fixture: testPng!,
-            }),
-            mockGetUploadImageFile({
-              complete: true,
-              id: "123",
-              filename: "test.png",
-              fixture: testPng!,
-            }),
-            mockCreateImageFile({
-              complete: false,
-              id: "123",
-              filename: "test.png",
-              fixture: test2Png!,
-            }),
-            mockGetUploadImageFile({
-              complete: true,
-              id: "123",
-              filename: "test.png",
-              fixture: test2Png!,
-            }),
-          );
-
-          await cacheImage(testPng!);
-          await cacheImage(test2Png!);
-          await syncAssetsDirectory();
-          await expectCacheFiles(testPng!, [
-            "test.png",
-            "test.png.info",
-            "test2.png",
-            "test2.png.info",
-          ]);
-
-          await expectInfoFileContent("test.png.info", testPng!, {
-            complete: true,
-            id: "123",
-          });
-
-          await expectInfoFileContent("test2.png.info", testPng!, {
-            complete: true,
-            id: "123",
-          });
-        },
-      );
-    });
-  });
-
-  describe("A/V Sync", () => {
-    it("Syncs assets directory when fragment index is already uploaded", async () => {
-      await withFixtures(
-        [fixture("test.mp4", "test.mp4")],
-        async ({
-          files: [testMp4],
-          generateTrack,
-          generateTrackFragmentIndex,
-          syncAssetsDirectory,
-          expectInfoFileContent,
-          expectCacheFiles,
-        }) => {
-          const creationArgs = {
-            complete: true,
-            id: "123",
-            filename: "test.mp4",
-            fixture: testMp4!,
-          };
-          server.use(
-            mockLookupISOBMFFFileByMd5NotFound({
-              md5: testMp4!.md5,
-            }),
-
-            mockCreateIsobmffFile(creationArgs),
-
-            mockCreateIsobmffTrack({
-              complete: true,
-              id: "track-1",
-              fileId: "123",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-
-            mockCreateIsobmffFile(creationArgs),
-            mockCreateIsobmffTrack({
-              complete: true,
-              fileId: "123",
-              id: "track-2",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-
-            mockCreateIsobmffFile(creationArgs),
-            mockUploadIsobmffFileIndex({
-              id: "123",
-              complete: true,
-            }),
-          );
-          await generateTrack(testMp4!, 1);
-          await generateTrack(testMp4!, 2);
-          await generateTrackFragmentIndex(testMp4!);
-
-          await syncAssetsDirectory();
-
-          await expectCacheFiles(testMp4!, [
-            "isobmff.info",
-            "test.mp4.track-1.mp4",
-            "test.mp4.track-1.mp4.info",
-            "test.mp4.track-2.mp4",
-            "test.mp4.track-2.mp4.info",
-            "test.mp4.tracks.json",
-            "test.mp4.tracks.json.info",
-          ]);
-
-          await expectInfoFileContent("isobmff.info", testMp4!, {
-            complete: true,
-            id: "123",
-            byte_size: 31,
-          });
-
-          await expectInfoFileContent("test.mp4.tracks.json.info", testMp4!, {
-            complete: true,
-            id: "123",
-            byte_size: 31,
-          });
-
-          await expectInfoFileContent("test.mp4.track-1.mp4.info", testMp4!, {
-            complete: true,
-            id: "123:track-1",
-            byte_size: 26434,
-          });
-
-          await expectInfoFileContent("test.mp4.track-2.mp4.info", testMp4!, {
-            complete: true,
-            id: "123:track-2",
-            byte_size: 26434,
-          });
-        },
-      );
-    });
-
-    it("Syncs assets directory when fragment index is not uploaded", async () => {
-      await withFixtures(
-        [fixture("test.mp4", "test.mp4")],
-        async ({
-          files: [testMp4],
-
-          syncAssetsDirectory,
-          expectCacheFiles,
-          expectInfoFileContent,
-          generateTrackFragmentIndex,
-          generateTrack,
-        }) => {
-          const creationArgs = {
-            complete: false,
-            id: "123",
-            filename: "test.mp4",
-            fixture: testMp4!,
-          };
-          server.use(
-            mockLookupISOBMFFFileByMd5NotFound({
-              md5: testMp4!.md5,
-            }),
-            mockCreateIsobmffFile(creationArgs),
-            mockUploadIsobmffFileIndex({
-              id: "123",
-              complete: true,
-            }),
-
-            mockCreateIsobmffFile(creationArgs),
-            mockCreateIsobmffTrack({
-              complete: true,
-              id: "track-1",
-              fileId: "123",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-
-            mockCreateIsobmffFile(creationArgs),
-            mockCreateIsobmffTrack({
-              complete: true,
-              fileId: "123",
-              id: "track-2",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-          );
-          await generateTrackFragmentIndex(testMp4!);
-          await generateTrack(testMp4!, 1);
-          await generateTrack(testMp4!, 2);
-
-          await syncAssetsDirectory();
-
-          await expectCacheFiles(testMp4!, [
-            "isobmff.info",
-            "test.mp4.track-1.mp4",
-            "test.mp4.track-1.mp4.info",
-            "test.mp4.track-2.mp4",
-            "test.mp4.track-2.mp4.info",
-            "test.mp4.tracks.json",
-            "test.mp4.tracks.json.info",
-          ]);
-
-          await expectInfoFileContent("isobmff.info", testMp4!, {
-            complete: true,
-            id: "123",
-            byte_size: 31,
-          });
-
-          await expectInfoFileContent("test.mp4.tracks.json.info", testMp4!, {
-            byte_size: 31,
-            complete: true,
-            id: "123",
-          });
-
-          await expectInfoFileContent("test.mp4.track-1.mp4.info", testMp4!, {
-            byte_size: 26434,
-            complete: true,
-            id: "123:track-1",
-          });
-
-          await expectInfoFileContent("test.mp4.track-2.mp4.info", testMp4!, {
-            byte_size: 26434,
-            complete: true,
-            id: "123:track-2",
-          });
-        },
-      );
-    });
-
-    it("Syncs assets when file has already been synced with a different name", async () => {
-      await withFixtures(
-        [fixture("test.mp4", "test.mp4"), fixture("test.mp4", "test2.mp4")],
-        async ({
-          files: [testMp4, test2Mp4],
-          syncAssetsDirectory,
-          generateTrackFragmentIndex,
-          generateTrack,
-          expectInfoFileContent,
-          expectCacheFiles,
-        }) => {
-          server.use(
-            mockLookupISOBMFFFileByMd5NotFound({
-              md5: testMp4!.md5,
-            }),
-            mockCreateIsobmffFile({
-              complete: true,
-              id: "123",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-            mockCreateIsobmffFile({
-              complete: true,
-              id: "123",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-            mockCreateIsobmffFile({
-              complete: true,
-              id: "123",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-
-            mockCreateIsobmffTrack({
-              complete: true,
-              id: "track-1",
-              fileId: "123",
-              filename: "test.mp4",
-              fixture: test2Mp4!,
-            }),
-
-            mockCreateIsobmffTrack({
-              complete: true,
-              id: "track-2",
-              fileId: "123",
-              filename: "test.mp4",
-              fixture: test2Mp4!,
-            }),
-
-            mockUploadIsobmffFileIndex({
-              id: "123",
-              complete: true,
-            }),
-          );
-          server.use(
-            mockCreateIsobmffFile({
-              complete: true,
-              id: "123",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-            mockCreateIsobmffFile({
-              complete: true,
-              id: "123",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-            mockCreateIsobmffFile({
-              complete: true,
-              id: "123",
-              filename: "test.mp4",
-              fixture: testMp4!,
-            }),
-
-            mockCreateIsobmffTrack({
-              complete: true,
-              id: "track-1",
-              fileId: "123",
-              filename: "test.mp4",
-              fixture: test2Mp4!,
-            }),
-
-            mockCreateIsobmffTrack({
-              complete: true,
-              id: "track-2",
-              fileId: "123",
-              filename: "test.mp4",
-              fixture: test2Mp4!,
-            }),
-
-            mockUploadIsobmffFileIndex({
-              id: "123",
-              complete: true,
-            }),
-          );
-
-          await generateTrackFragmentIndex(testMp4!);
-          await generateTrack(testMp4!, 1);
-          await generateTrack(testMp4!, 2);
-
-          await generateTrackFragmentIndex(test2Mp4!);
-          await generateTrack(test2Mp4!, 1);
-          await generateTrack(test2Mp4!, 2);
-          await syncAssetsDirectory();
-
-          await expectCacheFiles(test2Mp4!, [
-            "isobmff.info",
-            "test.mp4.track-1.mp4",
-            "test.mp4.track-1.mp4.info",
-            "test.mp4.track-2.mp4",
-            "test.mp4.track-2.mp4.info",
-            "test.mp4.tracks.json",
-
-            "test.mp4.tracks.json.info",
-            "test2.mp4.track-1.mp4",
-            "test2.mp4.track-1.mp4.info",
-            "test2.mp4.track-2.mp4",
-            "test2.mp4.track-2.mp4.info",
-            "test2.mp4.tracks.json",
-            "test2.mp4.tracks.json.info",
-          ]);
-
-          await expectInfoFileContent("isobmff.info", testMp4!, {
-            byte_size: 31,
-            complete: true,
-            id: "123",
-          });
-
-          await expectInfoFileContent("test2.mp4.tracks.json.info", testMp4!, {
-            byte_size: 31,
-            complete: true,
-            id: "123",
-          });
-
-          await expectInfoFileContent("test2.mp4.track-1.mp4.info", testMp4!, {
-            byte_size: 26434,
-            complete: true,
-            id: "123:track-1",
-          });
-
-          await expectInfoFileContent("test2.mp4.track-2.mp4.info", testMp4!, {
-            byte_size: 26434,
-            complete: true,
-            id: "123:track-2",
-          });
-
-          await expectInfoFileContent("test.mp4.tracks.json.info", testMp4!, {
-            byte_size: 31,
-            complete: true,
-            id: "123",
-          });
-
-          await expectInfoFileContent("test.mp4.track-1.mp4.info", testMp4!, {
-            byte_size: 26434,
-            complete: true,
-            id: "123:track-1",
-          });
-
-          await expectInfoFileContent("test.mp4.track-2.mp4.info", testMp4!, {
-            byte_size: 26434,
-            complete: true,
-            id: "123:track-2",
-          });
-        },
-      );
-    });
-  });
-});

package/src/operations/syncAssetsDirectory.ts

@@ -1,91 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { doAssetSync } from "./syncAssetsDirectory/doAssetSync.js";
-import { getAssetSync } from "./syncAssetsDirectory/SubAssetSync.js";
-
-export const syncAssetDirectory = async (
-  /**
-   * Project directory will be used as the base to find an assets directory.
-   * Assets will be synced from `<projectDirectory>/src/assets`
-   */
-  cacheDir: string,
-) => {
-  const stat = await fs.stat(cacheDir).catch((error) => {
-    if (error.code === "ENOENT") {
-      return;
-    }
-    throw error;
-  });
-
-  if (!stat?.isDirectory()) {
-    console.error(`No assets cache directory found at ${cacheDir}`);
-    return;
-  }
-  const assets = await fs.readdir(cacheDir);
-
-  process.stderr.write(`Syncing asset dir: ${cacheDir}\n`);
-
-  const errors: Record<string, string[]> = {};
-
-  const reportError = (path: string, message: string) => {
-    errors[path] ||= [];
-    errors[path].push(message);
-    process.stderr.write(` 🚫 ${message}\n`);
-  };
-
-  const reportSuccess = (_path: string, message: string) => {
-    process.stderr.write(` ✅ ${message}\n`);
-  };
-
-  const reportInfo = (_path: string, message: string) => {
-    process.stderr.write(` ${message}\n`);
-  };
-
-  for (const assetMd5 of assets) {
-    reportInfo(assetMd5, `Syncing asset: ${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.");
-      return;
-    }
-    const subAssets = await fs.readdir(assetDir);
-
-    for (const subAsset of subAssets) {
-      if (subAsset.endsWith(".info")) {
-        // skip .info files, they are not assets
-        continue;
-      }
-      const subAssetPath = path.join(assetDir, subAsset);
-
-      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);
-          }
-        }
-      } catch (error) {
-        if (error instanceof Error) {
-          reportError(subAsset, error.message);
-        } else {
-          reportError(subAsset, "Unknown error");
-        }
-      }
-    }
-  }
-
-  if (Object.keys(errors).length) {
-    process.stderr.write("\n\n❌ Encountered errors while syncing assets:\n");
-    for (const [asset, messages] of Object.entries(errors)) {
-      process.stderr.write(`\n🚫 ${asset}\n`);
-      for (const message of messages) {
-        process.stderr.write(`  - ${message}\n`);
-      }
-    }
-
-    throw new Error("Failed to sync assets");
-  }
-};

package/src/utils/attachWorkbench.ts

@@ -1,16 +0,0 @@
-import type { EFTimegroup } from "@editframe/elements";
-import type { Page } from "playwright";
-
-export const attachWorkbench = (page: Page) => {
-  page.on("load", buildWorkbench.bind(null, page));
-  buildWorkbench(page);
-};
-
-const buildWorkbench = async (page: Page) => {
-  await page.evaluate(async () => {
-    const rootTimegroup = document.body.querySelector("ef-timegroup") as
-      | EFTimegroup
-      | undefined;
-    rootTimegroup?.wrapWithWorkbench();
-  });
-};