@astrojs/cloudflare 0.0.0-cloudcannon-fix-20230306211609

package/dist/index.js

@@ -0,0 +1,156 @@
+import esbuild from "esbuild";
+import * as fs from "fs";
+import * as os from "os";
+import glob from "tiny-glob";
+import { fileURLToPath, pathToFileURL } from "url";
+function getAdapter(isModeDirectory) {
+  return isModeDirectory ? {
+    name: "@astrojs/cloudflare",
+    serverEntrypoint: "@astrojs/cloudflare/server.directory.js",
+    exports: ["onRequest"]
+  } : {
+    name: "@astrojs/cloudflare",
+    serverEntrypoint: "@astrojs/cloudflare/server.advanced.js",
+    exports: ["default"]
+  };
+}
+const SHIM = `globalThis.process = {
+	argv: [],
+	env: {},
+};`;
+const SERVER_BUILD_FOLDER = "/$server_build/";
+function createIntegration(args) {
+  let _config;
+  let _buildConfig;
+  const isModeDirectory = (args == null ? void 0 : args.mode) === "directory";
+  return {
+    name: "@astrojs/cloudflare",
+    hooks: {
+      "astro:config:setup": ({ config, updateConfig }) => {
+        updateConfig({
+          build: {
+            client: new URL(`.${config.base}`, config.outDir),
+            server: new URL(`.${SERVER_BUILD_FOLDER}`, config.outDir),
+            serverEntry: "_worker.mjs"
+          }
+        });
+      },
+      "astro:config:done": ({ setAdapter, config }) => {
+        setAdapter(getAdapter(isModeDirectory));
+        _config = config;
+        _buildConfig = config.build;
+        if (config.output === "static") {
+          throw new Error(`
+  [@astrojs/cloudflare] \`output: "server"\` 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.`);
+        }
+      },
+      "astro:build:setup": ({ vite, target }) => {
+        if (target === "server") {
+          vite.resolve = vite.resolve || {};
+          vite.resolve.alias = vite.resolve.alias || {};
+          const aliases = [{ find: "react-dom/server", replacement: "react-dom/server.browser" }];
+          if (Array.isArray(vite.resolve.alias)) {
+            vite.resolve.alias = [...vite.resolve.alias, ...aliases];
+          } else {
+            for (const alias of aliases) {
+              vite.resolve.alias[alias.find] = alias.replacement;
+            }
+          }
+          vite.ssr = vite.ssr || {};
+          vite.ssr.target = vite.ssr.target || "webworker";
+        }
+      },
+      "astro:build:done": async ({ pages }) => {
+        const entryPath = fileURLToPath(new URL(_buildConfig.serverEntry, _buildConfig.server));
+        const entryUrl = new URL(_buildConfig.serverEntry, _config.outDir);
+        const buildPath = fileURLToPath(entryUrl);
+        const finalBuildUrl = pathToFileURL(buildPath.replace(/\.mjs$/, ".js"));
+        await esbuild.build({
+          target: "es2020",
+          platform: "browser",
+          entryPoints: [entryPath],
+          outfile: buildPath,
+          allowOverwrite: true,
+          format: "esm",
+          bundle: true,
+          minify: true,
+          banner: {
+            js: SHIM
+          }
+        });
+        await fs.promises.rename(buildPath, finalBuildUrl);
+        const serverUrl = new URL(_buildConfig.server);
+        await fs.promises.rm(serverUrl, { recursive: true, force: true });
+        const cloudflareSpecialFiles = ["_headers", "_redirects", "_routes.json"];
+        if (_config.base !== "/") {
+          for (const file of cloudflareSpecialFiles) {
+            try {
+              await fs.promises.rename(
+                new URL(file, _buildConfig.client),
+                new URL(file, _config.outDir)
+              );
+            } catch (e) {
+            }
+          }
+        }
+        const routesExists = await fs.promises.stat(new URL("./_routes.json", _config.outDir)).then((stat) => stat.isFile()).catch(() => false);
+        if (!routesExists) {
+          const staticPathList = (await glob(`${fileURLToPath(_buildConfig.client)}/**/*`, {
+            cwd: fileURLToPath(_config.outDir),
+            filesOnly: true
+          })).filter((file) => cloudflareSpecialFiles.indexOf(file) < 0).map((file) => `/${file}`);
+          for (let page of pages) {
+            staticPathList.push(prependForwardSlash(page.pathname));
+          }
+          const redirectsExists = await fs.promises.stat(new URL("./_redirects", _config.outDir)).then((stat) => stat.isFile()).catch(() => false);
+          if (redirectsExists) {
+            const redirects = (await fs.promises.readFile(new URL("./_redirects", _config.outDir), "utf-8")).split(os.EOL).map((line) => {
+              const parts = line.split(" ");
+              if (parts.length < 2) {
+                return null;
+              } else {
+                return parts[0].replace(/\/:.*?(?=\/|$)/g, "/*").replace(/\?.*$/, "");
+              }
+            }).filter(
+              (line, index, arr) => line !== null && arr.indexOf(line) === index
+            );
+            if (redirects.length > 0) {
+              staticPathList.push(...redirects);
+            }
+          }
+          await fs.promises.writeFile(
+            new URL("./_routes.json", _config.outDir),
+            JSON.stringify(
+              {
+                version: 1,
+                include: ["/*"],
+                exclude: staticPathList
+              },
+              null,
+              2
+            )
+          );
+        }
+        if (isModeDirectory) {
+          const functionsUrl = new URL("functions/", _config.root);
+          await fs.promises.mkdir(functionsUrl, { recursive: true });
+          const directoryUrl = new URL("[[path]].js", functionsUrl);
+          await fs.promises.rename(finalBuildUrl, directoryUrl);
+        }
+      }
+    }
+  };
+}
+function prependForwardSlash(path) {
+  return path[0] === "/" ? path : "/" + path;
+}
+export {
+  createIntegration as default,
+  getAdapter
+};

