@astrojs/cloudflare 7.7.1 → 8.0.1

package/dist/utils/local-runtime.js

@@ -0,0 +1,222 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import assert from 'node:assert';
+import { fileURLToPath } from 'url';
+import TOML from '@iarna/toml';
+import { AstroError } from 'astro/errors';
+import dotenv from 'dotenv';
+import { Miniflare } from 'miniflare';
+class LocalRuntime {
+    _astroConfig;
+    _logger;
+    _miniflare;
+    miniflareBindings;
+    secrets;
+    cfObject;
+    constructor(astroConfig, runtimeConfig, logger) {
+        this._astroConfig = astroConfig;
+        this._logger = logger;
+        const varBindings = {};
+        const kvBindings = [];
+        const d1Bindings = [];
+        const r2Bindings = [];
+        const durableObjectBindings = {};
+        for (const bindingName in runtimeConfig.bindings) {
+            const bindingData = runtimeConfig.bindings[bindingName];
+            switch (bindingData.type) {
+                case 'var':
+                    varBindings[bindingName] = bindingData.value;
+                    break;
+                case 'kv':
+                    kvBindings.push(bindingName);
+                    break;
+                case 'd1':
+                    d1Bindings.push(bindingName);
+                    break;
+                case 'r2':
+                    r2Bindings.push(bindingName);
+                    break;
+                case 'durable-object':
+                    durableObjectBindings[bindingName] = {
+                        className: bindingData.className,
+                        scriptName: bindingData.service?.name,
+                    };
+                    break;
+            }
+        }
+        this._miniflare = new Miniflare({
+            cachePersist: `${runtimeConfig.persistTo}/cache`,
+            d1Persist: `${runtimeConfig.persistTo}/d1`,
+            r2Persist: `${runtimeConfig.persistTo}/r2`,
+            kvPersist: `${runtimeConfig.persistTo}/kv`,
+            durableObjectsPersist: `${runtimeConfig.persistTo}/do`,
+            workers: [
+                {
+                    name: 'worker',
+                    script: '',
+                    modules: true,
+                    cacheWarnUsage: true,
+                    cache: true,
+                    bindings: varBindings,
+                    d1Databases: d1Bindings,
+                    r2Buckets: r2Bindings,
+                    kvNamespaces: kvBindings,
+                    durableObjects: durableObjectBindings,
+                },
+            ],
+        });
+    }
+    async getBindings() {
+        await this._miniflare.ready;
+        if (!this.miniflareBindings) {
+            this.miniflareBindings = await this._miniflare.getBindings();
+        }
+        return this.miniflareBindings;
+    }
+    async getSecrets() {
+        await this._miniflare.ready;
+        if (!this.secrets) {
+            try {
+                this.secrets = dotenv.parse(readFileSync(fileURLToPath(new URL('./.dev.vars', this._astroConfig.root))));
+            }
+            catch (error) {
+                const e = error;
+                if (e.code === 'ENOENT') {
+                    this._logger.info('There is no `.dev.vars` file in the root directory, if you have encrypted secrets or environmental variables you Cloudflare recommends to put them in this file');
+                    this.secrets = {};
+                }
+                else {
+                    throw new AstroError('Failed to load secrets file', e.message);
+                }
+            }
+        }
+        return this.secrets;
+    }
+    async getCaches() {
+        await this._miniflare.ready;
+        return this._miniflare.getCaches();
+    }
+    async getCF() {
+        await this._miniflare.ready;
+        const MAX_CACHE_AGE = 1000 * 60 * 60 * 24 * 7; // 7 days;
+        // Try load cached cfObject, if this fails, we'll catch the error and refetch.
+        // If this succeeds, and the file is stale, that's fine: it's very likely
+        // we'll be fetching the same data anyways.
+        try {
+            const cachedCFObject = JSON.parse(readFileSync(fileURLToPath(new URL('cf.json', this._astroConfig.cacheDir)), 'utf8'));
+            const cfObjectStats = statSync(fileURLToPath(new URL('cf.json', this._astroConfig.cacheDir)));
+            assert(Date.now() - cfObjectStats.mtimeMs <= MAX_CACHE_AGE);
+            this.cfObject = cachedCFObject;
+        }
+        catch { }
+        const CF_ENDPOINT = 'https://workers.cloudflare.com/cf.json';
+        if (!this.cfObject) {
+            this.cfObject = await fetch(CF_ENDPOINT).then((res) => res.json());
+            mkdirSync(this._astroConfig.cacheDir);
+            writeFileSync(fileURLToPath(new URL('cf.json', this._astroConfig.cacheDir)), JSON.stringify(this.cfObject), 'utf8');
+        }
+        return this.cfObject;
+    }
+    async dispose() {
+        await this._miniflare.dispose();
+    }
+}
+export class LocalWorkersRuntime extends LocalRuntime {
+    constructor(astroConfig, runtimeConfig, logger) {
+        let _wranglerConfig;
+        try {
+            _wranglerConfig = TOML.parse(readFileSync(fileURLToPath(new URL('./wrangler.toml', astroConfig.root)), 'utf-8').replace(/\r\n/g, '\n'));
+        }
+        catch (error) {
+            const e = error;
+            if (e.code === 'ENOENT') {
+                logger.error('Missing file `wrangler.toml in root directory`');
+            }
+            else {
+                throw new AstroError('Failed to load wrangler config', e.message);
+            }
+        }
+        const runtimeConfigWithWrangler = {
+            ...runtimeConfig,
+            bindings: {},
+        };
+        if (_wranglerConfig?.vars) {
+            for (const key in _wranglerConfig.vars) {
+                runtimeConfigWithWrangler.bindings[key] = {
+                    type: 'var',
+                    value: _wranglerConfig.vars[key],
+                };
+            }
+        }
+        if (_wranglerConfig?.kv_namespaces) {
+            for (const ns of _wranglerConfig.kv_namespaces) {
+                runtimeConfigWithWrangler.bindings[ns.binding] = {
+                    type: 'kv',
+                };
+            }
+        }
+        if (_wranglerConfig?.d1_databases) {
+            for (const db of _wranglerConfig.d1_databases) {
+                runtimeConfigWithWrangler.bindings[db.binding] = {
+                    type: 'd1',
+                };
+            }
+        }
+        if (_wranglerConfig?.r2_buckets) {
+            for (const bucket of _wranglerConfig.r2_buckets) {
+                runtimeConfigWithWrangler.bindings[bucket.binding] = {
+                    type: 'r2',
+                };
+            }
+        }
+        if (_wranglerConfig?.durable_objects) {
+            for (const durableObject of _wranglerConfig.durable_objects.bindings) {
+                runtimeConfigWithWrangler.bindings[durableObject.name] = {
+                    type: 'durable-object',
+                    className: durableObject.class_name,
+                    service: durableObject.script_name
+                        ? {
+                            name: durableObject.script_name,
+                        }
+                        : undefined,
+                };
+            }
+        }
+        super(astroConfig, runtimeConfigWithWrangler, logger);
+    }
+}
+export class LocalPagesRuntime extends LocalRuntime {
+    // biome-ignore lint/complexity/noUselessConstructor: not types information yet, so we need to disable the rule for the time being
+    constructor(astroConfig, runtimeConfig, logger) {
+        super(astroConfig, runtimeConfig, logger);
+    }
+}
+let localRuntime;
+export function getLocalRuntime(astroConfig, runtimeConfig, logger) {
+    if (localRuntime)
+        return localRuntime;
+    if (runtimeConfig.type === 'pages') {
+        localRuntime = new LocalPagesRuntime(astroConfig, runtimeConfig, logger);
+    }
+    else {
+        localRuntime = new LocalWorkersRuntime(astroConfig, runtimeConfig, logger);
+    }
+    return localRuntime;
+}
+export function getRuntimeConfig(userConfig) {
+    if (!userConfig || userConfig.mode === 'off')
+        return { mode: 'off' };
+    // we know that we have `mode: local` below
+    if (userConfig.type === 'pages')
+        return {
+            mode: 'local',
+            type: 'pages',
+            persistTo: userConfig.persistTo ?? '.wrangler/state/v3',
+            bindings: userConfig.bindings ?? {},
+        };
+    // we know that we have `type: workers` below
+    return {
+        mode: 'local',
+        type: 'workers',
+        persistTo: userConfig.persistTo ?? '.wrangler/state/v3',
+    };
+}

