@astrojs/cloudflare 9.2.1 → 10.0.1

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

@@ -0,0 +1,205 @@
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { posix } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { prependForwardSlash, removeLeadingForwardSlash, removeTrailingForwardSlash, } from '@astrojs/internal-helpers/path';
+import glob from 'tiny-glob';
+// Copied from https://github.com/withastro/astro/blob/3776ecf0aa9e08a992d3ae76e90682fd04093721/packages/astro/src/core/routing/manifest/create.ts#L45-L70
+// We're not sure how to improve this regex yet
+const ROUTE_DYNAMIC_SPLIT = /\[(.+?\(.+?\)|.+?)\]/;
+const ROUTE_SPREAD = /^\.{3}.+$/;
+export function getParts(part) {
+    const result = [];
+    part.split(ROUTE_DYNAMIC_SPLIT).map((str, i) => {
+        if (!str)
+            return;
+        const dynamic = i % 2 === 1;
+        const [, content] = dynamic ? /([^(]+)$/.exec(str) || [null, null] : [null, str];
+        if (!content || (dynamic && !/^(?:\.\.\.)?[\w$]+$/.test(content))) {
+            throw new Error('Parameter name must match /^[a-zA-Z0-9_$]+$/');
+        }
+        result.push({
+            content,
+            dynamic,
+            spread: dynamic && ROUTE_SPREAD.test(content),
+        });
+    });
+    return result;
+}
+async function writeRoutesFileToOutDir(_config, logger, include, exclude) {
+    try {
+        await writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
+            version: 1,
+            include: include,
+            exclude: exclude,
+        }, null, 2), 'utf-8');
+    }
+    catch (error) {
+        logger.error("There was an error writing the '_routes.json' file to the output directory.");
+    }
+}
+function segmentsToCfSyntax(segments, _config) {
+    const pathSegments = [];
+    if (removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)).length > 0) {
+        pathSegments.push(removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)));
+    }
+    for (const segment of segments.flat()) {
+        if (segment.dynamic)
+            pathSegments.push('*');
+        else
+            pathSegments.push(segment.content);
+    }
+    return pathSegments;
+}
+class TrieNode {
+    children = new Map();
+    isEndOfPath = false;
+    hasWildcardChild = false;
+}
+class PathTrie {
+    root;
+    constructor() {
+        this.root = new TrieNode();
+    }
+    insert(path) {
+        let node = this.root;
+        for (const segment of path) {
+            if (segment === '*') {
+                node.hasWildcardChild = true;
+                break;
+            }
+            if (!node.children.has(segment)) {
+                node.children.set(segment, new TrieNode());
+            }
+            // biome-ignore lint/style/noNonNullAssertion: The `if` condition above ensures that the segment exists inside the map
+            node = node.children.get(segment);
+        }
+        node.isEndOfPath = true;
+    }
+    /**
+     * Depth-first search (dfs), traverses the "graph"  segment by segment until the end or wildcard (*).
+     * It makes sure that all necessary paths are returned, but not paths with an existing wildcard prefix.
+     * e.g. if we have a path like /foo/* and /foo/bar, we only want to return /foo/*
+     */
+    dfs(node, path, allPaths) {
+        if (node.hasWildcardChild) {
+            allPaths.push([...path, '*']);
+            return;
+        }
+        if (node.isEndOfPath) {
+            allPaths.push([...path]);
+        }
+        for (const [segment, childNode] of node.children) {
+            this.dfs(childNode, [...path, segment], allPaths);
+        }
+    }
+    getAllPaths() {
+        const allPaths = [];
+        this.dfs(this.root, [], allPaths);
+        return allPaths;
+    }
+}
+export async function createRoutesFile(_config, logger, routes, pages, redirects, includeExtends, excludeExtends) {
+    const includePaths = [];
+    const excludePaths = [];
+    let hasPrerendered404 = false;
+    for (const route of routes) {
+        const convertedPath = segmentsToCfSyntax(route.segments, _config);
+        if (route.pathname === '/404' && route.prerender === true)
+            hasPrerendered404 = true;
+        switch (route.type) {
+            case 'page':
+                if (route.prerender === false)
+                    includePaths.push(convertedPath);
+                break;
+            case 'endpoint':
+                if (route.prerender === false)
+                    includePaths.push(convertedPath);
+                else
+                    excludePaths.push(convertedPath);
+                break;
+            case 'redirect':
+                excludePaths.push(convertedPath);
+                break;
+            default:
+                /**
+                 * We don't know the type, so we are conservative!
+                 * Invoking the function on these is a safe-bet because
+                 * the function will fallback to static asset fetching
+                 */
+                includePaths.push(convertedPath);
+                break;
+        }
+    }
+    for (const page of pages) {
+        const pageSegments = removeLeadingForwardSlash(page.pathname)
+            .split(posix.sep)
+            .filter(Boolean)
+            .map((s) => {
+            return getParts(s);
+        });
+        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 excludeTrie = new PathTrie();
+    for (const excludePath of excludePaths) {
+        excludeTrie.insert(excludePath);
+    }
+    const deduplicatedExcludePaths = 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;
+    if (!hasPrerendered404 ||
+        deduplicatedIncludePaths.length + (includeExtends?.length ?? 0) > CLOUDFLARE_COMBINED_LIMIT ||
+        deduplicatedExcludePaths.length + (excludeExtends?.length ?? 0) > 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));
+    }
+    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) ?? []));
+    }
+}

