@webflow/webflow-cli 1.22.0-next.1 → 1.22.0-next.2

package/dist/cloud-scaffolds/__tests__/fetcher.test.ts

@@ -1,249 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import os from "os";
-import * as tar from "tar";
-import {
-  fetchScaffoldContent,
-  getScaffoldContent,
-  getScaffoldFromLocal,
-} from "../fetcher";
-import * as registry from "../registry";
-import { ScaffoldError } from "../types";
-
-jest.mock("../registry");
-jest.mock("../../../utils/logger", () => ({
-  __esModule: true,
-  default: {
-    spinner: jest.fn(() => ({
-      succeed: jest.fn(),
-      fail: jest.fn(),
-      warn: jest.fn(),
-      info: jest.fn(),
-    })),
-  },
-}));
-
-const mockGetFrameworkDefinition =
-  registry.getFrameworkDefinition as jest.MockedFunction<
-    typeof registry.getFrameworkDefinition
-  >;
-const mockToMinimalScaffoldId =
-  registry.toMinimalScaffoldId as jest.MockedFunction<
-    typeof registry.toMinimalScaffoldId
-  >;
-
-describe("scaffold fetcher", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "fetcher-test-"));
-    jest.clearAllMocks();
-  });
-
-  afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe("getScaffoldFromLocal", () => {
-    it("returns ScaffoldContent from local directory", async () => {
-      const scaffoldDir = path.join(tempDir, "scaffold");
-      fs.mkdirSync(scaffoldDir, { recursive: true });
-      fs.writeFileSync(path.join(scaffoldDir, "package.json"), "{}");
-      fs.mkdirSync(path.join(scaffoldDir, "src"), { recursive: true });
-      fs.writeFileSync(path.join(scaffoldDir, "src", "index.ts"), "// test");
-
-      mockGetFrameworkDefinition.mockReturnValue({
-        id: "test-minimal",
-        name: "Test",
-        source: {
-          type: "local",
-          path: path.resolve(scaffoldDir),
-        },
-      });
-
-      const result = await getScaffoldFromLocal("test-minimal");
-
-      expect(result.scaffoldId).toBe("test-minimal");
-      expect(result.extractionRoot).toBe(scaffoldDir);
-      expect(result.files).toHaveLength(2);
-      expect(result.files).toContain(path.join(scaffoldDir, "package.json"));
-      expect(result.files).toContain(path.join(scaffoldDir, "src", "index.ts"));
-    });
-
-    it("throws ScaffoldError when source is not local", async () => {
-      mockGetFrameworkDefinition.mockReturnValue({
-        id: "astro-minimal",
-        name: "Astro",
-        source: {
-          type: "github",
-          repo: "Webflow-Examples/hello-world-astro",
-          ref: "main",
-        },
-      });
-
-      await expect(getScaffoldFromLocal("astro-minimal")).rejects.toThrow(
-        ScaffoldError
-      );
-      await expect(getScaffoldFromLocal("astro-minimal")).rejects.toThrow(
-        "does not have a local source"
-      );
-    });
-
-    it("throws ScaffoldError when directory does not exist", async () => {
-      const missingPath = path.resolve(path.join(tempDir, "nonexistent"));
-
-      mockGetFrameworkDefinition.mockReturnValue({
-        id: "test-minimal",
-        name: "Test",
-        source: { type: "local", path: missingPath },
-      });
-
-      await expect(getScaffoldFromLocal("test-minimal")).rejects.toThrow(
-        ScaffoldError
-      );
-      await expect(getScaffoldFromLocal("test-minimal")).rejects.toThrow(
-        "Scaffold directory not found"
-      );
-    });
-  });
-
-  describe("fetchScaffoldContent", () => {
-    it("dispatches to getScaffoldFromLocal for local source", async () => {
-      const scaffoldDir = path.join(tempDir, "scaffold");
-      fs.mkdirSync(scaffoldDir, { recursive: true });
-      fs.writeFileSync(path.join(scaffoldDir, "package.json"), "{}");
-
-      mockGetFrameworkDefinition.mockReturnValue({
-        id: "test-minimal",
-        name: "Test",
-        source: { type: "local", path: path.resolve(scaffoldDir) },
-      });
-
-      const result = await fetchScaffoldContent("test-minimal");
-
-      expect(result.scaffoldId).toBe("test-minimal");
-      expect(result.files).toHaveLength(1);
-    });
-
-    it("fetches from GitHub and returns ScaffoldContent", async () => {
-      // Create a minimal tarball matching GitHub structure: owner-repo-sha/
-      const topLevelDir = "Webflow-Examples-hello-world-astro-abc123";
-      const tarballDir = path.join(tempDir, "tarball-src");
-      fs.mkdirSync(path.join(tarballDir, topLevelDir), { recursive: true });
-      fs.writeFileSync(
-        path.join(tarballDir, topLevelDir, "package.json"),
-        '{"name":"test"}'
-      );
-
-      const tarballPath = path.join(tempDir, "archive.tar.gz");
-      await tar.create(
-        {
-          gzip: true,
-          file: tarballPath,
-          cwd: tarballDir,
-        },
-        [topLevelDir]
-      );
-      const tarballBuffer = fs.readFileSync(tarballPath);
-
-      const originalFetch = globalThis.fetch;
-      const arrayBuffer = tarballBuffer.buffer.slice(
-        tarballBuffer.byteOffset,
-        tarballBuffer.byteOffset + tarballBuffer.byteLength
-      );
-      globalThis.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        arrayBuffer: () => Promise.resolve(arrayBuffer),
-      });
-
-      mockGetFrameworkDefinition.mockReturnValue({
-        id: "astro-minimal",
-        name: "Astro",
-        source: {
-          type: "github",
-          repo: "Webflow-Examples/hello-world-astro",
-          ref: "main",
-        },
-      });
-
-      try {
-        const result = await fetchScaffoldContent("astro-minimal");
-
-        expect(result.scaffoldId).toBe("astro-minimal");
-        expect(result.files).toHaveLength(1);
-        expect(result.files[0]).toContain("package.json");
-        expect(result.extractionRoot).toContain(topLevelDir);
-      } finally {
-        globalThis.fetch = originalFetch;
-      }
-    });
-
-    it("throws ScaffoldError when GitHub fetch fails", async () => {
-      const originalFetch = globalThis.fetch;
-      globalThis.fetch = jest.fn().mockResolvedValue({
-        ok: false,
-        status: 404,
-        statusText: "Not Found",
-      });
-
-      mockGetFrameworkDefinition.mockReturnValue({
-        id: "astro-minimal",
-        name: "Astro",
-        source: {
-          type: "github",
-          repo: "Webflow-Examples/hello-world-astro",
-          ref: "main",
-        },
-      });
-
-      try {
-        await expect(fetchScaffoldContent("astro-minimal")).rejects.toThrow(
-          ScaffoldError
-        );
-        await expect(fetchScaffoldContent("astro-minimal")).rejects.toThrow(
-          "Failed to fetch scaffold from GitHub"
-        );
-      } finally {
-        globalThis.fetch = originalFetch;
-      }
-    });
-  });
-
-  describe("getScaffoldContent", () => {
-    it("resolves framework name to minimal ID and fetches", async () => {
-      const scaffoldDir = path.join(tempDir, "scaffold");
-      fs.mkdirSync(scaffoldDir, { recursive: true });
-      fs.writeFileSync(path.join(scaffoldDir, "package.json"), "{}");
-
-      mockToMinimalScaffoldId.mockReturnValue("astro-minimal");
-      mockGetFrameworkDefinition.mockReturnValue({
-        id: "astro-minimal",
-        name: "Astro",
-        source: { type: "local", path: path.resolve(scaffoldDir) },
-      });
-
-      const result = await getScaffoldContent("astro");
-
-      expect(mockToMinimalScaffoldId).toHaveBeenCalledWith("astro");
-      expect(result.scaffoldId).toBe("astro-minimal");
-      expect(result.files).toHaveLength(1);
-    });
-
-    it("passes through full scaffold ID unchanged", async () => {
-      const scaffoldDir = path.join(tempDir, "scaffold");
-      fs.mkdirSync(scaffoldDir, { recursive: true });
-      fs.writeFileSync(path.join(scaffoldDir, "package.json"), "{}");
-
-      mockGetFrameworkDefinition.mockReturnValue({
-        id: "astro-minimal",
-        name: "Astro",
-        source: { type: "local", path: path.resolve(scaffoldDir) },
-      });
-
-      const result = await getScaffoldContent("astro-minimal");
-
-      expect(mockToMinimalScaffoldId).not.toHaveBeenCalled();
-      expect(result.scaffoldId).toBe("astro-minimal");
-    });
-  });
-});