package/dist/utils/parser.js

@@ -6,18 +6,18 @@
  * Until further notice, we will be using this file as a workaround
  * TODO: Tackle this file, once their is an decision on the upstream request
  */
+import * as fs from 'node:fs';
+import { dirname, resolve } from 'node:path';
 import TOML from '@iarna/toml';
 import dotenv from 'dotenv';
 import { findUpSync } from 'find-up';
-import * as fs from 'node:fs';
-import { dirname, resolve } from 'node:path';
 let _wrangler;
 function findWranglerToml(referencePath = process.cwd(), preferJson = false) {
     if (preferJson) {
-        return (findUpSync(`wrangler.json`, { cwd: referencePath }) ??
-            findUpSync(`wrangler.toml`, { cwd: referencePath }));
+        return (findUpSync('wrangler.json', { cwd: referencePath }) ??
+            findUpSync('wrangler.toml', { cwd: referencePath }));
     }
-    return findUpSync(`wrangler.toml`, { cwd: referencePath });
+    return findUpSync('wrangler.toml', { cwd: referencePath });
 }
 class ParseError extends Error {
     text;
@@ -84,9 +84,7 @@ function getVarsForDev(config, configPath) {
             ...loaded.parsed,
         };
     }
-    else {
-        return config.vars;
-    }
+    return config.vars;
 }
 function parseConfig() {
     if (_wrangler)
@@ -139,10 +137,11 @@ export function getDOBindings() {
     const { rawConfig } = parseConfig();
     if (!rawConfig)
         return {};
-    if (!rawConfig?.durable_objects)
+    if (!rawConfig.durable_objects)
         return {};
     const output = new Object({});
-    for (const binding of rawConfig?.durable_objects.bindings) {
+    const bindings = rawConfig.durable_objects.bindings;
+    for (const binding of bindings) {
         Reflect.set(output, binding.name, { className: binding.class_name });
     }
     return output;

package/dist/utils/prependForwardSlash.js

@@ -1,3 +1,3 @@
 export function prependForwardSlash(path) {
-    return path[0] === '/' ? path : '/' + path;
+    return path[0] === '/' ? path : `/${path}`;
 }

package/dist/utils/rewriteWasmImportPath.js

@@ -1,5 +1,5 @@
-import esbuild from 'esbuild';
 import { basename } from 'node:path';
+import esbuild from 'esbuild';
 /**
  *
  * @param relativePathToAssets - relative path from the final location for the current esbuild output bundle, to the assets directory.

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

@@ -1,4 +1,4 @@
-import { type Plugin } from 'vite';
+import type { AstroConfig } from 'astro';
 /**
  * Loads '*.wasm?module' imports as WebAssembly modules, which is the only way to load WASM in cloudflare workers.
  * Current proposal for WASM modules: https://github.com/WebAssembly/esm-integration/tree/main/proposals/esm-integration
@@ -11,4 +11,4 @@ import { type Plugin } from 'vite';
 export declare function wasmModuleLoader({ disabled, assetsDirectory, }: {
     disabled: boolean;
     assetsDirectory: string;
-}): Plugin;
+}): NonNullable<AstroConfig['vite']['plugins']>[number];

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

@@ -1,6 +1,5 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import {} from 'vite';
 /**
  * Loads '*.wasm?module' imports as WebAssembly modules, which is the only way to load WASM in cloudflare workers.
  * Current proposal for WASM modules: https://github.com/WebAssembly/esm-integration/tree/main/proposals/esm-integration
@@ -44,31 +43,29 @@ export default wasmModule
                 // no need to wire up the assets in dev mode, just rewrite
                 return base64Module;
             }
-            else {
-                // just some shared ID
-                let hash = hashString(base64);
-                // emit the wasm binary as an asset file, to be picked up later by the esbuild bundle for the worker.
-                // give it a shared deterministic name to make things easy for esbuild to switch on later
-                const assetName = path.basename(filePath).split('.')[0] + '.' + hash + '.wasm';
-                this.emitFile({
-                    type: 'asset',
-                    // 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),
-                });
-                // however, by default, the SSG generator cannot import the .wasm as a module, so embed as a base64 string
-                const chunkId = this.emitFile({
-                    type: 'prebuilt-chunk',
-                    fileName: assetName + '.mjs',
-                    code: base64Module,
-                });
-                return `
+            // just some shared ID
+            const hash = hashString(base64);
+            // emit the wasm binary as an asset file, to be picked up later by the esbuild bundle for the worker.
+            // give it a shared deterministic name to make things easy for esbuild to switch on later
+            const assetName = `${path.basename(filePath).split('.')[0]}.${hash}.wasm`;
+            this.emitFile({
+                type: 'asset',
+                // 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),
+            });
+            // however, by default, the SSG generator cannot import the .wasm as a module, so embed as a base64 string
+            const chunkId = this.emitFile({
+                type: 'prebuilt-chunk',
+                fileName: `${assetName}.mjs`,
+                code: base64Module,
+            });
+            return `
 import wasmModule from "__WASM_ASSET__${chunkId}.wasm.mjs";
 export default wasmModule;
 	`;
-            }
         },
         // output original wasm file relative to the chunk
         renderChunk(code, chunk, _) {
@@ -76,7 +73,7 @@ export default wasmModule;
                 return;
             if (!/__WASM_ASSET__/g.test(code))
                 return;
-            const final = code.replaceAll(/__WASM_ASSET__([a-z\d]+).wasm.mjs/g, (s, assetId) => {
+            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)

package/package.json

@@ -2,7 +2,7 @@
   "//comment": "test changeset-bot",
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "7.7.1",
+  "version": "8.0.1",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -36,18 +36,17 @@
     "dotenv": "^16.3.1",
     "esbuild": "^0.19.5",
     "find-up": "^6.3.0",
-    "tiny-glob": "^0.2.9",
-    "vite": "^4.5.0"
+    "tiny-glob": "^0.2.9"
   },
   "peerDependencies": {
-    "astro": "^3.4.3"
+    "astro": "^3.0.0 || ^4.0.0"
   },
   "devDependencies": {
     "execa": "^8.0.1",
     "fast-glob": "^3.3.1",
     "@types/iarna__toml": "^2.0.2",
     "strip-ansi": "^7.1.0",
-    "astro": "^3.4.3",
+    "astro": "^4.0.0",
     "chai": "^4.3.10",
     "cheerio": "1.0.0-rc.12",
     "mocha": "^10.2.0",

package/dist/utils/getCFObject.d.ts

@@ -1,2 +0,0 @@
-import type { IncomingRequestCfProperties } from '@cloudflare/workers-types/experimental';
-export declare function getCFObject(runtimeMode: string): Promise<IncomingRequestCfProperties | void>;

package/dist/utils/getCFObject.js

@@ -1,67 +0,0 @@
-export async function getCFObject(runtimeMode) {
-    const CF_ENDPOINT = 'https://workers.cloudflare.com/cf.json';
-    const CF_FALLBACK = {
-        asOrganization: '',
-        asn: 395747,
-        colo: 'DFW',
-        city: 'Austin',
-        region: 'Texas',
-        regionCode: 'TX',
-        metroCode: '635',
-        postalCode: '78701',
-        country: 'US',
-        continent: 'NA',
-        timezone: 'America/Chicago',
-        latitude: '30.27130',
-        longitude: '-97.74260',
-        clientTcpRtt: 0,
-        httpProtocol: 'HTTP/1.1',
-        requestPriority: 'weight=192;exclusive=0',
-        tlsCipher: 'AEAD-AES128-GCM-SHA256',
-        tlsVersion: 'TLSv1.3',
-        tlsClientAuth: {
-            certPresented: '0',
-            certVerified: 'NONE',
-            certRevoked: '0',
-            certIssuerDN: '',
-            certSubjectDN: '',
-            certIssuerDNRFC2253: '',
-            certSubjectDNRFC2253: '',
-            certIssuerDNLegacy: '',
-            certSubjectDNLegacy: '',
-            certSerial: '',
-            certIssuerSerial: '',
-            certSKI: '',
-            certIssuerSKI: '',
-            certFingerprintSHA1: '',
-            certFingerprintSHA256: '',
-            certNotBefore: '',
-            certNotAfter: '',
-        },
-        edgeRequestKeepAliveStatus: 0,
-        hostMetadata: undefined,
-        clientTrustScore: 99,
-        botManagement: {
-            corporateProxy: false,
-            verifiedBot: false,
-            ja3Hash: '25b4882c2bcb50cd6b469ff28c596742',
-            staticResource: false,
-            detectionIds: [],
-            score: 99,
-        },
-    };
-    if (runtimeMode === 'local') {
-        return CF_FALLBACK;
-    }
-    else if (runtimeMode === 'remote') {
-        try {
-            const res = await fetch(CF_ENDPOINT);
-            const cfText = await res.text();
-            const storedCf = JSON.parse(cfText);
-            return storedCf;
-        }
-        catch (e) {
-            return CF_FALLBACK;
-        }
-    }
-}