zastro-websockets-cloudflare 0.0.0-729d313

package/dist/entrypoints/image-endpoint.d.ts

@@ -0,0 +1,3 @@
+import type { APIRoute } from 'astro';
+export declare const prerender = false;
+export declare const GET: APIRoute;

package/dist/entrypoints/image-endpoint.js

@@ -0,0 +1,15 @@
+const prerender = false;
+const GET = (ctx) => {
+  const href = ctx.url.searchParams.get("href");
+  if (!href) {
+    return new Response("Missing 'href' query parameter", {
+      status: 400,
+      statusText: "Missing 'href' query parameter"
+    });
+  }
+  return fetch(new URL(href, ctx.url.origin));
+};
+export {
+  GET,
+  prerender
+};

package/dist/entrypoints/image-service.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalImageService } from 'astro';
+declare const service: ExternalImageService;
+export default service;

package/dist/entrypoints/image-service.js

@@ -0,0 +1,35 @@
+import { joinPaths } from "@astrojs/internal-helpers/path";
+import { baseService } from "astro/assets";
+import { isESMImportedImage } from "astro/assets/utils";
+import { isRemoteAllowed } from "../utils/assets.js";
+const service = {
+  ...baseService,
+  getURL: (options, imageConfig) => {
+    const resizingParams = ["onerror=redirect"];
+    if (options.width) resizingParams.push(`width=${options.width}`);
+    if (options.height) resizingParams.push(`height=${options.height}`);
+    if (options.quality) resizingParams.push(`quality=${options.quality}`);
+    if (options.fit) resizingParams.push(`fit=${options.fit}`);
+    if (options.format) resizingParams.push(`format=${options.format}`);
+    let imageSource = "";
+    if (isESMImportedImage(options.src)) {
+      imageSource = options.src.src;
+    } else if (isRemoteAllowed(options.src, imageConfig)) {
+      imageSource = String(options.src);
+    } else {
+      return String(options.src);
+    }
+    const imageEndpoint = joinPaths(
+      // @ts-expect-error Can't recognise import.meta.env
+      import.meta.env.BASE_URL,
+      "/cdn-cgi/image",
+      resizingParams.join(","),
+      imageSource
+    );
+    return imageEndpoint;
+  }
+};
+var image_service_default = service;
+export {
+  image_service_default as default
+};

package/dist/entrypoints/middleware.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareHandler } from 'astro';
+export declare const onRequest: MiddlewareHandler;

package/dist/entrypoints/middleware.js

@@ -0,0 +1,11 @@
+const onRequest = (context, next) => {
+  if (context.isPrerendered) {
+    context.locals.runtime ??= {
+      env: process.env
+    };
+  }
+  return next();
+};
+export {
+  onRequest
+};

package/dist/entrypoints/server.d.ts

@@ -0,0 +1,15 @@
+import type { ExecutionContext, ExportedHandlerFetchHandler } from '@cloudflare/workers-types';
+import type { SSRManifest } from 'astro';
+type Env = {
+    [key: string]: unknown;
+    ASSETS: {
+        fetch: (req: Request | string) => Promise<Response>;
+    };
+    ASTRO_STUDIO_APP_TOKEN?: string;
+};
+export declare function createExports(manifest: SSRManifest): {
+    default: {
+        fetch: (request: Parameters<ExportedHandlerFetchHandler>[0], env: Env, context: ExecutionContext) => Promise<Response>;
+    };
+};
+export {};

package/dist/entrypoints/server.js

