@tinacms/astro 0.4.0 → 0.4.1

package/dist/integration.d.ts

@@ -1,5 +1,12 @@
 import type { AstroIntegration } from 'astro';
 export interface TinaIntegrationOptions {
     middlewareOrder?: 'pre' | 'post';
+    /**
+     * Force the Cloudflare Workers (workerd) `import.meta.url` workaround on or
+     * off. When omitted, it is applied automatically whenever the
+     * `@astrojs/cloudflare` adapter is detected. Set `false` to opt out, or
+     * `true` to force it for a custom Cloudflare setup.
+     */
+    cloudflareWorkers?: boolean;
 }
 export default function tina(options?: TinaIntegrationOptions): AstroIntegration;

package/dist/integration.js

@@ -4,9 +4,13 @@ import { createRequire } from "node:module";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 var BRIDGE_ROUTE = "/admin/bridge.js";
+var CLOUDFLARE_ADAPTER_NAME = "@astrojs/cloudflare";
+var WORKERD_IMPORT_META_URL = JSON.stringify("file:///worker.mjs");
+var SERVER_ENVIRONMENTS = /* @__PURE__ */ new Set(["ssr", "astro"]);
 function tina(options = {}) {
   const { middlewareOrder = "pre" } = options;
   let clientDir;
+  let isCloudflareAdapter = false;
   return {
     name: "@tinacms/astro",
     hooks: {
@@ -15,10 +19,18 @@ function tina(options = {}) {
           entrypoint: "@tinacms/astro/middleware",
           order: middlewareOrder
         });
-        updateConfig({ vite: { plugins: [bridgeDevPlugin()] } });
+        updateConfig({
+          vite: {
+            plugins: [
+              bridgeDevPlugin(),
+              cloudflareImportMetaUrlPlugin(() => isCloudflareAdapter)
+            ]
+          }
+        });
       },
       "astro:config:done": ({ config }) => {
         clientDir = config.build.client;
+        isCloudflareAdapter = options.cloudflareWorkers ?? config.adapter?.name === CLOUDFLARE_ADAPTER_NAME;
       },
       "astro:build:done": ({ logger }) => {
         if (!clientDir) return;
@@ -54,6 +66,18 @@ function bridgeDevPlugin() {
     }
   };
 }
