@astrojs/cloudflare 7.4.0 → 7.5.1

package/README.md

@@ -212,7 +212,14 @@ export default defineConfig({
 
 ## Cloudflare runtime
 
-Gives you access to [environment variables](https://developers.cloudflare.com/pages/platform/functions/bindings/#environment-variables).
+Gives you access to [environment variables](https://developers.cloudflare.com/pages/platform/functions/bindings/#environment-variables), and [Cloudflare bindings](https://developers.cloudflare.com/pages/platform/functions/bindings).
+
+Currently supported bindings:
+
+- [Cloudflare D1](https://developers.cloudflare.com/d1/)
+- [Cloudflare R2](https://developers.cloudflare.com/r2/)
+- [Cloudflare Workers KV](https://developers.cloudflare.com/kv/)
+- [Cloudflare Durable Objects](https://developers.cloudflare.com/durable-objects/)
 
 You can access the runtime from Astro components through `Astro.locals` inside any .astro` file.
 

package/dist/index.js

@@ -1,9 +1,7 @@
 import { createRedirectsFromAstroRoutes } from "@astrojs/underscore-redirects";
-import { CacheStorage } from "@miniflare/cache";
-import { NoOpLog } from "@miniflare/shared";
-import { MemoryStorage } from "@miniflare/storage-memory";
 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";
@@ -12,23 +10,20 @@ import glob from "tiny-glob";
 import { getAdapter } from "./getAdapter.js";
 import { deduplicatePatterns } from "./utils/deduplicatePatterns.js";
 import { getCFObject } from "./utils/getCFObject.js";
-import { getEnvVars } from "./utils/parser.js";
+import {
+  getD1Bindings,
+  getDOBindings,
+  getEnvVars,
+  getKVBindings,
+  getR2Bindings
+} from "./utils/parser.js";
 import { prependForwardSlash } from "./utils/prependForwardSlash.js";
 import { rewriteWasmImportPath } from "./utils/rewriteWasmImportPath.js";
 import { wasmModuleLoader } from "./utils/wasm-module-loader.js";
-class StorageFactory {
-  storages = /* @__PURE__ */ new Map();
-  storage(namespace) {
-    let storage = this.storages.get(namespace);
-    if (storage)
-      return storage;
-    this.storages.set(namespace, storage = new MemoryStorage());
-    return storage;
-  }
-}
 function createIntegration(args) {
   let _config;
   let _buildConfig;
+  let _mf;
   let _entryPoints = /* @__PURE__ */ new Map();
   const SERVER_BUILD_FOLDER = "/$server_build/";
   const isModeDirectory = args?.mode === "directory";
@@ -77,6 +72,49 @@ function createIntegration(args) {
             try {
               const cf = await getCFObject(runtimeMode);
               const vars = await getEnvVars();
+              const D1Bindings = await getD1Bindings();
+              const R2Bindings = await getR2Bindings();
+              const KVBindings = await getKVBindings();
+              const DOBindings = await getDOBindings();
+              let bindingsEnv = new Object({});
+              const originalPWD = process.env.PWD;
+              process.env.PWD = process.cwd();
+              _mf = new Miniflare({
+                modules: true,
+                script: "",
+                cache: true,
+                cachePersist: true,
+                cacheWarnUsage: true,
+                d1Databases: D1Bindings,
+                d1Persist: true,
+                r2Buckets: R2Bindings,
+                r2Persist: true,
+                kvNamespaces: KVBindings,
+                kvPersist: true,
+                durableObjects: DOBindings,
+                durableObjectsPersist: true
+              });
+              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: {
@@ -90,18 +128,14 @@ function createIntegration(args) {
                     // 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,
                   waitUntil: (_promise) => {
                     return;
                   },
-                  caches: new CacheStorage(
-                    { cache: true, cachePersist: false },
-                    new NoOpLog(),
-                    new StorageFactory(),
-                    {}
-                  )
+                  caches: mfCache
                 }
               });
               next();
@@ -111,6 +145,12 @@ function createIntegration(args) {
           });
         }
       },
+      "astro:server:done": async ({ logger }) => {
+        if (_mf) {
+          logger.info("Cleaning up the Miniflare instance, and shutting down the workerd server.");
+          await _mf.dispose();
+        }
+      },
       "astro:build:setup": ({ vite, target }) => {
         if (target === "server") {
           vite.resolve ||= {};

package/dist/utils/parser.d.ts

@@ -17,3 +17,11 @@ export interface DotEnv {
  */
 export declare function loadDotEnv(path: string): DotEnv | undefined;
 export declare function getEnvVars(): Promise<any>;
+export declare function getD1Bindings(): Promise<string[]>;
+export declare function getR2Bindings(): Promise<string[]>;
+export declare function getKVBindings(): Promise<string[]>;
+export declare function getDOBindings(): Record<string, {
+    scriptName?: string | undefined;
+    unsafeUniqueKey?: string | undefined;
+    className: string;
+}>;

package/dist/utils/parser.js

@@ -3,6 +3,7 @@ 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 });
@@ -69,7 +70,9 @@ function getVarsForDev(config, configPath) {
     return config.vars;
   }
 }
-async function getEnvVars() {
+function parseConfig() {
+  if (_wrangler)
+    return _wrangler;
   let rawConfig;
   const configPath = findWranglerToml(process.cwd(), false);
   if (!configPath) {
@@ -78,10 +81,64 @@ async function getEnvVars() {
   if (configPath?.endsWith("toml")) {
     rawConfig = parseTOML(fs.readFileSync(configPath).toString(), configPath);
   }
+  _wrangler = { rawConfig, configPath };
+  return { rawConfig, configPath };
+}
+async function getEnvVars() {
+  const { rawConfig, configPath } = parseConfig();
   const vars = getVarsForDev(rawConfig, configPath);
   return vars;
 }
+async function getD1Bindings() {
+  const { rawConfig } = parseConfig();
+  if (!rawConfig)
+    return [];
+  if (!rawConfig?.d1_databases)
+    return [];
+  const bindings = (rawConfig?.d1_databases).map(
+    (binding) => binding.binding
+  );
+  return bindings;
+}
+async function getR2Bindings() {
+  const { rawConfig } = parseConfig();
+  if (!rawConfig)
+    return [];
+  if (!rawConfig?.r2_buckets)
+    return [];
+  const bindings = (rawConfig?.r2_buckets).map(
+    (binding) => binding.binding
+  );
+  return bindings;
+}
+async function getKVBindings() {
+  const { rawConfig } = parseConfig();
+  if (!rawConfig)
+    return [];
+  if (!rawConfig?.kv_namespaces)
+    return [];
+  const bindings = (rawConfig?.kv_namespaces).map(
+    (binding) => binding.binding
+  );
+  return bindings;
+}
+function getDOBindings() {
+  const { rawConfig } = parseConfig();
+  if (!rawConfig)
+    return {};
+  if (!rawConfig?.durable_objects)
+    return {};
+  const output = new Object({});
+  for (const binding of rawConfig?.durable_objects.bindings) {
+    Reflect.set(output, binding.name, { className: binding.class_name });
+  }
+  return output;
+}
 export {
+  getD1Bindings,
+  getDOBindings,
   getEnvVars,
+  getKVBindings,
+  getR2Bindings,
   loadDotEnv
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "7.4.0",
+  "version": "7.5.1",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -28,6 +28,7 @@
   ],
   "dependencies": {
     "@cloudflare/workers-types": "^4.20230821.0",
+    "miniflare": "^3.20230918.0",
     "@iarna/toml": "^2.2.5",
     "@miniflare/cache": "^2.14.1",
     "@miniflare/shared": "^2.14.1",
@@ -37,10 +38,10 @@
     "find-up": "^6.3.0",
     "tiny-glob": "^0.2.9",
     "vite": "^4.4.9",
-    "@astrojs/underscore-redirects": "0.3.0"
+    "@astrojs/underscore-redirects": "0.3.1"
   },
   "peerDependencies": {
-    "astro": "^3.2.1"
+    "astro": "^3.2.3"
   },
   "devDependencies": {
     "@types/iarna__toml": "^2.0.2",
@@ -48,9 +49,12 @@
     "cheerio": "1.0.0-rc.12",
     "mocha": "^10.2.0",
     "wrangler": "^3.5.1",
-    "astro": "3.2.1",
+    "astro": "3.2.3",
     "astro-scripts": "0.0.14"
   },
+  "publishConfig": {
+    "provenance": true
+  },
   "scripts": {
     "build": "astro-scripts build \"src/**/*.ts\" && tsc",
     "build:ci": "astro-scripts build \"src/**/*.ts\"",