package/dist/runtime.d.ts

@@ -0,0 +1,16 @@
+export declare type WorkerRuntime<T = unknown> = {
+    name: 'cloudflare';
+    env: T;
+    waitUntil(promise: Promise<any>): void;
+    passThroughOnException(): void;
+};
+export declare type PagesRuntime<T = unknown, U = unknown> = {
+    name: 'cloudflare';
+    env: T;
+    functionPath: string;
+    params: Record<string, string>;
+    data: U;
+    waitUntil(promise: Promise<any>): void;
+    next(request: Request): void;
+};
+export declare function getRuntime<T = unknown, U = unknown>(request: Request): WorkerRuntime<T> | PagesRuntime<T, U>;

package/dist/runtime.js

@@ -0,0 +1,12 @@
+function getRuntime(request) {
+  if (!!request) {
+    return Reflect.get(request, Symbol.for("runtime"));
+  } else {
+    throw new Error(
+      "To retrieve the current cloudflare runtime you need to pass in the Astro request object"
+    );
+  }
+}
+export {
+  getRuntime
+};

package/dist/server.advanced.d.ts

@@ -0,0 +1,13 @@
+import type { SSRManifest } from 'astro';
+declare type Env = {
+    ASSETS: {
+        fetch: (req: Request) => Promise<Response>;
+    };
+    name: string;
+};
+export declare function createExports(manifest: SSRManifest): {
+    default: {
+        fetch: (request: Request, env: Env, context: any) => Promise<Response>;
+    };
+};
+export {};

package/dist/server.advanced.js

@@ -0,0 +1,39 @@
+import { App } from "astro/app";
+import { getProcessEnvProxy, isNode } from "./util.js";
+if (!isNode) {
+  process.env = getProcessEnvProxy();
+}
+function createExports(manifest) {
+  const app = new App(manifest);
+  const fetch = async (request, env, context) => {
+    process.env = env;
+    const { pathname } = new URL(request.url);
+    if (manifest.assets.has(pathname)) {
+      return env.ASSETS.fetch(request);
+    }
+    let routeData = app.match(request, { matchNotFound: true });
+    if (routeData) {
+      Reflect.set(
+        request,
+        Symbol.for("astro.clientAddress"),
+        request.headers.get("cf-connecting-ip")
+      );
+      Reflect.set(request, Symbol.for("runtime"), { env, name: "cloudflare", ...context });
+      let response = await app.render(request, routeData);
+      if (app.setCookieHeaders) {
+        for (const setCookieHeader of app.setCookieHeaders(response)) {
+          response.headers.append("Set-Cookie", setCookieHeader);
+        }
+      }
+      return response;
+    }
+    return new Response(null, {
+      status: 404,
+      statusText: "Not found"
+    });
+  };
+  return { default: { fetch } };
+}
+export {
+  createExports
+};

package/dist/server.directory.d.ts

