@astrojs/cloudflare 10.0.0 → 10.0.2

package/dist/index.js

@@ -88,14 +88,6 @@ export default function createIntegration(args) {
                             find: 'react-dom/server',
                             replacement: 'react-dom/server.browser',
                         },
-                        {
-                            find: 'solid-js/web',
-                            replacement: 'solid-js/web/dist/server',
-                        },
-                        {
-                            find: 'solid-js',
-                            replacement: 'solid-js/dist/server',
-                        },
                     ];
                     if (Array.isArray(vite.resolve.alias)) {
                         vite.resolve.alias = [...vite.resolve.alias, ...aliases];
@@ -105,10 +97,23 @@ export default function createIntegration(args) {
                             vite.resolve.alias[alias.find] = alias.replacement;
                         }
                     }
+                    vite.resolve.conditions ||= [];
+                    // We need those conditions, previous these conditions where applied at the esbuild step which we removed
+                    // https://github.com/withastro/astro/pull/7092
+                    vite.resolve.conditions.push('workerd', 'worker');
                     vite.ssr ||= {};
                     vite.ssr.target = 'webworker';
                     vite.ssr.noExternal = true;
-                    vite.ssr.external = _config.vite.ssr?.external ?? [];
+                    if (typeof _config.vite.ssr?.external === 'undefined')
+                        vite.ssr.external = [];
+                    if (typeof _config.vite.ssr?.external === 'boolean')
+                        vite.ssr.external = _config.vite.ssr?.external;
+                    if (Array.isArray(_config.vite.ssr?.external))
+                        // `@astrojs/vue` sets `@vue/server-renderer` to external
+                        // https://github.com/withastro/astro/blob/e648c5575a8774af739231cfa9fc27a32086aa5f/packages/integrations/vue/src/index.ts#L119
+                        // the cloudflare adapter needs to get all dependencies inlined, we use `noExternal` for that, but any `external` config overrides that
+                        // therefore we need to remove `@vue/server-renderer` from the external config again
+                        vite.ssr.external = _config.vite.ssr?.external.filter((entry) => entry !== '@vue/server-renderer');
                     vite.build ||= {};
                     vite.build.rollupOptions ||= {};
                     vite.build.rollupOptions.output ||= {};
@@ -123,6 +128,15 @@ export default function createIntegration(args) {
                         ...vite.define,
                     };
                 }