package/dist/utils/image-config.d.ts

@@ -1,5 +1,5 @@
 import type { AstroConfig, AstroIntegrationLogger } from 'astro';
-export declare function prepareImageConfig(service: string, config: AstroConfig['image'], command: 'dev' | 'build' | 'preview', logger: AstroIntegrationLogger): {
+export declare function setImageConfig(service: string, config: AstroConfig['image'], command: 'dev' | 'build' | 'preview', logger: AstroIntegrationLogger): {
     service: import("astro").ImageServiceConfig<Record<string, any>>;
     domains: string[];
     remotePatterns: {

package/dist/utils/image-config.js

@@ -1,5 +1,5 @@
 import { passthroughImageService, sharpImageService } from 'astro/config';
-export function prepareImageConfig(service, config, command, logger) {
+export function setImageConfig(service, config, command, logger) {
     switch (service) {
         case 'passthrough':
             return { ...config, service: passthroughImageService() };

package/dist/utils/wasm-module-loader.d.ts

@@ -8,7 +8,6 @@ import type { AstroConfig } from 'astro';
  * @param assetsDirectory - the folder name for the assets directory in the build directory. Usually '_astro'
  * @returns Vite plugin to load WASM tagged with '?module' as a WASM modules
  */
-export declare function wasmModuleLoader({ disabled, assetsDirectory, }: {
+export declare function wasmModuleLoader({ disabled, }: {
     disabled: boolean;
-    assetsDirectory: string;
 }): NonNullable<AstroConfig['vite']['plugins']>[number];

package/dist/utils/wasm-module-loader.js

@@ -9,7 +9,7 @@ import * as path from 'node:path';
  * @param assetsDirectory - the folder name for the assets directory in the build directory. Usually '_astro'
  * @returns Vite plugin to load WASM tagged with '?module' as a WASM modules
  */
-export function wasmModuleLoader({ disabled, assetsDirectory, }) {
+export function wasmModuleLoader({ disabled, }) {
     const postfix = '.wasm?module';
     let isDev = false;
     return {
@@ -22,7 +22,12 @@ export function wasmModuleLoader({ disabled, assetsDirectory, }) {
             // let vite know that file format and the magic import string is intentional, and will be handled in this plugin
             return {
                 assetsInclude: ['**/*.wasm?module'],
-                build: { rollupOptions: { external: /^__WASM_ASSET__.+\.wasm\.mjs$/i } },
+                build: {
+                    rollupOptions: {
+                        // mark the wasm files as external so that they are not bundled and instead are loaded from the files
+                        external: [/^__WASM_ASSET__.+\.wasm$/i, /^__WASM_ASSET__.+\.wasm.mjs$/i],
+                    },
+                },
             };
         },
         load(id, _) {
@@ -35,10 +40,7 @@ export function wasmModuleLoader({ disabled, assetsDirectory, }) {
             const filePath = id.slice(0, -1 * '?module'.length);
             const data = fs.readFileSync(filePath);
             const base64 = data.toString('base64');
-            const base64Module = `
-const wasmModule = new WebAssembly.Module(Uint8Array.from(atob("${base64}"), c => c.charCodeAt(0)));
-export default wasmModule
-`;
+            const base64Module = `const wasmModule = new WebAssembly.Module(Uint8Array.from(atob("${base64}"), c => c.charCodeAt(0)));export default wasmModule;`;
             if (isDev) {
                 // no need to wire up the assets in dev mode, just rewrite
                 return base64Module;
@@ -53,8 +55,8 @@ export default wasmModule
                 // put it explicitly in the _astro assets directory with `fileName` rather than `name` so that
                 // vite doesn't give it a random id in its name. We need to be able to easily rewrite from
                 // the .mjs loader and the actual wasm asset later in the ESbuild for the worker
-                fileName: path.join(assetsDirectory, assetName),
-                source: fs.readFileSync(filePath),
+                fileName: assetName,
+                source: data,
             });
             // however, by default, the SSG generator cannot import the .wasm as a module, so embed as a base64 string
             const chunkId = this.emitFile({
@@ -62,10 +64,7 @@ export default wasmModule
                 fileName: `${assetName}.mjs`,
                 code: base64Module,
             });
-            return `
-import wasmModule from "__WASM_ASSET__${chunkId}.wasm.mjs";
-export default wasmModule;
-	`;
+            return `import wasmModule from "__WASM_ASSET__${chunkId}.wasm.mjs";export default wasmModule;`;
         },
         // output original wasm file relative to the chunk
         renderChunk(code, chunk, _) {
@@ -73,13 +72,28 @@ export default wasmModule;
                 return;
             if (!/__WASM_ASSET__/g.test(code))
                 return;
-            const final = code.replaceAll(/__WASM_ASSET__([A-Za-z\d]+).wasm.mjs/g, (s, assetId) => {
-                const fileName = this.getFileName(assetId);
-                const relativePath = path
-                    .relative(path.dirname(chunk.fileName), fileName)
-                    .replaceAll('\\', '/'); // fix windows paths for import
-                return `./${relativePath}`;
-            });
+            const isPrerendered = Object.keys(chunk.modules).some((moduleId) => this.getModuleInfo(moduleId)?.meta?.astro?.pageOptions?.prerender === true);
+            let final = code;
+            // SSR
+            if (!isPrerendered) {
+                final = code.replaceAll(/__WASM_ASSET__([A-Za-z\d]+).wasm.mjs/g, (s, assetId) => {
+                    const fileName = this.getFileName(assetId).replace(/\.mjs$/, '');
+                    const relativePath = path
+                        .relative(path.dirname(chunk.fileName), fileName)
+                        .replaceAll('\\', '/'); // fix windows paths for import
+                    return `./${relativePath}`;
+                });
+            }
+            // SSG
+            if (isPrerendered) {
+                final = code.replaceAll(/__WASM_ASSET__([A-Za-z\d]+).wasm.mjs/g, (s, assetId) => {
+                    const fileName = this.getFileName(assetId);
+                    const relativePath = path
+                        .relative(path.dirname(chunk.fileName), fileName)
+                        .replaceAll('\\', '/'); // fix windows paths for import
+                    return `./${relativePath}`;
+                });
+            }
             return { code: final };
         },
     };

package/package.json

@@ -1,8 +1,7 @@
 {
-  "//comment": "test changeset-bot",
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "9.2.1",
+  "version": "10.0.1",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -31,27 +30,24 @@
   ],
   "dependencies": {
     "@astrojs/underscore-redirects": "^0.3.3",
-    "@cloudflare/workers-types": "^4.20231025.0",
-    "miniflare": "3.20231030.2",
-    "@iarna/toml": "^2.2.5",
-    "dotenv": "^16.3.1",
+    "@astrojs/internal-helpers": "0.3.0",
+    "@cloudflare/workers-types": "^4.20240320.1",
+    "miniflare": "^3.20240320.0",
     "esbuild": "^0.19.5",
-    "find-up": "^6.3.0",
-    "tiny-glob": "^0.2.9"
+    "tiny-glob": "^0.2.9",
+    "wrangler": "^3.39.0"
   },
   "peerDependencies": {
     "astro": "^4.2.0"
   },
   "devDependencies": {
     "execa": "^8.0.1",
-    "fast-glob": "^3.3.1",
-    "@types/iarna__toml": "^2.0.2",
+    "fast-glob": "^3.3.2",
     "strip-ansi": "^7.1.0",
-    "astro": "^4.3.5",
+    "astro": "^4.5.8",
     "cheerio": "1.0.0-rc.12",
-    "wrangler": "^3.15.0",
-    "@astrojs/test-utils": "0.0.1",
-    "astro-scripts": "0.0.14"
+    "astro-scripts": "0.0.14",
+    "@astrojs/test-utils": "0.0.1"
   },
   "publishConfig": {
     "provenance": true

package/dist/entrypoints/server.directory.d.ts

@@ -1,14 +0,0 @@
-import type { Request as CFRequest, CacheStorage, EventContext } from '@cloudflare/workers-types';
-import type { SSRManifest } from 'astro';
-export interface DirectoryRuntime<T extends object = object> {
-    runtime: {
-        waitUntil: (promise: Promise<any>) => void;
-        env: EventContext<unknown, string, unknown>['env'] & T;
-        cf: CFRequest['cf'];
-        caches: CacheStorage;
-    };
-}
-export declare function createExports(manifest: SSRManifest): {
-    onRequest: (context: EventContext<unknown, string, unknown>) => Promise<Response | import("@cloudflare/workers-types").Response>;
-    manifest: SSRManifest;
-};

package/dist/entrypoints/server.directory.js

@@ -1,40 +0,0 @@
-import { App } from 'astro/app';
-import { getProcessEnvProxy, isNode } from '../util.js';
-if (!isNode) {
-    process.env = getProcessEnvProxy();
-}
-export function createExports(manifest) {
-    const app = new App(manifest);
-    const onRequest = async (context) => {
-        const request = context.request;
-        const { env } = context;
-        // TODO: remove this any cast in the future
-        // REF: the type cast to any is needed because the Cloudflare Env Type is not assignable to type 'ProcessEnv'
-        process.env = env;
-        const { pathname } = new URL(request.url);
-        // static assets fallback, in case default _routes.json is not used
-        if (manifest.assets.has(pathname)) {
-            return env.ASSETS.fetch(request);
-        }
-        const routeData = app.match(request);
-        Reflect.set(request, Symbol.for('astro.clientAddress'), request.headers.get('cf-connecting-ip'));
-        const locals = {
-            runtime: {
-                waitUntil: (promise) => {
-                    context.waitUntil(promise);
-                },
-                env: context.env,
-                cf: request.cf,
-                caches: caches,
-            },
-        };
-        const response = await app.render(request, { routeData, locals });
-        if (app.setCookieHeaders) {
-            for (const setCookieHeader of app.setCookieHeaders(response)) {
-                response.headers.append('Set-Cookie', setCookieHeader);
-            }
-        }
-        return response;
-    };
-    return { onRequest, manifest };
-}

package/dist/getAdapter.d.ts

@@ -1,5 +0,0 @@
-import type { AstroAdapter } from 'astro';
-export declare function getAdapter({ isModeDirectory, functionPerRoute, }: {
-    isModeDirectory: boolean;
-    functionPerRoute: boolean;
-}): AstroAdapter;

package/dist/getAdapter.js

@@ -1,30 +0,0 @@
-export function getAdapter({ isModeDirectory, functionPerRoute, }) {
-    const astroFeatures = {
-        hybridOutput: 'stable',
-        staticOutput: 'unsupported',
-        serverOutput: 'stable',
-        assets: {
-            supportKind: 'stable',
-            isSharpCompatible: false,
-            isSquooshCompatible: false,
-        },
-    };
-    if (isModeDirectory) {
-        return {
-            name: '@astrojs/cloudflare',
-            serverEntrypoint: '@astrojs/cloudflare/entrypoints/server.directory.js',
-            exports: ['onRequest', 'manifest'],
-            adapterFeatures: {
-                functionPerRoute,
-                edgeMiddleware: false,
-            },
-            supportedAstroFeatures: astroFeatures,
-        };
-    }
-    return {
-        name: '@astrojs/cloudflare',
-        serverEntrypoint: '@astrojs/cloudflare/entrypoints/server.advanced.js',
-        exports: ['default'],
-        supportedAstroFeatures: astroFeatures,
-    };
-}

package/dist/util.d.ts

@@ -1,2 +0,0 @@
-export declare const isNode: boolean;
-export declare function getProcessEnvProxy(): {};

package/dist/util.js

@@ -1,10 +0,0 @@
-export const isNode = typeof process === 'object' && Object.prototype.toString.call(process) === '[object process]';
-export function getProcessEnvProxy() {
-    return new Proxy({}, {
-        get: (target, prop) => {
-            console.warn(
-            // NOTE: \0 prevents Vite replacement
-            `Unable to access \`import.meta\0.env.${prop.toString()}\` on initialization as the Cloudflare platform only provides the environment variables per request. Please move the environment variable access inside a function that's only called after a request has been received.`);
-        },
-    });
-}

package/dist/utils/deduplicatePatterns.d.ts

@@ -1,8 +0,0 @@
-/**
- * Remove duplicates and redundant patterns from an `include` or `exclude` list.
- * Otherwise Cloudflare will throw an error on deployment. Plus, it saves more entries.
- * E.g. `['/foo/*', '/foo/*', '/foo/bar'] => ['/foo/*']`
- * @param patterns a list of `include` or `exclude` patterns
- * @returns a deduplicated list of patterns
- */
-export declare function deduplicatePatterns(patterns: string[]): string[];

package/dist/utils/deduplicatePatterns.js

@@ -1,25 +0,0 @@
-/**
- * Remove duplicates and redundant patterns from an `include` or `exclude` list.
- * Otherwise Cloudflare will throw an error on deployment. Plus, it saves more entries.
- * E.g. `['/foo/*', '/foo/*', '/foo/bar'] => ['/foo/*']`
- * @param patterns a list of `include` or `exclude` patterns
- * @returns a deduplicated list of patterns
- */
-export function deduplicatePatterns(patterns) {
-    const openPatterns = [];
-    // A value in the set may only occur once; it is unique in the set's collection.
-    // ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
-    const uniquePatterns = [...new Set(patterns)];
-    for (const pattern of uniquePatterns) {
-        if (pattern.endsWith('*')) {
-            openPatterns.push(new RegExp(`^${pattern.replace(/(\*\/)*\*$/g, '(?=.{2,}).+[^*\n]$')}`));
-        }
-    }
-    return uniquePatterns
-        .sort((a, b) => a.length - b.length)
-        .filter((pattern) => {
-        if (openPatterns.some((p) => p.test(pattern)))
-            return false;
-        return true;
-    });
-}