@@ -0,0 +1,7 @@
+import type { SSRManifest } from 'astro';
+export declare function createExports(manifest: SSRManifest): {
+    onRequest: ({ request, next, ...runtimeEnv }: {
+        request: Request;
+        next: (request: Request) => void;
+    } & Record<string, unknown>) => Promise<void | Response>;
+};

package/dist/server.directory.js

@@ -0,0 +1,47 @@
+import { App } from "astro/app";
+import { getProcessEnvProxy, isNode } from "./util.js";
+if (!isNode) {
+  process.env = getProcessEnvProxy();
+}
+function createExports(manifest) {
+  const app = new App(manifest);
+  const onRequest = async ({
+    request,
+    next,
+    ...runtimeEnv
+  }) => {
+    process.env = runtimeEnv.env;
+    const { pathname } = new URL(request.url);
+    if (manifest.assets.has(pathname)) {
+      return next(request);
+    }
+    let routeData = app.match(request, { matchNotFound: true });
+    if (routeData) {
+      Reflect.set(
+        request,
+        Symbol.for("astro.clientAddress"),
+        request.headers.get("cf-connecting-ip")
+      );
+      Reflect.set(request, Symbol.for("runtime"), {
+        ...runtimeEnv,
+        name: "cloudflare",
+        next
+      });
+      let response = await app.render(request, routeData);
+      if (app.setCookieHeaders) {
+        for (const setCookieHeader of app.setCookieHeaders(response)) {
+          response.headers.append("Set-Cookie", setCookieHeader);
+        }
+      }
+      return response;
+    }
+    return new Response(null, {
+      status: 404,
+      statusText: "Not found"
+    });
+  };
+  return { onRequest };
+}
+export {
+  createExports
+};

package/dist/util.d.ts

@@ -0,0 +1,2 @@
+export declare const isNode: boolean;
+export declare function getProcessEnvProxy(): {};

package/dist/util.js

@@ -0,0 +1,17 @@
+const isNode = typeof process === "object" && Object.prototype.toString.call(process) === "[object process]";
+function getProcessEnvProxy() {
+  return new Proxy(
+    {},
+    {
+      get: (target, prop) => {
+        console.warn(
+          `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.`
+        );
+      }
+    }
+  );
+}
+export {
+  getProcessEnvProxy,
+  isNode
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@astrojs/cloudflare",
+  "description": "Deploy your site to cloudflare workers or cloudflare pages",
+  "version": "0.0.0-cloudcannon-fix-20230306211609",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "author": "withastro",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/withastro/astro.git",
+    "directory": "packages/integrations/cloudflare"
+  },
+  "keywords": [
+    "withastro",
+    "astro-adapter"
+  ],
+  "bugs": "https://github.com/withastro/astro/issues",
+  "homepage": "https://docs.astro.build/en/guides/integrations-guide/cloudflare/",
+  "exports": {
+    ".": "./dist/index.js",
+    "./runtime": {
+      "types": "./runtime.d.ts",
+      "default": "./dist/runtime.js"
+    },
+    "./server.advanced.js": "./dist/server.advanced.js",
+    "./server.directory.js": "./dist/server.directory.js",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "esbuild": "^0.15.18",
+    "tiny-glob": "^0.2.9"
+  },
+  "peerDependencies": {
+    "astro": "0.0.0-cloudcannon-fix-20230306211609"
+  },
+  "devDependencies": {
+    "astro": "0.0.0-cloudcannon-fix-20230306211609",
+    "astro-scripts": "0.0.0-cloudcannon-fix-20230306211609",
+    "chai": "^4.3.6",
+    "cheerio": "^1.0.0-rc.11",
+    "mocha": "^9.2.2",
+    "wrangler": "^2.0.23"
+  },
+  "scripts": {
+    "build": "astro-scripts build \"src/**/*.ts\" && tsc",
+    "build:ci": "astro-scripts build \"src/**/*.ts\"",
+    "dev": "astro-scripts dev \"src/**/*.ts\"",
+    "test": "mocha --exit --timeout 30000 test/"
+  }
+}

package/runtime.d.ts

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

package/src/index.ts