+                // we thought that vite config inside `if (target === 'server')` would not apply for client
+                // but it seems like the same `vite` reference is used for both
+                // so we need to reset the previous conflicting setting
+                // in the future we should look into a more robust solution
+                if (target === 'client') {
+                    vite.resolve ||= {};
+                    vite.resolve.conditions ||= [];
+                    vite.resolve.conditions = vite.resolve.conditions.filter((c) => c !== 'workerd' && c !== 'worker');
+                }
             },
             'astro:build:done': async ({ pages, routes, dir, logger }) => {
                 const PLATFORM_FILES = ['_headers', '_redirects', '_routes.json'];

package/dist/utils/generate-routes-json.js

@@ -58,6 +58,7 @@ class TrieNode {
 }
 class PathTrie {
     root;
+    returnHasWildcard = false;
     constructor() {
         this.root = new TrieNode();
     }
@@ -83,6 +84,7 @@ class PathTrie {
      */
     dfs(node, path, allPaths) {
         if (node.hasWildcardChild) {
+            this.returnHasWildcard = true;
             allPaths.push([...path, '*']);
             return;
         }
@@ -96,12 +98,44 @@ class PathTrie {
     getAllPaths() {
         const allPaths = [];
         this.dfs(this.root, [], allPaths);
-        return allPaths;
+        return [allPaths, this.returnHasWildcard];
     }
 }
 export async function createRoutesFile(_config, logger, routes, pages, redirects, includeExtends, excludeExtends) {
     const includePaths = [];
     const excludePaths = [];
+    /**
+     * All files in the `_config.build.assets` path, e.g. `_astro`
+     * are considered static assets and should not be handled by the function
+     * therefore we exclude a wildcard for that, e.g. `/_astro/*`
+     */
+    const assetsPath = segmentsToCfSyntax([
+        [{ content: _config.build.assets, dynamic: false, spread: false }],
+        [{ content: '', dynamic: true, spread: false }],
+    ], _config);
+    excludePaths.push(assetsPath);
+    if (existsSync(fileURLToPath(_config.publicDir))) {
+        const staticFiles = await glob(`${fileURLToPath(_config.publicDir)}/**/*`, {
+            cwd: fileURLToPath(_config.publicDir),
+            filesOnly: true,
+            dot: true,
+        });
+        for (const staticFile of staticFiles) {
+            if (['_headers', '_redirects', '_routes.json'].includes(staticFile))
+                continue;
+            const staticPath = staticFile;
+            const segments = removeLeadingForwardSlash(staticPath)
+                .split(posix.sep)
+                .filter(Boolean)
+                .map((s) => {
+                return getParts(s);
+            });
+            excludePaths.push(segmentsToCfSyntax(segments, _config));
+        }
+    }
+    for (const redirect of redirects) {
+        excludePaths.push(segmentsToCfSyntax(redirect, _config));
+    }
     let hasPrerendered404 = false;
     for (const route of routes) {
         const convertedPath = segmentsToCfSyntax(route.segments, _config);
@@ -132,6 +166,8 @@ export async function createRoutesFile(_config, logger, routes, pages, redirects
         }
     }
     for (const page of pages) {
+        if (page.pathname === '404')
+            hasPrerendered404 = true;
         const pageSegments = removeLeadingForwardSlash(page.pathname)
             .split(posix.sep)
             .filter(Boolean)
@@ -140,66 +176,58 @@ export async function createRoutesFile(_config, logger, routes, pages, redirects
         });
         excludePaths.push(segmentsToCfSyntax(pageSegments, _config));
     }
-    if (existsSync(fileURLToPath(_config.publicDir))) {
-        const staticFiles = await glob(`${fileURLToPath(_config.publicDir)}/**/*`, {
-            cwd: fileURLToPath(_config.publicDir),
-            filesOnly: true,
-            dot: true,
-        });
-        for (const staticFile of staticFiles) {
-            if (['_headers', '_redirects', '_routes.json'].includes(staticFile))
-                continue;
-            const staticPath = staticFile;
-            const segments = removeLeadingForwardSlash(staticPath)
-                .split(posix.sep)
-                .filter(Boolean)
-                .map((s) => {
-                return getParts(s);
-            });
-            excludePaths.push(segmentsToCfSyntax(segments, _config));
-        }
-    }
-    /**
-     * All files in the `_config.build.assets` path, e.g. `_astro`
-     * are considered static assets and should not be handled by the function
-     * therefore we exclude a wildcard for that, e.g. `/_astro/*`
-     */
-    const assetsPath = segmentsToCfSyntax([
-        [{ content: _config.build.assets, dynamic: false, spread: false }],
-        [{ content: '', dynamic: true, spread: false }],
-    ], _config);
-    excludePaths.push(assetsPath);
-    for (const redirect of redirects) {
-        excludePaths.push(segmentsToCfSyntax(redirect, _config));
-    }
     const includeTrie = new PathTrie();
     for (const includePath of includePaths) {
         includeTrie.insert(includePath);
     }
-    const deduplicatedIncludePaths = includeTrie.getAllPaths();
+    const [deduplicatedIncludePaths, includedPathsHaveWildcard] = includeTrie.getAllPaths();
     const excludeTrie = new PathTrie();
     for (const excludePath of excludePaths) {
+        /**
+         * A excludePath with starts with a wildcard (*) is a catch-all
+         * that would mean all routes are static, that would be equal to a full SSG project
+         * the adapter is not needed in this case, so we do not consider such paths
+         */
+        if (excludePath[0] === '*')
+            continue;
         excludeTrie.insert(excludePath);
     }
-    const deduplicatedExcludePaths = excludeTrie.getAllPaths();
+    const [deduplicatedExcludePaths, _excludedPathsHaveWildcard] = excludeTrie.getAllPaths();
     /**
      * Cloudflare allows no more than 100 include/exclude rules combined
      * https://developers.cloudflare.com/pages/functions/routing/#limits
      */
     const CLOUDFLARE_COMBINED_LIMIT = 100;
+    /**
+     * Caluclate the number of automated and extended include rules
+     */
+    const AUTOMATIC_INCLUDE_RULES_COUNT = deduplicatedIncludePaths.length;
+    const EXTENDED_INCLUDE_RULES_COUNT = includeExtends?.length ?? 0;
+    const INCLUDE_RULES_COUNT = AUTOMATIC_INCLUDE_RULES_COUNT + EXTENDED_INCLUDE_RULES_COUNT;
+    /**
+     * Caluclate the number of automated and extended exclude rules
+     */
+    const AUTOMATIC_EXCLUDE_RULES_COUNT = deduplicatedExcludePaths.length;
+    const EXTENDED_EXCLUDE_RULES_COUNT = excludeExtends?.length ?? 0;
+    const EXCLUDE_RULES_COUNT = AUTOMATIC_EXCLUDE_RULES_COUNT + EXTENDED_EXCLUDE_RULES_COUNT;
     if (!hasPrerendered404 ||
-        deduplicatedIncludePaths.length + (includeExtends?.length ?? 0) > CLOUDFLARE_COMBINED_LIMIT ||
-        deduplicatedExcludePaths.length + (excludeExtends?.length ?? 0) > CLOUDFLARE_COMBINED_LIMIT) {
+        INCLUDE_RULES_COUNT > CLOUDFLARE_COMBINED_LIMIT ||
+        EXCLUDE_RULES_COUNT > CLOUDFLARE_COMBINED_LIMIT) {
         await writeRoutesFileToOutDir(_config, logger, ['/*'].concat(includeExtends?.map((entry) => entry.pattern) ?? []), deduplicatedExcludePaths
             .map((path) => `${prependForwardSlash(path.join('/'))}`)
-            .concat(excludeExtends?.map((entry) => entry.pattern) ?? [])
-            .slice(0, 99));
+            .slice(0, CLOUDFLARE_COMBINED_LIMIT -
+            EXTENDED_INCLUDE_RULES_COUNT -
+            EXTENDED_EXCLUDE_RULES_COUNT -
+            1)
+            .concat(excludeExtends?.map((entry) => entry.pattern) ?? []));
     }
     else {
         await writeRoutesFileToOutDir(_config, logger, deduplicatedIncludePaths
             .map((path) => `${prependForwardSlash(path.join('/'))}`)
-            .concat(includeExtends?.map((entry) => entry.pattern) ?? []), deduplicatedExcludePaths
-            .map((path) => `${prependForwardSlash(path.join('/'))}`)
-            .concat(excludeExtends?.map((entry) => entry.pattern) ?? []));
+            .concat(includeExtends?.map((entry) => entry.pattern) ?? []), includedPathsHaveWildcard
+            ? deduplicatedExcludePaths
+                .map((path) => `${prependForwardSlash(path.join('/'))}`)
+                .concat(excludeExtends?.map((entry) => entry.pattern) ?? [])
+            : []);
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "10.0.0",
+  "version": "10.0.2",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -35,7 +35,7 @@
     "miniflare": "^3.20240320.0",
     "esbuild": "^0.19.5",
     "tiny-glob": "^0.2.9",
-    "wrangler": "^3.36.0"
+    "wrangler": "^3.39.0"
   },
   "peerDependencies": {
     "astro": "^4.2.0"