package/dist/cloud-scaffolds/__tests__/registry.test.ts

@@ -1,134 +0,0 @@
-import {
-  FRAMEWORK_REGISTRY,
-  getAvailableFrameworkNames,
-  getFrameworkDefinition,
-  listSupportedScaffoldIds,
-  toMinimalScaffoldId,
-} from "../registry";
-import { ScaffoldError } from "../types";
-
-describe("scaffold registry", () => {
-  describe("getFrameworkDefinition", () => {
-    it("returns definition for astro-minimal", () => {
-      const def = getFrameworkDefinition("astro-minimal");
-      expect(def.id).toBe("astro-minimal");
-      expect(def.name).toBe("Astro");
-      expect(def.source.type).toBe("github");
-      if (def.source.type === "github") {
-        expect(def.source.repo).toBe("Webflow-Examples/hello-world-astro");
-        expect(def.source.ref).toBe("v1");
-      }
-    });
-
-    it("returns definition for nextjs-minimal", () => {
-      const def = getFrameworkDefinition("nextjs-minimal");
-      expect(def.id).toBe("nextjs-minimal");
-      expect(def.name).toBe("Next.js");
-      expect(def.source.type).toBe("github");
-      if (def.source.type === "github") {
-        expect(def.source.repo).toBe("Webflow-Examples/hello-world-nextjs");
-      }
-    });
-
-    it("returns definition for astro (site-attached)", () => {
-      const def = getFrameworkDefinition("astro");
-      expect(def.id).toBe("astro");
-      expect(def.name).toBe("Astro (site-attached)");
-      expect(def.source.type).toBe("github");
-      if (def.source.type === "github") {
-        expect(def.source.repo).toBe(
-          "Webflow-Examples/hello-world-astro-devlink"
-        );
-      }
-    });
-
-    it("returns definition for nextjs (site-attached)", () => {
-      const def = getFrameworkDefinition("nextjs");
-      expect(def.id).toBe("nextjs");
-      expect(def.name).toBe("Next.js (site-attached)");
-      expect(def.source.type).toBe("github");
-      if (def.source.type === "github") {
-        expect(def.source.repo).toBe(
-          "Webflow-Examples/hello-world-nextjs-devlink"
-        );
-      }
-    });
-
-    it("throws ScaffoldError for unsupported scaffold ID", () => {
-      expect(() => getFrameworkDefinition("remix-minimal")).toThrow(
-        ScaffoldError
-      );
-      expect(() => getFrameworkDefinition("remix-minimal")).toThrow(
-        'Unsupported framework: "remix-minimal"'
-      );
-    });
-
-    it("includes supported IDs in ScaffoldError", () => {
-      try {
-        getFrameworkDefinition("unknown");
-        fail("Expected ScaffoldError");
-      } catch (err) {
-        expect(err).toBeInstanceOf(ScaffoldError);
-        expect((err as ScaffoldError).scaffoldId).toBe("unknown");
-        expect((err as ScaffoldError).supportedIds).toContain("astro-minimal");
-        expect((err as ScaffoldError).supportedIds).toContain("nextjs-minimal");
-        expect((err as ScaffoldError).supportedIds).toContain("astro");
-        expect((err as ScaffoldError).supportedIds).toContain("nextjs");
-      }
-    });
-  });
-
-  describe("listSupportedScaffoldIds", () => {
-    it("returns all registry keys", () => {
-      const ids = listSupportedScaffoldIds();
-      expect(ids).toEqual(
-        expect.arrayContaining([
-          "astro-minimal",
-          "nextjs-minimal",
-          "astro",
-          "nextjs",
-        ])
-      );
-      expect(ids).toHaveLength(Object.keys(FRAMEWORK_REGISTRY).length);
-    });
-  });
-
-  describe("getAvailableFrameworkNames", () => {
-    it("returns framework names without -minimal suffix", () => {
-      const names = getAvailableFrameworkNames();
-      expect(names).toEqual(expect.arrayContaining(["astro", "nextjs"]));
-      expect(names).toHaveLength(2);
-    });
-  });
-
-  describe("toMinimalScaffoldId", () => {
-    it("maps astro to astro-minimal", () => {
-      expect(toMinimalScaffoldId("astro")).toBe("astro-minimal");
-    });
-
-    it("maps nextjs to nextjs-minimal", () => {
-      expect(toMinimalScaffoldId("nextjs")).toBe("nextjs-minimal");
-    });
-
-    it("passes through astro-minimal unchanged", () => {
-      expect(toMinimalScaffoldId("astro-minimal")).toBe("astro-minimal");
-    });
-
-    it("throws ScaffoldError for unsupported framework", () => {
-      expect(() => toMinimalScaffoldId("remix")).toThrow(ScaffoldError);
-      expect(() => toMinimalScaffoldId("remix")).toThrow(
-        'No minimal scaffold for "remix"'
-      );
-    });
-
-    it("includes supported IDs in ScaffoldError", () => {
-      try {
-        toMinimalScaffoldId("vue");
-        fail("Expected ScaffoldError");
-      } catch (err) {
-        expect(err).toBeInstanceOf(ScaffoldError);
-        expect((err as ScaffoldError).supportedIds).toBeDefined();
-      }
-    });
-  });
-});

