@astrojs/cloudflare 7.7.1 → 8.0.1

package/dist/index.js

@@ -1,50 +1,27 @@
-import { createRedirectsFromAstroRoutes } from '@astrojs/underscore-redirects';
-import { AstroError } from 'astro/errors';
-import esbuild from 'esbuild';
-import { Miniflare } from 'miniflare';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import { dirname, relative, sep } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createRedirectsFromAstroRoutes } from '@astrojs/underscore-redirects';
+import { AstroError } from 'astro/errors';
+import esbuild from 'esbuild';
 import glob from 'tiny-glob';
 import { getAdapter } from './getAdapter.js';
 import { deduplicatePatterns } from './utils/deduplicatePatterns.js';
-import { getCFObject } from './utils/getCFObject.js';
 import { prepareImageConfig } from './utils/image-config.js';
-import { getD1Bindings, getDOBindings, getEnvVars, getKVBindings, getR2Bindings, } from './utils/parser.js';
+import { getLocalRuntime, getRuntimeConfig } from './utils/local-runtime.js';
 import { prependForwardSlash } from './utils/prependForwardSlash.js';
 import { rewriteWasmImportPath } from './utils/rewriteWasmImportPath.js';
 import { wasmModuleLoader } from './utils/wasm-module-loader.js';