+function cloudflareImportMetaUrlPlugin(isCloudflare) {
+  const define = { "import.meta.url": WORKERD_IMPORT_META_URL };
+  return {
+    name: "@tinacms/astro:cloudflare-import-meta-url",
+    // No `apply`: the define is needed in both the build (ssr) and dev envs.
+    configEnvironment(name) {
+      if (!isCloudflare()) return;
+      if (!SERVER_ENVIRONMENTS.has(name)) return;
+      return { define };
+    }
+  };
+}
 function emitBridgeAsset(adminDir, logger) {
   try {
     mkdirSync(adminDir, { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/astro",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "type": "module",
   "main": "src/TinaMarkdown.astro",
   "types": "dist/index.d.ts",

package/src/__tests__/integration.test.ts

@@ -12,11 +12,11 @@ type ConfigSetupArg = Parameters<NonNullable<Hooks['astro:config:setup']>>[0];
 type ConfigDoneArg = Parameters<NonNullable<Hooks['astro:config:done']>>[0];
 type BuildDoneArg = Parameters<NonNullable<Hooks['astro:build:done']>>[0];
 
-function runConfigSetup() {
+function runConfigSetup(options?: Parameters<typeof tina>[0]) {
   const addMiddleware = vi.fn();
   const updateConfig = vi.fn();
   const logger = { warn: vi.fn(), info: vi.fn() };
-  const integration = tina();
+  const integration = tina(options);
   (
     integration.hooks['astro:config:setup'] as NonNullable<
       Hooks['astro:config:setup']
@@ -28,6 +28,34 @@ function runConfigSetup() {
   return { integration, addMiddleware, updateConfig, logger, plugins };
 }
 
+// Drive the astro:config:done hook with a chosen adapter so the integration can
+// resolve whether the Cloudflare workaround should apply.
+function runConfigDone(integration: AstroIntegration, adapterName?: string) {
+  (
+    integration.hooks['astro:config:done'] as NonNullable<
+      Hooks['astro:config:done']
+    >
+  )({
+    config: {
+      build: { client: pathToFileURL('/tmp/tina-client/') },
+      adapter: adapterName ? { name: adapterName, hooks: {} } : undefined,
+    },
+  } as unknown as ConfigDoneArg);
+}
+
+const cfPlugin = (plugins: VitePlugin[]) =>
+  plugins.find(
+    (p) => p.name === '@tinacms/astro:cloudflare-import-meta-url'
+  ) as VitePlugin;
+
+// Invoke a plugin's `configEnvironment` hook (a function in our plugin) without
+// a real Vite environment — it only branches on the environment name.
+function runConfigEnvironment(plugin: VitePlugin, name: string) {
+  const hook = plugin.configEnvironment as any;
+  const fn = typeof hook === 'function' ? hook : hook?.handler;
+  return fn?.call({}, name, {}, {});
+}
+
 // Drive a Vite plugin's `configureServer` and capture the request handler it
 // registers, so we can exercise it without a real dev server.
 function devHandler(plugin: VitePlugin) {
@@ -96,6 +124,82 @@ describe('tina() integration — bridge dev plugin', () => {
   });
 });
 
+describe('tina() integration — cloudflare import.meta.url plugin', () => {
+  const EXPECTED = JSON.stringify('file:///worker.mjs');
+
+  it('injects a valid import.meta.url define for the workerd server envs under the cloudflare adapter', () => {
+    const { integration, plugins } = runConfigSetup();
+    runConfigDone(integration, '@astrojs/cloudflare');
+    const plugin = cfPlugin(plugins);
+    expect(plugin).toBeDefined();
+
+    for (const env of ['ssr', 'astro']) {
+      const result = runConfigEnvironment(plugin, env);
+      expect(result?.define?.['import.meta.url']).toBe(EXPECTED);
+      // The placeholder must itself be a valid absolute URL.
+      expect(
+        () => new URL(JSON.parse(result.define['import.meta.url']))
+      ).not.toThrow();
+    }
+  });
+
+  it('never injects the define into the client or prerender envs', () => {
+    const { integration, plugins } = runConfigSetup();
+    runConfigDone(integration, '@astrojs/cloudflare');
+    const plugin = cfPlugin(plugins);
+    // `client` keeps the real import.meta.url; `prerender` may run in Node.
+    expect(runConfigEnvironment(plugin, 'client')).toBeUndefined();
+    expect(runConfigEnvironment(plugin, 'prerender')).toBeUndefined();
+  });
+
+  it('does not inject the define for non-cloudflare adapters', () => {
+    for (const adapter of ['@astrojs/node', '@astrojs/vercel']) {
+      const { integration, plugins } = runConfigSetup();
+      runConfigDone(integration, adapter);
+      const plugin = cfPlugin(plugins);
+      for (const env of ['ssr', 'prerender', 'astro', 'client']) {
+        expect(runConfigEnvironment(plugin, env)).toBeUndefined();
+      }
+    }
+  });
+
+  it('does not inject the define when no adapter is configured', () => {
+    const { integration, plugins } = runConfigSetup();
+    runConfigDone(integration);
+    expect(runConfigEnvironment(cfPlugin(plugins), 'ssr')).toBeUndefined();
+  });
+
+  it('reads the adapter flag lazily, after config:done', () => {
+    const { integration, plugins } = runConfigSetup();
+    const plugin = cfPlugin(plugins);
+    // Before config:done the flag is false, so the plugin is inert.
+    expect(runConfigEnvironment(plugin, 'ssr')).toBeUndefined();
+    // The same plugin instance picks up the adapter once config:done runs.
+    runConfigDone(integration, '@astrojs/cloudflare');
+    expect(
+      runConfigEnvironment(plugin, 'ssr')?.define?.['import.meta.url']
+    ).toBe(EXPECTED);
+  });
+
+  it('honours the cloudflareWorkers option override', () => {
+    // Force on, even with a Node adapter.
+    const forcedOn = runConfigSetup({ cloudflareWorkers: true });
+    runConfigDone(forcedOn.integration, '@astrojs/node');
+    expect(
+      runConfigEnvironment(cfPlugin(forcedOn.plugins), 'ssr')?.define?.[
+        'import.meta.url'
+      ]
+    ).toBe(EXPECTED);
+
+    // Force off, even with the Cloudflare adapter.
+    const forcedOff = runConfigSetup({ cloudflareWorkers: false });
+    runConfigDone(forcedOff.integration, '@astrojs/cloudflare');
+    expect(
+      runConfigEnvironment(cfPlugin(forcedOff.plugins), 'ssr')
+    ).toBeUndefined();
+  });
+});
+
 describe('tina() integration — astro:build:done', () => {
   it('emits bridge.js into the client output dir', () => {
     const clientDir = mkdtempSync(join(tmpdir(), 'tina-client-'));

package/src/integration.ts

@@ -7,11 +7,32 @@ import type { Plugin as VitePlugin } from 'vite';
 
 export interface TinaIntegrationOptions {
   middlewareOrder?: 'pre' | 'post';
+  /**
+   * Force the Cloudflare Workers (workerd) `import.meta.url` workaround on or
+   * off. When omitted, it is applied automatically whenever the
+   * `@astrojs/cloudflare` adapter is detected. Set `false` to opt out, or
+   * `true` to force it for a custom Cloudflare setup.
+   */
+  cloudflareWorkers?: boolean;
 }
 
 /** Where the injected bridge bootstrap imports the bridge bundle from. */
 const BRIDGE_ROUTE = '/admin/bridge.js';
 
+const CLOUDFLARE_ADAPTER_NAME = '@astrojs/cloudflare';
+/** A valid absolute URL that stands in for `import.meta.url` in server bundles. */
+const WORKERD_IMPORT_META_URL = JSON.stringify('file:///worker.mjs');
+/**
+ * The Vite environments that run on workerd under `@astrojs/cloudflare` and
+ * therefore need the placeholder: `ssr` (the on-demand server build) and `astro`
+ * (the dev SSR runtime). The `client` bundle is excluded so the browser keeps
+ * the real `import.meta.url`, and `prerender` is excluded because it runs in
+ * real Node when `prerenderEnvironment: 'node'` (faking the URL there would
+ * break genuine file resolution) — and the island route is `prerender: false`,
+ * so it never renders during prerendering anyway.
+ */
+const SERVER_ENVIRONMENTS = new Set(['ssr', 'astro']);
+
 export default function tina(
   options: TinaIntegrationOptions = {}
 ): AstroIntegration {
@@ -19,6 +40,10 @@ export default function tina(
   // Resolved client output dir, captured at config:done and consumed at
   // build:done (only then is the final output location known).
   let clientDir: URL | undefined;
+  // Whether the Cloudflare adapter is in use, resolved at config:done. The
+  // injected Vite plugin reads it lazily (via a thunk) because the plugin is
+  // constructed at config:setup, before the adapter is known.
+  let isCloudflareAdapter = false;
 
   return {
     name: '@tinacms/astro',
@@ -32,10 +57,23 @@ export default function tina(
         // it into the user's source tree — config-time writes churn
         // public/admin on every `astro dev`/`astro build`, break on read-only
         // or sandboxed filesystems, and can race `tinacms build`.
-        updateConfig({ vite: { plugins: [bridgeDevPlugin()] } });
+        updateConfig({
+          vite: {
+            plugins: [
+              bridgeDevPlugin(),
+              cloudflareImportMetaUrlPlugin(() => isCloudflareAdapter),
+            ],
+          },
+        });
       },
       'astro:config:done': ({ config }) => {
         clientDir = config.build.client;
+        // config:done runs before Vite is created and after every integration
+        // (including a late-registered adapter) has resolved, so config.adapter
+        // is reliable here.
+        isCloudflareAdapter =
+          options.cloudflareWorkers ??
+          config.adapter?.name === CLOUDFLARE_ADAPTER_NAME;
       },
       'astro:build:done': ({ logger }) => {
         // Build: emit the bridge next to the admin SPA in the *output* tree.
@@ -82,6 +120,36 @@ function bridgeDevPlugin(): VitePlugin {
   };
 }
 
+/**
+ * Cloudflare Workers (workerd) runs the server bundle in a runtime where the
+ * bundled `import.meta.url` is not a valid absolute URL. Astro's experimental
+ * Container API — used by the on-demand island route — calls
+ * `new URL(import.meta.url)` while building its manifest, which throws
+ * "Invalid URL string" and 500s the island render in production. The paths it
+ * seeds from that URL are never dereferenced for an in-memory render, so a
+ * valid placeholder is harmless. We inject it as a Vite `define`, but only in
+ * the server environments (never the client bundle, which needs the real value)
+ * and only under the Cloudflare adapter (faking it on a Node server would break
+ * real file resolution).
+ *
+ * TODO: remove once Astro guards the unconditional `new URL(import.meta.url)` in
+ * createManifest (tracked upstream in withastro/astro).
+ */
+function cloudflareImportMetaUrlPlugin(
+  isCloudflare: () => boolean
+): VitePlugin {
+  const define = { 'import.meta.url': WORKERD_IMPORT_META_URL };
+  return {
+    name: '@tinacms/astro:cloudflare-import-meta-url',
+    // No `apply`: the define is needed in both the build (ssr) and dev envs.
+    configEnvironment(name) {
+      if (!isCloudflare()) return;
+      if (!SERVER_ENVIRONMENTS.has(name)) return;
+      return { define };
+    },
+  };
+}
+
 function emitBridgeAsset(adminDir: string, logger: AstroIntegrationLogger) {
   try {
     mkdirSync(adminDir, { recursive: true });