@astrojs/cloudflare 7.0.2 → 7.1.1

package/README.md

@@ -115,8 +115,12 @@ If you're using the `advanced` runtime, you can type the `runtime` object as fol
 /// <reference types="astro/client" />
 import type { AdvancedRuntime } from '@astrojs/cloudflare';
 
+type ENV = {
+  SERVER_URL: string;
+};
+
 declare namespace App {
-  interface Locals extends AdvancedRuntime {
+  interface Locals extends AdvancedRuntime<ENV> {
     user: {
       name: string;
       surname: string;
@@ -132,8 +136,12 @@ If you're using the `directory` runtime, you can type the `runtime` object as fo
 /// <reference types="astro/client" />
 import type { DirectoryRuntime } from '@astrojs/cloudflare';
 
+type ENV = {
+  SERVER_URL: string;
+};
+
 declare namespace App {
-  interface Locals extends DirectoryRuntime {
+  interface Locals extends DirectoryRuntime<ENV> {
     user: {
       name: string;
       surname: string;
@@ -142,7 +150,7 @@ declare namespace App {
 }
 ```
 
-## Environment Variables
+### Environment Variables
 
 See Cloudflare's documentation for [working with environment variables](https://developers.cloudflare.com/pages/platform/functions/bindings/#environment-variables).
 
@@ -159,6 +167,30 @@ export function GET({ params }) {
 }
 ```
 
+### `cloudflare.runtime`
+
+`runtime: "off" | "local" | "remote"`
+default `"off"`
+
+This optional flag enables the Astro dev server to populate environment variables and the Cloudflare Request Object, avoiding the need for Wrangler.
+
+- `local`: environment variables are available, but the request object is populated from a static placeholder value.
+- `remote`: environment variables and the live, fetched request object are available.
+- `off`: the Astro dev server will populate neither environment variables nor the request object. Use Wrangler to access Cloudflare bindings and environment variables.
+
+```js
+// astro.config.mjs
+import { defineConfig } from 'astro/config';
+import cloudflare from '@astrojs/cloudflare';
+
+export default defineConfig({
+  output: 'server',
+  adapter: cloudflare({
+    runtime: 'off' | 'local' | 'remote',
+  }),
+});
+```
+
 ## Headers, Redirects and function invocation routes
 
 Cloudflare has support for adding custom [headers](https://developers.cloudflare.com/pages/platform/headers/), configuring static [redirects](https://developers.cloudflare.com/pages/platform/redirects/) and defining which routes should [invoke functions](https://developers.cloudflare.com/pages/platform/functions/routing/#function-invocation-routes). Cloudflare looks for `_headers`, `_redirects`, and `_routes.json` files in your build output directory to configure these features. This means they should be placed in your Astro project’s `public/` directory.

package/dist/index.d.ts

@@ -1,9 +1,15 @@
 import type { AstroAdapter, AstroIntegration } from 'astro';
-export type { AdvancedRuntime } from './server.advanced';
-export type { DirectoryRuntime } from './server.directory';
+export type { AdvancedRuntime } from './server.advanced.js';
+export type { DirectoryRuntime } from './server.directory.js';
 type Options = {
-    mode: 'directory' | 'advanced';
+    mode?: 'directory' | 'advanced';
     functionPerRoute?: boolean;
+    /**
+     * 'off': current behaviour (wrangler is needed)
+     * 'local': use a static req.cf object, and env vars defined in wrangler.toml & .dev.vars (astro dev is enough)
+     * 'remote': use a dynamic real-live req.cf object, and env vars defined in wrangler.toml & .dev.vars (astro dev is enough)
+     */
+    runtime?: 'off' | 'local' | 'remote';
 };
 export declare function getAdapter({ isModeDirectory, functionPerRoute, }: {
     isModeDirectory: boolean;

package/dist/index.js

@@ -1,10 +1,25 @@
 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 * as fs from "node:fs";
 import * as os from "node:os";
 import { sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import glob from "tiny-glob";
+import { getEnvVars } from "./parser.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 getAdapter({
   isModeDirectory,
   functionPerRoute
@@ -43,6 +58,71 @@ function getAdapter({
     }
   };
 }
+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: void 0,
+    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;
+    }
+  }
+}
 const SHIM = `globalThis.process = {
 	argv: [],
 	env: {},
@@ -55,6 +135,7 @@ function createIntegration(args) {
   let _entryPoints = /* @__PURE__ */ new Map();
   const isModeDirectory = args?.mode === "directory";
   const functionPerRoute = args?.functionPerRoute ?? false;
+  const runtimeMode = args?.runtime ?? "off";
   return {
     name: "@astrojs/cloudflare",
     hooks: {
@@ -73,14 +154,54 @@ function createIntegration(args) {
         _config = config;
         _buildConfig = config.build;
         if (config.output === "static") {
-          throw new Error(`
-  [@astrojs/cloudflare] \`output: "server"\` or \`output: "hybrid"\` is required to use this adapter. Otherwise, this adapter is not necessary to deploy a static site to Cloudflare.
-
-`);
+          throw new AstroError(
+            '[@astrojs/cloudflare] `output: "server"` or `output: "hybrid"` is required to use this adapter. Otherwise, this adapter is not necessary to deploy a static site to Cloudflare.'
+          );
         }
         if (config.base === SERVER_BUILD_FOLDER) {
-          throw new Error(`
-  [@astrojs/cloudflare] \`base: "${SERVER_BUILD_FOLDER}"\` is not allowed. Please change your \`base\` config to something else.`);
+          throw new AstroError(
+            '[@astrojs/cloudflare] `base: "${SERVER_BUILD_FOLDER}"` is not allowed. Please change your `base` config to something else.'
+          );
+        }
+      },
+      "astro:server:setup": ({ server }) => {
+        if (runtimeMode !== "off") {
+          server.middlewares.use(async function middleware(req, res, next) {
+            try {
+              const cf = await getCFObject(runtimeMode);
+              const vars = await getEnvVars();
+              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}`,
+                    ...vars
+                  },
+                  cf,
+                  waitUntil: (_promise) => {
+                    return;
+                  },
+                  caches: new CacheStorage(
+                    { cache: true, cachePersist: false },
+                    new NoOpLog(),
+                    new StorageFactory(),
+                    {}
+                  )
+                }
+              });
+              next();
+            } catch {
+              next();
+            }
+          });
         }
       },
       "astro:build:setup": ({ vite, target }) => {

package/dist/parser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This file is a derivative work of wrangler by Cloudflare
+ * An upstream request for exposing this API was made here:
+ * https://github.com/cloudflare/workers-sdk/issues/3897
+ *
+ * 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 dotenv from 'dotenv';
+export interface DotEnv {
+    path: string;
+    parsed: dotenv.DotenvParseOutput;
+}
+/**
+ * Loads a dotenv file from <path>, preferring to read <path>.<environment> if
+ * <environment> is defined and that file exists.
+ */
+export declare function loadDotEnv(path: string): DotEnv | undefined;
+export declare function getEnvVars(): Promise<any>;

package/dist/parser.js

@@ -0,0 +1,87 @@
+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";
+function findWranglerToml(referencePath = process.cwd(), preferJson = false) {
+  if (preferJson) {
+    return findUpSync(`wrangler.json`, { cwd: referencePath }) ?? findUpSync(`wrangler.toml`, { cwd: referencePath });
+  }
+  return findUpSync(`wrangler.toml`, { cwd: referencePath });
+}
+class ParseError extends Error {
+  text;
+  notes;
+  location;
+  kind;
+  constructor({ text, notes, location, kind }) {
+    super(text);
+    this.name = this.constructor.name;
+    this.text = text;
+    this.notes = notes ?? [];
+    this.location = location;
+    this.kind = kind ?? "error";
+  }
+}
+const TOML_ERROR_NAME = "TomlError";
+const TOML_ERROR_SUFFIX = " at row ";
+function parseTOML(input, file) {
+  try {
+    const normalizedInput = input.replace(/\r\n/g, "\n");
+    return TOML.parse(normalizedInput);
+  } catch (err) {
+    const { name, message, line, col } = err;
+    if (name !== TOML_ERROR_NAME) {
+      throw err;
+    }
+    const text = message.substring(0, message.lastIndexOf(TOML_ERROR_SUFFIX));
+    const lineText = input.split("\n")[line];
+    const location = {
+      lineText,
+      line: line + 1,
+      column: col - 1,
+      file,
+      fileText: input
+    };
+    throw new ParseError({ text, location });
+  }
+}
+function tryLoadDotEnv(path) {
+  try {
+    const parsed = dotenv.parse(fs.readFileSync(path));
+    return { path, parsed };
+  } catch (e) {
+  }
+}
+function loadDotEnv(path) {
+  return tryLoadDotEnv(path);
+}
+function getVarsForDev(config, configPath) {
+  const configDir = resolve(dirname(configPath ?? "."));
+  const devVarsPath = resolve(configDir, ".dev.vars");
+  const loaded = loadDotEnv(devVarsPath);
+  if (loaded !== void 0) {
+    return {
+      ...config.vars,
+      ...loaded.parsed
+    };
+  } else {
+    return config.vars;
+  }
+}
+async function getEnvVars() {
+  let rawConfig;
+  const configPath = findWranglerToml(process.cwd(), false);
+  if (!configPath) {
+    throw new Error("Could not find wrangler.toml");
+  }
+  if (configPath?.endsWith("toml")) {
+    rawConfig = parseTOML(fs.readFileSync(configPath).toString(), configPath);
+  }
+  const vars = getVarsForDev(rawConfig, configPath);
+  return vars;
+}
+export {
+  getEnvVars,
+  loadDotEnv
+};

package/dist/server.advanced.d.ts

@@ -4,12 +4,11 @@ type Env = {
     ASSETS: {
         fetch: (req: Request) => Promise<Response>;
     };
-    name: string;
 };
-export interface AdvancedRuntime {
+export interface AdvancedRuntime<T extends object = object> {
     runtime: {
         waitUntil: (promise: Promise<any>) => void;
-        env: Env;
+        env: Env & T;
         cf: CFRequest['cf'];
         caches: typeof caches;
     };

package/dist/server.advanced.js

@@ -18,16 +18,6 @@ function createExports(manifest) {
         Symbol.for("astro.clientAddress"),
         request.headers.get("cf-connecting-ip")
       );
-      Reflect.set(request, Symbol.for("runtime"), {
-        env,
-        name: "cloudflare",
-        caches,
-        cf: request.cf,
-        ...context,
-        waitUntil: (promise) => {
-          context.waitUntil(promise);
-        }
-      });
       const locals = {
         runtime: {
           waitUntil: (promise) => {

package/dist/server.directory.d.ts

@@ -1,9 +1,9 @@
 import type { Request as CFRequest, EventContext } from '@cloudflare/workers-types';
 import type { SSRManifest } from 'astro';
-export interface DirectoryRuntime {
+export interface DirectoryRuntime<T extends object = object> {
     runtime: {
         waitUntil: (promise: Promise<any>) => void;
-        env: EventContext<unknown, string, unknown>['env'];
+        env: EventContext<unknown, string, unknown>['env'] & T;
         cf: CFRequest['cf'];
         caches: typeof caches;
     };

package/dist/server.directory.js

@@ -7,7 +7,7 @@ function createExports(manifest) {
   const app = new App(manifest);
   const onRequest = async (context) => {
     const request = context.request;
-    const { next, env } = context;
+    const { env } = context;
     process.env = env;
     const { pathname } = new URL(request.url);
     if (manifest.assets.has(pathname)) {
@@ -20,16 +20,6 @@ function createExports(manifest) {
         Symbol.for("astro.clientAddress"),
         request.headers.get("cf-connecting-ip")
       );
-      Reflect.set(request, Symbol.for("runtime"), {
-        ...context,
-        waitUntil: (promise) => {
-          context.waitUntil(promise);
-        },
-        name: "cloudflare",
-        next,
-        caches,
-        cf: request.cf
-      });
       const locals = {
         runtime: {
           waitUntil: (promise) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "7.0.2",
+  "version": "7.1.1",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -33,20 +33,27 @@
   ],
   "dependencies": {
     "@cloudflare/workers-types": "^4.20230821.0",
+    "@iarna/toml": "^2.2.5",
+    "@miniflare/cache": "^2.14.1",
+    "@miniflare/shared": "^2.14.1",
+    "@miniflare/storage-memory": "^2.14.1",
+    "dotenv": "^16.3.1",
     "esbuild": "^0.19.2",
+    "find-up": "^6.3.0",
     "tiny-glob": "^0.2.9",
     "@astrojs/underscore-redirects": "0.3.0"
   },
   "peerDependencies": {
-    "astro": "^3.0.9"
+    "astro": "^3.1.1"
   },
   "devDependencies": {
+    "@types/iarna__toml": "^2.0.2",
     "chai": "^4.3.7",
     "cheerio": "1.0.0-rc.12",
     "kill-port": "^2.0.1",
     "mocha": "^10.2.0",
     "wrangler": "^3.5.1",
-    "astro": "3.0.9",
+    "astro": "3.1.1",
     "astro-scripts": "0.0.14"
   },
   "scripts": {

package/runtime.d.ts

@@ -1,3 +0,0 @@
-export type { WorkerRuntime, PagesRuntime } from './dist/runtime';
-
-export { getRuntime } from './dist/runtime';