@@ -0,0 +1,12 @@
+import { App } from "astro/app";
+import { handle } from "../utils/handler.js";
+function createExports(manifest) {
+  const app = new App(manifest);
+  const fetch = async (request, env, context) => {
+    return await handle(manifest, app, request, env, context);
+  };
+  return { default: { fetch } };
+}
+export {
+  createExports
+};

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import type { AstroIntegration } from 'astro';
+import { type GetPlatformProxyOptions } from 'wrangler';
+import { type ImageService } from './utils/image-config.js';
+export type { Runtime } from './utils/handler.js';
+export type Options = {
+    /** Options for handling images. */
+    imageService?: ImageService;
+    /** Configuration for `_routes.json` generation. A _routes.json file controls when your Function is invoked. This file will include three different properties:
+     *
+     * - version: Defines the version of the schema. Currently there is only one version of the schema (version 1), however, we may add more in the future and aim to be backwards compatible.
+     * - include: Defines routes that will be invoked by Functions. Accepts wildcard behavior.
+     * - exclude: Defines routes that will not be invoked by Functions. Accepts wildcard behavior. `exclude` always take priority over `include`.
+     *
+     * Wildcards match any number of path segments (slashes). For example, `/users/*` will match everything after the `/users/` path.
+     *
+     */
+    routes?: {
+        /** Extend `_routes.json` */
+        extend: {
+            /** Paths which should be routed to the SSR function */
+            include?: {
+                /** Generally this is in pathname format, but does support wildcards, e.g. `/users`, `/products/*` */
+                pattern: string;
+            }[];
+            /** Paths which should be routed as static assets */
+            exclude?: {
+                /** Generally this is in pathname format, but does support wildcards, e.g. `/static`, `/assets/*`, `/images/avatar.jpg` */
+                pattern: string;
+            }[];
+        };
+    };
+    /**
+     * Proxy configuration for the platform.
+     */
+    platformProxy?: GetPlatformProxyOptions & {
+        /** Toggle the proxy. Default `undefined`, which equals to `true`. */
+        enabled?: boolean;
+    };
+    /**
+     * Allow bundling cloudflare worker specific file types as importable modules. Defaults to true.
+     * When enabled, allows imports of '.wasm', '.bin', and '.txt' file types
+     *
+     * See https://developers.cloudflare.com/pages/functions/module-support/
+     * for reference on how these file types are exported
+     */
+    cloudflareModules?: boolean;
+    /**
+     * By default, Astro will be configured to use Cloudflare KV to store session data. If you want to use sessions,
+     * you must create a KV namespace and declare it in your wrangler config file. You can do this with the wrangler command:
+     *
+     * ```sh
+     * npx wrangler kv namespace create SESSION
+     * ```
+     *
+     * This will log the id of the created namespace. You can then add it to your `wrangler.json` file like this:
+     *
+     * ```json
+     * {
+     *   "kv_namespaces": [
+     *     {
+     *       "binding": "SESSION",
+     *       "id": "<your kv namespace id here>"
+     *     }
+     *   ]
+     * }
+     * ```
+     * By default, the driver looks for the binding named `SESSION`, but you can override this by providing a different name here.
+     *
+     * See https://developers.cloudflare.com/kv/concepts/kv-namespaces/ for more details on using KV namespaces.
+     *
+     */
+    sessionKVBindingName?: string;
+    /**
+     * This configuration option allows you to specify a custom entryPoint for your Cloudflare Worker.
+     * The entry point is the file that will be executed when your Worker is invoked.
+     * By default, this is set to `@astrojs/cloudflare/entrypoints/server.js` and `['default']`.
+     * @docs https://docs.astro.build/en/guides/integrations-guide/cloudflare/#workerEntryPoint
+     */
+    workerEntryPoint?: {
+        /**
+         * The path to the entry file. This should be a relative path from the root of your Astro project.
+         * @example`'src/worker.ts'`
+         * @docs https://docs.astro.build/en/guides/integrations-guide/cloudflare/#workerentrypointpath
+         */
+        path: string | URL;
+        /**
+         * Additional named exports to use for the entry file. Astro always includes the default export (`['default']`). If you need to have other top level named exports use this option.
+         * @example ['MyDurableObject', 'namedExport']
+         * @docs https://docs.astro.build/en/guides/integrations-guide/cloudflare/#workerentrypointnamedexports
+         */
+        namedExports?: string[];
+    };
+};
+export default function createIntegration(args?: Options): AstroIntegration;

package/dist/index.js