-const RUNTIME_WARNING = `You are using a deprecated string format for the \`runtime\` API. Please update to the current format for better support. 
-
-Example:
-Old Format: 'local'
-Current Format: { mode: 'local', persistTo: '.wrangler/state/v3' }
-
-Please refer to our runtime documentation for more details on the format. https://docs.astro.build/en/guides/integrations-guide/cloudflare/#runtime`;
 export default function createIntegration(args) {
     let _config;
     let _buildConfig;
-    let _mf;
+    let _localRuntime;
     let _entryPoints = new Map();
     const SERVER_BUILD_FOLDER = '/$server_build/';
     const isModeDirectory = args?.mode === 'directory';
     const functionPerRoute = args?.functionPerRoute ?? false;
-    let runtimeMode = { mode: 'off' };
-    if (args?.runtime === 'remote') {
-        runtimeMode = { mode: 'remote' };
-    }
-    else if (args?.runtime === 'local') {
-        runtimeMode = { mode: 'local', persistTo: '.wrangler/state/v3' };
-    }
-    else if (typeof args?.runtime === 'object' &&
-        args?.runtime.mode === 'local' &&
-        args.runtime.persistTo === undefined) {
-        runtimeMode = { mode: 'local', persistTo: '.wrangler/state/v3' };
-    }
-    else if (args?.runtime) {
-        runtimeMode = args?.runtime;
-    }
+    const runtimeMode = getRuntimeConfig(args?.runtime);
     return {
         name: '@astrojs/cloudflare',
         hooks: {
@@ -68,7 +45,7 @@ export default function createIntegration(args) {
                     image: prepareImageConfig(args?.imageService ?? 'DEFAULT', config.image, command, logger),
                 });
             },
-            'astro:config:done': ({ setAdapter, config, logger }) => {
+            'astro:config:done': ({ setAdapter, config }) => {
                 setAdapter(getAdapter({ isModeDirectory, functionPerRoute }));
                 _config = config;
                 _buildConfig = config.build;
@@ -78,97 +55,38 @@ export default function createIntegration(args) {
                 if (_config.base === SERVER_BUILD_FOLDER) {
                     throw new AstroError('[@astrojs/cloudflare] `base: "${SERVER_BUILD_FOLDER}"` is not allowed. Please change your `base` config to something else.');
                 }
-                if (typeof args?.runtime === 'string') {
-                    logger.warn(RUNTIME_WARNING);
-                }
             },
-            'astro:server:setup': ({ server }) => {
+            'astro:server:setup': ({ server, logger }) => {
                 if (runtimeMode.mode === 'local') {
-                    const typedRuntimeMode = runtimeMode;
                     server.middlewares.use(async function middleware(req, res, next) {
-                        try {
-                            const cf = await getCFObject(typedRuntimeMode.mode);
-                            const vars = await getEnvVars();
-                            const D1Bindings = await getD1Bindings();
-                            const R2Bindings = await getR2Bindings();
-                            const KVBindings = await getKVBindings();
-                            const DOBindings = await getDOBindings();
-                            let bindingsEnv = new Object({});
-                            // fix for the error "kj/filesystem-disk-unix.c++:1709: warning: PWD environment variable doesn't match current directory."
-                            // note: This mismatch might be primarily due to the test runner.
-                            const originalPWD = process.env.PWD;
-                            process.env.PWD = process.cwd();
-                            _mf = new Miniflare({
-                                modules: true,
-                                script: '',
-                                cache: true,
-                                cachePersist: `${typedRuntimeMode.persistTo}/cache`,
-                                cacheWarnUsage: true,
-                                d1Databases: D1Bindings,
-                                d1Persist: `${typedRuntimeMode.persistTo}/d1`,
-                                r2Buckets: R2Bindings,
-                                r2Persist: `${typedRuntimeMode.persistTo}/r2`,
-                                kvNamespaces: KVBindings,
-                                kvPersist: `${typedRuntimeMode.persistTo}/kv`,
-                                durableObjects: DOBindings,
-                                durableObjectsPersist: `${typedRuntimeMode.persistTo}/do`,
-                            });
-                            await _mf.ready;
-                            for (const D1Binding of D1Bindings) {
-                                const db = await _mf.getD1Database(D1Binding);
-                                Reflect.set(bindingsEnv, D1Binding, db);
-                            }
-                            for (const R2Binding of R2Bindings) {
-                                const bucket = await _mf.getR2Bucket(R2Binding);
-                                Reflect.set(bindingsEnv, R2Binding, bucket);
-                            }
-                            for (const KVBinding of KVBindings) {
-                                const namespace = await _mf.getKVNamespace(KVBinding);
-                                Reflect.set(bindingsEnv, KVBinding, namespace);
-                            }
-                            for (const key in DOBindings) {
-                                if (Object.prototype.hasOwnProperty.call(DOBindings, key)) {
-                                    const DO = await _mf.getDurableObjectNamespace(key);
-                                    Reflect.set(bindingsEnv, key, DO);
-                                }
-                            }
-                            const mfCache = await _mf.getCaches();
-                            process.env.PWD = originalPWD;
-                            const clientLocalsSymbol = Symbol.for('astro.locals');
-                            Reflect.set(req, clientLocalsSymbol, {
-                                runtime: {
-                                    env: {
-                                        // default binding for static assets will be dynamic once we support mocking of bindings
-                                        ASSETS: {},
-                                        // this is just a VAR for CF to change build behavior, on dev it should be 0
-                                        CF_PAGES: '0',
-                                        // will be fetched from git dynamically once we support mocking of bindings
-                                        CF_PAGES_BRANCH: 'TBA',
-                                        // will be fetched from git dynamically once we support mocking of bindings
-                                        CF_PAGES_COMMIT_SHA: 'TBA',
-                                        CF_PAGES_URL: `http://${req.headers.host}`,
-                                        ...bindingsEnv,
-                                        ...vars,
-                                    },
-                                    cf: cf,
-                                    waitUntil: (_promise) => {
-                                        return;
-                                    },
-                                    caches: mfCache,
+                        _localRuntime = getLocalRuntime(_config, runtimeMode, logger);
+                        const bindings = await _localRuntime.getBindings();
+                        const secrets = await _localRuntime.getSecrets();
+                        const caches = await _localRuntime.getCaches();
+                        const cf = await _localRuntime.getCF();
+                        const clientLocalsSymbol = Symbol.for('astro.locals');
+                        Reflect.set(req, clientLocalsSymbol, {
+                            runtime: {
+                                env: {
+                                    CF_PAGES_URL: `http://${req.headers.host}`,
+                                    ...bindings,
+                                    ...secrets,
                                 },
-                            });
-                            next();
-                        }
-                        catch {
-                            next();
-                        }
+                                cf: cf,
+                                caches: caches,
+                                waitUntil: (_promise) => {
+                                    return;
+                                },
+                            },
+                        });
+                        next();
                     });
                 }
             },
             'astro:server:done': async ({ logger }) => {
-                if (_mf) {
-                    logger.info('Cleaning up the Miniflare instance, and shutting down the workerd server.');
-                    await _mf.dispose();
+                if (_localRuntime) {
+                    logger.info('Cleaning up the local Cloudflare runtime.');
+                    await _localRuntime.dispose();
                 }
             },
             'astro:build:setup': ({ vite, target }) => {
@@ -209,8 +127,7 @@ export default function createIntegration(args) {
                 if (isModeDirectory) {
                     await fs.promises.mkdir(functionsUrl, { recursive: true });
                 }
-                // TODO: remove _buildConfig.split in Astro 4.0
-                if (isModeDirectory && (_buildConfig.split || functionPerRoute)) {
+                if (isModeDirectory && functionPerRoute) {
                     const entryPointsURL = [..._entryPoints.values()];
                     const entryPaths = entryPointsURL.map((entry) => fileURLToPath(entry));
                     const outputUrl = new URL('$astro', _buildConfig.server);
@@ -276,7 +193,7 @@ export default function createIntegration(args) {
                                 : [rewriteWasmImportPath({ relativePathToAssets })],
                         });
                     }
-                    const outputFiles = await glob(`**/*`, {
+                    const outputFiles = await glob('**/*', {
                         cwd: outputDir,
                         filesOnly: true,
                     });
@@ -398,17 +315,14 @@ export default function createIntegration(args) {
                         .map((route) => {
                         if (route.component === 'src/pages/404.astro' && route.prerender === false)
                             notFoundIsSSR = true;
-                        const includePattern = '/' +
-                            route.segments
-                                .flat()
-                                .map((segment) => (segment.dynamic ? '*' : segment.content))
-                                .join('/');
-                        const regexp = new RegExp('^\\/' +
-                            route.segments
-                                .flat()
-                                .map((segment) => (segment.dynamic ? '(.*)' : segment.content))
-                                .join('\\/') +
-                            '$');
+                        const includePattern = `/${route.segments
+                            .flat()
+                            .map((segment) => (segment.dynamic ? '*' : segment.content))
+                            .join('/')}`;
+                        const regexp = new RegExp(`^\\/${route.segments
+                            .flat()
+                            .map((segment) => (segment.dynamic ? '(.*)' : segment.content))
+                            .join('\\/')}$`);
                         return {
                             includePattern,
                             regexp,
@@ -421,7 +335,7 @@ export default function createIntegration(args) {
                     }))
                         .filter((file) => cloudflareSpecialFiles.indexOf(file) < 0)
                         .map((file) => `/${file.replace(/\\/g, '/')}`);
-                    for (let page of pages) {
+                    for (const page of pages) {
                         let pagePath = prependForwardSlash(page.pathname);
                         if (_config.base !== '/') {
                             const base = _config.base.endsWith('/') ? _config.base.slice(0, -1) : _config.base;
@@ -443,13 +357,11 @@ export default function createIntegration(args) {
                             if (parts.length < 2) {
                                 return null;
                             }
-                            else {
-                                // convert /products/:id to /products/*
-                                return (parts[0]
-                                    .replace(/\/:.*?(?=\/|$)/g, '/*')
-                                    // remove query params as they are not supported by cloudflare
-                                    .replace(/\?.*$/, ''));
-                            }
+                            // convert /products/:id to /products/*
+                            return (parts[0]
+                                .replace(/\/:.*?(?=\/|$)/g, '/*')
+                                // remove query params as they are not supported by cloudflare
+                                .replace(/\?.*$/, ''));
                         })
                             .filter((line, index, arr) => line !== null && arr.indexOf(line) === index);
                         if (redirects.length > 0) {

package/dist/util.js

@@ -4,10 +4,7 @@ export function getProcessEnvProxy() {
         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.`);
+            `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/assets.js

@@ -8,14 +8,14 @@ export function matchHostname(url, hostname, allowWildcard) {
     if (!hostname) {
         return true;
     }
-    else if (!allowWildcard || !hostname.startsWith('*')) {
+    if (!allowWildcard || !hostname.startsWith('*')) {
         return hostname === url.hostname;
     }
-    else if (hostname.startsWith('**.')) {
+    if (hostname.startsWith('**.')) {
         const slicedHostname = hostname.slice(2); // ** length
         return slicedHostname !== url.hostname && url.hostname.endsWith(slicedHostname);
     }
-    else if (hostname.startsWith('*.')) {
+    if (hostname.startsWith('*.')) {
         const slicedHostname = hostname.slice(1); // * length
         const additionalSubdomains = url.hostname
             .replace(slicedHostname, '')
@@ -35,14 +35,14 @@ export function matchPathname(url, pathname, allowWildcard) {
     if (!pathname) {
         return true;
     }
-    else if (!allowWildcard || !pathname.endsWith('*')) {
+    if (!allowWildcard || !pathname.endsWith('*')) {
         return pathname === url.pathname;
     }
-    else if (pathname.endsWith('/**')) {
+    if (pathname.endsWith('/**')) {
         const slicedPathname = pathname.slice(0, -2); // ** length
         return slicedPathname !== url.pathname && url.pathname.startsWith(slicedPathname);
     }
-    else if (pathname.endsWith('/*')) {
+    if (pathname.endsWith('/*')) {
         const slicedPathname = pathname.slice(0, -1); // * length
         const additionalPathChunks = url.pathname
             .replace(slicedPathname, '')
@@ -84,12 +84,10 @@ export function joinPaths(...paths) {
         if (i === 0) {
             return removeTrailingForwardSlash(path);
         }
-        else if (i === paths.length - 1) {
+        if (i === paths.length - 1) {
             return removeLeadingForwardSlash(path);
         }
-        else {
-            return trimSlashes(path);
-        }
+        return trimSlashes(path);
     })
         .join('/');
 }