package/dist/templates/astro/astro.config.mjs.template

@@ -1,52 +0,0 @@
-import { defineConfig } from "astro/config";
-
-import cloudflare from "@astrojs/cloudflare";
-
-import react from '@astrojs/react';
-
-import userConfig from './clouduser.astro.config.mjs';
-
-const webflowOverrides = {
-  base: "${COSMIC_MOUNT_PATH}",
-  output: "server",
-  adapter: cloudflare({
-    imageService: "custom",
-    platformProxy: {
-      enabled: true
-    }
-  }),
-
-  integrations: [react()],
-  vite: {
-    ...userConfig.vite,
-    resolve: {
-      ...userConfig.vite?.resolve,
-      // Use react-dom/server.edge instead of react-dom/server.browser for React 19.
-      // Without this, MessageChannel from node:worker_threads needs to be polyfilled.
-      alias: import.meta.env.PROD ? {
-        "react-dom/server": "react-dom/server.edge",
-      } : undefined,
-    },
-  },
-
-  build: {
-    assetsPrefix: "${COSMIC_DEPLOY_URL}${COSMIC_MOUNT_PATH}"
-  },
-
-  image: {
-    ...userConfig.image,
-    service: {
-      entrypoint: "./webflow-loader.ts",
-      config: {
-        deployUrl: "${COSMIC_DEPLOY_URL}",
-        mountPath: "${COSMIC_MOUNT_PATH}"
-      }
-    },
-  }
-};
-
-// https://astro.build/config
-export default defineConfig({
-  ...userConfig,
-  ...webflowOverrides,
-});

package/dist/templates/nextjs/next.config.ts

@@ -1,5 +0,0 @@
-// For tests
-export default {
-  basePath: "",
-  assetPrefix: "",
-};