@@ -0,0 +1,307 @@
+import { createReadStream } from "node:fs";
+import { appendFile, stat } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  appendForwardSlash,
+  prependForwardSlash,
+  removeLeadingForwardSlash
+} from "@astrojs/internal-helpers/path";
+import { createRedirectsFromAstroRoutes, printAsRedirects } from "@astrojs/underscore-redirects";
+import { AstroError } from "astro/errors";
+import { defaultClientConditions } from "vite";
+import { getPlatformProxy } from "wrangler";
+import {
+  cloudflareModuleLoader
+} from "./utils/cloudflare-module-loader.js";
+import { createGetEnv } from "./utils/env.js";
+import { createRoutesFile, getParts } from "./utils/generate-routes-json.js";
+import { setImageConfig } from "./utils/image-config.js";
+function wrapWithSlashes(path) {
+  return prependForwardSlash(appendForwardSlash(path));
+}
+function setProcessEnv(config, env) {
+  const getEnv = createGetEnv(env);
+  if (config.env?.schema) {
+    for (const key of Object.keys(config.env.schema)) {
+      const value = getEnv(key);
+      if (value !== void 0) {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+function createIntegration(args) {
+  let _config;
+  let finalBuildOutput;
+  const cloudflareModulePlugin = cloudflareModuleLoader(
+    args?.cloudflareModules ?? true
+  );
+  let _routes;
+  return {
+    name: "zastro-websockets-cloudflare",
+    hooks: {
+      "astro:config:setup": ({
+        command,
+        config,
+        updateConfig,
+        logger,
+        addWatchFile,
+        addMiddleware,
+        createCodegenDir
+      }) => {
+        let session = config.session;
+        const isBuild = command === "build";
+        if (!session?.driver) {
+          const sessionDir = isBuild ? void 0 : createCodegenDir();
+          const bindingName = args?.sessionKVBindingName ?? "SESSION";
+          if (isBuild) {
+            logger.info(
+              `Enabling sessions with Cloudflare KV for production with the "${bindingName}" KV binding.`
+            );
+            logger.info(
+              `If you see the error "Invalid binding \`${bindingName}\`" in your build output, you need to add the binding to your wrangler config file.`
+            );
+          }
+          session = isBuild ? {
+            ...session,
+            driver: "cloudflare-kv-binding",
+            options: {
+              binding: bindingName,
+              ...session?.options
+            }
+          } : {
+            ...session,
+            driver: "fs-lite",
+            options: {
+              base: fileURLToPath(new URL("sessions", sessionDir)),
+              ...session?.options
+            }
+          };
+        }
+        updateConfig({
+          build: {
+            client: new URL(`.${wrapWithSlashes(config.base)}`, config.outDir),
+            server: new URL("./_worker.js/", config.outDir),
+            serverEntry: "index.js",
+            redirects: false
+          },
+          session,
+          vite: {
+            plugins: [
+              // https://developers.cloudflare.com/pages/functions/module-support/
+              // Allows imports of '.wasm', '.bin', and '.txt' file types
+              cloudflareModulePlugin,
+              {
+                name: "vite:cf-imports",
+                enforce: "pre",
+                resolveId(source) {
+                  if (source.startsWith("cloudflare:")) {
+                    return { id: source, external: true };
+                  }
+                  return null;
+                }
+              }
+            ]
+          },
+          image: setImageConfig(args?.imageService ?? "compile", config.image, command, logger)
+        });
+        if (args?.platformProxy?.configPath) {
+          addWatchFile(new URL(args.platformProxy.configPath, config.root));
+        } else {
+          addWatchFile(new URL("./wrangler.toml", config.root));
+          addWatchFile(new URL("./wrangler.json", config.root));
+          addWatchFile(new URL("./wrangler.jsonc", config.root));
+        }
+        addMiddleware({
+          entrypoint: "zastro-websockets-cloudflare/entrypoints/middleware.js",
+          order: "pre"
+        });
+      },
+      "astro:routes:resolved": ({ routes }) => {
+        _routes = routes;
+      },
+      "astro:config:done": ({ setAdapter, config, buildOutput, logger }) => {
+        if (buildOutput === "static") {
+          logger.warn(
+            "[@astrojs/cloudflare] This adapter is intended to be used with server rendered pages, which this project does not contain any of. As such, this adapter is unnecessary."
+          );
+        }
+        _config = config;
+        finalBuildOutput = buildOutput;
+        let customWorkerEntryPoint;
+        if (args?.workerEntryPoint && typeof args.workerEntryPoint.path === "string") {
+          const require2 = createRequire(config.root);
+          try {
+            customWorkerEntryPoint = pathToFileURL(require2.resolve(args.workerEntryPoint.path));
+          } catch {
+            customWorkerEntryPoint = new URL(args.workerEntryPoint.path, config.root);
+          }
+        }
+        setAdapter({
+          name: "zastro-websockets-cloudflare",
+          serverEntrypoint: customWorkerEntryPoint ?? "zastro-websockets-cloudflare/entrypoints/server.js",
+          exports: args?.workerEntryPoint?.namedExports ? ["default", ...args.workerEntryPoint.namedExports] : ["default"],
+          adapterFeatures: {
+            edgeMiddleware: false,
+            buildOutput: "server"
+          },
+          supportedAstroFeatures: {
+            serverOutput: "stable",
+            hybridOutput: "stable",
+            staticOutput: "unsupported",
+            i18nDomains: "experimental",
+            sharpImageService: {
+              support: "limited",
+              message: 'Cloudflare does not support sharp at runtime. However, you can configure `imageService: "compile"` to optimize images with sharp on prerendered pages during build time.',
+              // For explicitly set image services, we suppress the warning about sharp not being supported at runtime,
+              // inferring the user is aware of the limitations.
+              suppress: args?.imageService ? "all" : "default"
+            },
+            envGetSecret: "stable"
+          }
+        });
+      },
+      "astro:server:setup": async ({ server }) => {
+        if ((args?.platformProxy?.enabled ?? true) === true) {
+          const platformProxy = await getPlatformProxy(args?.platformProxy);
+          server.httpServer?.on("close", async () => {
+            await platformProxy.dispose();
+          });
+          setProcessEnv(_config, platformProxy.env);
+          const clientLocalsSymbol = Symbol.for("astro.locals");
+          server.middlewares.use(async function middleware(req, _res, next) {
+            Reflect.set(req, clientLocalsSymbol, {
+              runtime: {
+                env: platformProxy.env,
+                cf: platformProxy.cf,
+                caches: platformProxy.caches,
+                ctx: {
+                  waitUntil: (promise) => platformProxy.ctx.waitUntil(promise),
+                  // Currently not available: https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions
+                  passThroughOnException: () => {
+                    throw new AstroError(
+                      "`passThroughOnException` is currently not available in Cloudflare Pages. See https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions."
+                    );
+                  }
+                }
+              }
+            });
+            next();
+          });
+        }
+      },
+      "astro:build:setup": ({ vite, target }) => {
+        if (target === "server") {
+          vite.resolve ||= {};
+          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.resolve ||= {};
+          vite.ssr.resolve.conditions ||= [...defaultClientConditions];
+          vite.ssr.resolve.conditions.push("workerd", "worker");
+          vite.ssr.target = "webworker";
+          vite.ssr.noExternal = true;
+          vite.build ||= {};
+          vite.build.rollupOptions ||= {};
+          vite.build.rollupOptions.output ||= {};
+          vite.build.rollupOptions.output.banner ||= "globalThis.process ??= {}; globalThis.process.env ??= {};";
+          vite.define = {
+            "process.env": "process.env",
+            // Allows the request handler to know what the binding name is
+            "globalThis.__ASTRO_SESSION_BINDING_NAME": JSON.stringify(
+              args?.sessionKVBindingName ?? "SESSION"
+            ),
+            ...vite.define
+          };
+        }
+      },
+      "astro:build:done": async ({ pages, dir, logger, assets }) => {
+        await cloudflareModulePlugin.afterBuildCompleted(_config);
+        let redirectsExists = false;
+        try {
+          const redirectsStat = await stat(new URL("./_redirects", _config.outDir));
+          if (redirectsStat.isFile()) {
+            redirectsExists = true;
+          }
+        } catch (_error) {
+          redirectsExists = false;
+        }
+        const redirects = [];
+        if (redirectsExists) {
+          const rl = createInterface({
+            input: createReadStream(new URL("./_redirects", _config.outDir)),
+            crlfDelay: Number.POSITIVE_INFINITY
+          });
+          for await (const line of rl) {
+            const parts = line.split(" ");
+            if (parts.length >= 2) {
+              const p = removeLeadingForwardSlash(parts[0]).split("/").filter(Boolean).map((s) => {
+                const syntax = s.replace(/\/:.*?(?=\/|$)/g, "/*").replace(/\?.*$/, "");
+                return getParts(syntax);
+              });
+              redirects.push(p);
+            }
+          }
+        }
+        let routesExists = false;
+        try {
+          const routesStat = await stat(new URL("./_routes.json", _config.outDir));
+          if (routesStat.isFile()) {
+            routesExists = true;
+          }
+        } catch (_error) {
+          routesExists = false;
+        }
+        if (!routesExists) {
+          await createRoutesFile(
+            _config,
+            logger,
+            _routes,
+            pages,
+            redirects,
+            args?.routes?.extend?.include,
+            args?.routes?.extend?.exclude
+          );
+        }
+        const trueRedirects = createRedirectsFromAstroRoutes({
+          config: _config,
+          routeToDynamicTargetMap: new Map(
+            Array.from(
+              _routes.filter((route) => route.type === "redirect").map((route) => [route, ""])
+            )
+          ),
+          dir,
+          buildOutput: finalBuildOutput,
+          assets
+        });
+        if (!trueRedirects.empty()) {
+          try {
+            await appendFile(
+              new URL("./_redirects", _config.outDir),
+              printAsRedirects(trueRedirects)
+            );
+          } catch (_error) {
+            logger.error("Failed to write _redirects file");
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  createIntegration as default
+};

package/dist/utils/assets.d.ts

@@ -0,0 +1,2 @@
+import type { AstroConfig } from 'astro';
+export declare function isRemoteAllowed(src: string, { domains, remotePatterns, }: Partial<Pick<AstroConfig['image'], 'domains' | 'remotePatterns'>>): boolean;

package/dist/utils/assets.js

@@ -0,0 +1,57 @@
+import { isRemotePath } from "@astrojs/internal-helpers/path";
+function matchHostname(url, hostname, allowWildcard) {
+  if (!hostname) {
+    return true;
+  }
+  if (!allowWildcard || !hostname.startsWith("*")) {
+    return hostname === url.hostname;
+  }
+  if (hostname.startsWith("**.")) {
+    const slicedHostname = hostname.slice(2);
+    return slicedHostname !== url.hostname && url.hostname.endsWith(slicedHostname);
+  }
+  if (hostname.startsWith("*.")) {
+    const slicedHostname = hostname.slice(1);
+    const additionalSubdomains = url.hostname.replace(slicedHostname, "").split(".").filter(Boolean);
+    return additionalSubdomains.length === 1;
+  }
+  return false;
+}
+function matchPort(url, port) {
+  return !port || port === url.port;
+}
+function matchProtocol(url, protocol) {
+  return !protocol || protocol === url.protocol.slice(0, -1);
+}
+function matchPathname(url, pathname, allowWildcard) {
+  if (!pathname) {
+    return true;
+  }
+  if (!allowWildcard || !pathname.endsWith("*")) {
+    return pathname === url.pathname;
+  }
+  if (pathname.endsWith("/**")) {
+    const slicedPathname = pathname.slice(0, -2);
+    return slicedPathname !== url.pathname && url.pathname.startsWith(slicedPathname);
+  }
+  if (pathname.endsWith("/*")) {
+    const slicedPathname = pathname.slice(0, -1);
+    const additionalPathChunks = url.pathname.replace(slicedPathname, "").split("/").filter(Boolean);
+    return additionalPathChunks.length === 1;
+  }
+  return false;
+}
+function matchPattern(url, remotePattern) {
+  return matchProtocol(url, remotePattern.protocol) && matchHostname(url, remotePattern.hostname, true) && matchPort(url, remotePattern.port) && matchPathname(url, remotePattern.pathname, true);
+}
+function isRemoteAllowed(src, {
+  domains = [],
+  remotePatterns = []
+}) {
+  if (!isRemotePath(src)) return false;
+  const url = new URL(src);
+  return domains.some((domain) => matchHostname(url, domain)) || remotePatterns.some((remotePattern) => matchPattern(url, remotePattern));
+}
+export {
+  isRemoteAllowed
+};

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

@@ -0,0 +1,20 @@
+import type { AstroConfig } from 'astro';
+import type { PluginOption } from 'vite';
+export interface CloudflareModulePluginExtra {
+    afterBuildCompleted(config: AstroConfig): Promise<void>;
+}
+/**
+ * Enables support for various non-standard extensions in module imports that cloudflare workers supports.
+ *
+ * See https://developers.cloudflare.com/pages/functions/module-support/ for reference
+ *
+ * This adds supports for imports in the following formats:
+ * - .wasm
+ * - .wasm?module
+ * - .bin
+ * - .txt
+ *
+ * @param enabled - if true, will load all cloudflare pages supported types
+ * @returns Vite plugin with additional extension method to hook into astro build
+ */
+export declare function cloudflareModuleLoader(enabled: boolean): PluginOption & CloudflareModulePluginExtra;