@astrojs/cloudflare 7.7.1 → 8.0.0

package/dist/utils/local-runtime.js

@@ -0,0 +1,221 @@
+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;
+        let varBindings = {};
+        let kvBindings = [];
+        let d1Bindings = [];
+        let r2Bindings = [];
+        let 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 {
+    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,11 +6,11 @@
  * 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) {

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
@@ -76,7 +75,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.0",
   "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;
-        }
-    }
-}