@@ -0,0 +1,219 @@
+import type { AstroAdapter, AstroConfig, AstroIntegration } from 'astro';
+import esbuild from 'esbuild';
+import * as fs from 'fs';
+import * as os from 'os';
+import glob from 'tiny-glob';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+type Options = {
+	mode: 'directory' | 'advanced';
+};
+
+interface BuildConfig {
+	server: URL;
+	client: URL;
+	serverEntry: string;
+}
+
+export function getAdapter(isModeDirectory: boolean): AstroAdapter {
+	return isModeDirectory
+		? {
+				name: '@astrojs/cloudflare',
+				serverEntrypoint: '@astrojs/cloudflare/server.directory.js',
+				exports: ['onRequest'],
+		  }
+		: {
+				name: '@astrojs/cloudflare',
+				serverEntrypoint: '@astrojs/cloudflare/server.advanced.js',
+				exports: ['default'],
+		  };
+}
+
+const SHIM = `globalThis.process = {
+	argv: [],
+	env: {},
+};`;
+
+const SERVER_BUILD_FOLDER = '/$server_build/';
+
+export default function createIntegration(args?: Options): AstroIntegration {
+	let _config: AstroConfig;
+	let _buildConfig: BuildConfig;
+	const isModeDirectory = args?.mode === 'directory';
+
+	return {
+		name: '@astrojs/cloudflare',
+		hooks: {
+			'astro:config:setup': ({ config, updateConfig }) => {
+				updateConfig({
+					build: {
+						client: new URL(`.${config.base}`, config.outDir),
+						server: new URL(`.${SERVER_BUILD_FOLDER}`, config.outDir),
+						serverEntry: '_worker.mjs',
+					},
+				});
+			},
+			'astro:config:done': ({ setAdapter, config }) => {
+				setAdapter(getAdapter(isModeDirectory));
+				_config = config;
+				_buildConfig = config.build;
+
+				if (config.output === 'static') {
+					throw new Error(`
+  [@astrojs/cloudflare] \`output: "server"\` 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.`);
+				}
+			},
+			'astro:build:setup': ({ vite, target }) => {
+				if (target === 'server') {
+					vite.resolve = vite.resolve || {};
+					vite.resolve.alias = vite.resolve.alias || {};
+
+					const aliases = [{ find: 'react-dom/server', replacement: 'react-dom/server.browser' }];
+
+					if (Array.isArray(vite.resolve.alias)) {
+						vite.resolve.alias = [...vite.resolve.alias, ...aliases];
+					} else {
+						for (const alias of aliases) {
+							(vite.resolve.alias as Record<string, string>)[alias.find] = alias.replacement;
+						}
+					}
+					vite.ssr = vite.ssr || {};
+					vite.ssr.target = vite.ssr.target || 'webworker';
+				}
+			},
+			'astro:build:done': async ({ pages }) => {
+				const entryPath = fileURLToPath(new URL(_buildConfig.serverEntry, _buildConfig.server));
+				const entryUrl = new URL(_buildConfig.serverEntry, _config.outDir);
+				const buildPath = fileURLToPath(entryUrl);
+				// A URL for the final build path after renaming
+				const finalBuildUrl = pathToFileURL(buildPath.replace(/\.mjs$/, '.js'));
+
+				await esbuild.build({
+					target: 'es2020',
+					platform: 'browser',
+					entryPoints: [entryPath],
+					outfile: buildPath,
+					allowOverwrite: true,
+					format: 'esm',
+					bundle: true,
+					minify: true,
+					banner: {
+						js: SHIM,
+					},
+				});
+
+				// Rename to worker.js
+				await fs.promises.rename(buildPath, finalBuildUrl);
+
+				// throw the server folder in the bin
+				const serverUrl = new URL(_buildConfig.server);
+				await fs.promises.rm(serverUrl, { recursive: true, force: true });
+
+				// move cloudflare specific files to the root
+				const cloudflareSpecialFiles = ['_headers', '_redirects', '_routes.json'];
+				if (_config.base !== '/') {
+					for (const file of cloudflareSpecialFiles) {
+						try {
+							await fs.promises.rename(
+								new URL(file, _buildConfig.client),
+								new URL(file, _config.outDir)
+							);
+						} catch (e) {
+							// ignore
+						}
+					}
+				}
+
+				const routesExists = await fs.promises
+					.stat(new URL('./_routes.json', _config.outDir))
+					.then((stat) => stat.isFile())
+					.catch(() => false);
+
+				// this creates a _routes.json, in case there is none present to enable
+				// cloudflare to handle static files and support _redirects configuration
+				// (without calling the function)
+				if (!routesExists) {
+					const staticPathList: Array<string> = (
+						await glob(`${fileURLToPath(_buildConfig.client)}/**/*`, {
+							cwd: fileURLToPath(_config.outDir),
+							filesOnly: true,
+						})
+					)
+						.filter((file: string) => cloudflareSpecialFiles.indexOf(file) < 0)
+						.map((file: string) => `/${file}`);
+
+					for (let page of pages) {
+						staticPathList.push(prependForwardSlash(page.pathname));
+					}
+
+					const redirectsExists = await fs.promises
+						.stat(new URL('./_redirects', _config.outDir))
+						.then((stat) => stat.isFile())
+						.catch(() => false);
+
+					// convert all redirect source paths into a list of routes
+					// and add them to the static path
+					if (redirectsExists) {
+						const redirects = (
+							await fs.promises.readFile(new URL('./_redirects', _config.outDir), 'utf-8')
+						)
+							.split(os.EOL)
+							.map((line) => {
+								const parts = line.split(' ');
+								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(/\?.*$/, '')
+									);
+								}
+							})
+							.filter(
+								(line, index, arr) => line !== null && arr.indexOf(line) === index
+							) as string[];
+
+						if (redirects.length > 0) {
+							staticPathList.push(...redirects);
+						}
+					}
+
+					await fs.promises.writeFile(
+						new URL('./_routes.json', _config.outDir),
+						JSON.stringify(
+							{
+								version: 1,
+								include: ['/*'],
+								exclude: staticPathList,
+							},
+							null,
+							2
+						)
+					);
+				}
+
+				if (isModeDirectory) {
+					const functionsUrl = new URL('functions/', _config.root);
+					await fs.promises.mkdir(functionsUrl, { recursive: true });
+
+					const directoryUrl = new URL('[[path]].js', functionsUrl);
+					await fs.promises.rename(finalBuildUrl, directoryUrl);
+				}
+			},
+		},
+	};
+}
+
+function prependForwardSlash(path: string) {
+	return path[0] === '/' ? path : '/' + path;
+}

package/src/runtime.ts

@@ -0,0 +1,28 @@
+export type WorkerRuntime<T = unknown> = {
+	name: 'cloudflare';
+	env: T;
+	waitUntil(promise: Promise<any>): void;
+	passThroughOnException(): void;
+};
+
+export type PagesRuntime<T = unknown, U = unknown> = {
+	name: 'cloudflare';
+	env: T;
+	functionPath: string;
+	params: Record<string, string>;
+	data: U;
+	waitUntil(promise: Promise<any>): void;
+	next(request: Request): void;
+};
+
+export function getRuntime<T = unknown, U = unknown>(
+	request: Request
+): WorkerRuntime<T> | PagesRuntime<T, U> {
+	if (!!request) {
+		return Reflect.get(request, Symbol.for('runtime'));
+	} else {
+		throw new Error(
+			'To retrieve the current cloudflare runtime you need to pass in the Astro request object'
+		);
+	}
+}

package/src/server.advanced.ts

@@ -0,0 +1,53 @@
+import type { SSRManifest } from 'astro';
+import { App } from 'astro/app';
+import { getProcessEnvProxy, isNode } from './util.js';
+
+if (!isNode) {
+	process.env = getProcessEnvProxy();
+}
+
+type Env = {
+	ASSETS: { fetch: (req: Request) => Promise<Response> };
+	name: string;
+};
+
+export function createExports(manifest: SSRManifest) {
+	const app = new App(manifest);
+
+	const fetch = async (request: Request, env: Env, context: any) => {
+		process.env = env as any;
+
+		const { pathname } = new URL(request.url);
+
+		// static assets fallback, in case default _routes.json is not used
+		if (manifest.assets.has(pathname)) {
+			return env.ASSETS.fetch(request);
+		}
+
+		let routeData = app.match(request, { matchNotFound: true });
+		if (routeData) {
+			Reflect.set(
+				request,
+				Symbol.for('astro.clientAddress'),
+				request.headers.get('cf-connecting-ip')
+			);
+			Reflect.set(request, Symbol.for('runtime'), { env, name: 'cloudflare', ...context });
+			let response = await app.render(request, routeData);
+
+			if (app.setCookieHeaders) {
+				for (const setCookieHeader of app.setCookieHeaders(response)) {
+					response.headers.append('Set-Cookie', setCookieHeader);
+				}
+			}
+
+			return response;
+		}
+
+		return new Response(null, {
+			status: 404,
+			statusText: 'Not found',
+		});
+	};
+
+	return { default: { fetch } };
+}