@b9g/platform-cloudflare 0.1.10 → 0.1.11

package/src/runtime.js

@@ -0,0 +1,65 @@
+/// <reference types="./runtime.d.ts" />
+// src/runtime.ts
+import {
+  ServiceWorkerGlobals,
+  ShovelServiceWorkerRegistration,
+  ShovelFetchEvent,
+  CustomLoggerStorage,
+  configureLogging,
+  createCacheFactory,
+  createDirectoryFactory
+} from "@b9g/platform/runtime";
+import { CustomCacheStorage } from "@b9g/cache";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { getLogger } from "@logtape/logtape";
+import { envStorage } from "./variables.js";
+var CloudflareFetchEvent = class extends ShovelFetchEvent {
+  /** Cloudflare environment bindings (KV, R2, D1, Durable Objects, etc.) */
+  env;
+  constructor(request, options) {
+    super(request, options);
+    this.env = options.env;
+  }
+};
+var _registration = null;
+var _globals = null;
+async function initializeRuntime(config) {
+  if (_registration) {
+    return _registration;
+  }
+  if (config.logging) {
+    await configureLogging(config.logging);
+  }
+  _registration = new ShovelServiceWorkerRegistration();
+  const caches = new CustomCacheStorage(
+    createCacheFactory({ configs: config.caches ?? {} })
+  );
+  const directories = new CustomDirectoryStorage(
+    createDirectoryFactory(config.directories ?? {})
+  );
+  _globals = new ServiceWorkerGlobals({
+    registration: _registration,
+    caches,
+    directories,
+    loggers: new CustomLoggerStorage((cats) => getLogger(cats))
+  });
+  _globals.install();
+  return _registration;
+}
+function createFetchHandler(registration) {
+  return async (request, env, ctx) => {
+    const event = new CloudflareFetchEvent(request, {
+      env,
+      platformWaitUntil: (promise) => ctx.waitUntil(promise)
+    });
+    return envStorage.run(
+      env,
+      () => registration.handleRequest(event)
+    );
+  };
+}
+export {
+  CloudflareFetchEvent,
+  createFetchHandler,
+  initializeRuntime
+};

package/src/variables.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Cloudflare Environment Storage
+ *
+ * Provides per-request access to Cloudflare's env object (KV, R2, D1 bindings, etc.)
+ * via AsyncContext. Used by directory implementations to resolve bindings at runtime.
+ */
+/**
+ * Per-request storage for Cloudflare's env object.
+ * Set by createFetchHandler() via envStorage.run().
+ */
+export declare const envStorage: any;
+/**
+ * Get the current Cloudflare env or throw if not in request context.
+ */
+export declare function getEnv(): Record<string, unknown>;

package/src/variables.js

@@ -0,0 +1,17 @@
+/// <reference types="./variables.d.ts" />
+// src/variables.ts
+import { AsyncContext } from "@b9g/async-context";
+var envStorage = new AsyncContext.Variable();
+function getEnv() {
+  const env = envStorage.get();
+  if (!env) {
+    throw new Error(
+      "Cloudflare env not available. Are you accessing bindings outside of a request context?"
+    );
+  }
+  return env;
+}
+export {
+  envStorage,
+  getEnv
+};

package/src/cloudflare-runtime.d.ts

@@ -1,39 +0,0 @@
-/**
- * Cloudflare Worker Runtime - Browser-safe ServiceWorkerGlobals setup
- *
- * This module is BROWSER-SAFE and can be bundled into Cloudflare Workers.
- * It only imports from browser-compatible modules:
- * - @b9g/platform/runtime (no fs/path)
- * - @b9g/filesystem (no fs/path in the index)
- * - @b9g/async-context (browser-safe)
- *
- * DO NOT import from @b9g/platform (the index) - it pulls in Node-only code.
- */
-import { ShovelServiceWorkerRegistration } from "@b9g/platform/runtime";
-/**
- * Cloudflare's ExecutionContext - passed to each request handler
- * Used for ctx.waitUntil() to extend request lifetime
- */
-export interface ExecutionContext {
-    waitUntil(promise: Promise<unknown>): void;
-    passThroughOnException(): void;
-}
-/**
- * Get the current request's Cloudflare env object
- * Contains all bindings: KV namespaces, R2 buckets, D1 databases, etc.
- */
-export declare function getEnv<T = Record<string, unknown>>(): T | undefined;
-/**
- * Get the current request's Cloudflare ExecutionContext
- * Used for ctx.waitUntil() and other lifecycle methods
- */
-export declare function getCtx(): ExecutionContext | undefined;
-/**
- * Initialize the Cloudflare runtime with ServiceWorkerGlobals
- * Called once when the worker module loads (before user code runs)
- */
-export declare function initializeRuntime(): ShovelServiceWorkerRegistration;
-/**
- * Create the ES module fetch handler for Cloudflare Workers
- */
-export declare function createFetchHandler(registration: ShovelServiceWorkerRegistration): (request: Request, env: unknown, ctx: ExecutionContext) => Promise<Response>;

package/src/cloudflare-runtime.js

@@ -1,102 +0,0 @@
-/// <reference types="./cloudflare-runtime.d.ts" />
-// src/cloudflare-runtime.ts
-import {
-  ServiceWorkerGlobals,
-  ShovelServiceWorkerRegistration,
-  CustomLoggerStorage
-} from "@b9g/platform/runtime";
-import { CustomDirectoryStorage } from "@b9g/filesystem";
-import { AsyncContext } from "@b9g/async-context";
-import { getLogger } from "@logtape/logtape";
-import { R2FileSystemDirectoryHandle } from "./filesystem-r2.js";
-var envStorage = new AsyncContext.Variable();
-var ctxStorage = new AsyncContext.Variable();
-function getEnv() {
-  return envStorage.get();
-}
-function getCtx() {
-  return ctxStorage.get();
-}
-var _registration = null;
-var _globals = null;
-function initializeRuntime() {
-  if (_registration) {
-    return _registration;
-  }
-  _registration = new ShovelServiceWorkerRegistration();
-  const directories = new CustomDirectoryStorage(
-    createCloudflareR2DirectoryFactory()
-  );
-  _globals = new ServiceWorkerGlobals({
-    registration: _registration,
-    caches: globalThis.caches,
-    // Cloudflare's native Cache API
-    directories,
-    loggers: new CustomLoggerStorage((...cats) => getLogger(cats))
-  });
-  _globals.install();
-  return _registration;
-}
-function createFetchHandler(registration) {
-  return async (request, env, ctx) => {
-    return envStorage.run(
-      env,
-      () => ctxStorage.run(ctx, async () => {
-        try {
-          return await registration.handleRequest(request);
-        } catch (error) {
-          console.error("ServiceWorker error:", error);
-          const err = error instanceof Error ? error : new Error(String(error));
-          const isDev = typeof import.meta !== "undefined" && import.meta.env?.MODE !== "production";
-          if (isDev) {
-            return new Response(
-              `<!DOCTYPE html>
-<html>
-<head><title>500 Internal Server Error</title>
-<style>body{font-family:system-ui;padding:2rem;max-width:800px;margin:0 auto}h1{color:#c00}pre{background:#f5f5f5;padding:1rem;overflow-x:auto}</style>
-</head>
-<body>
-<h1>500 Internal Server Error</h1>
-<p>${escapeHtml(err.message)}</p>
-<pre>${escapeHtml(err.stack || "No stack trace")}</pre>
-</body></html>`,
-              { status: 500, headers: { "Content-Type": "text/html" } }
-            );
-          }
-          return new Response("Internal Server Error", { status: 500 });
-        }
-      })
-    );
-  };
-}
-function escapeHtml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function createCloudflareR2DirectoryFactory() {
-  return async (name) => {
-    const env = getEnv();
-    if (!env) {
-      throw new Error(
-        `Cannot access directory "${name}": Cloudflare env not available. Are you accessing directories outside of a request context?`
-      );
-    }
-    const bindingName = `${name.toUpperCase()}_R2`;
-    const r2Bucket = env[bindingName];
-    if (!r2Bucket) {
-      throw new Error(
-        `R2 bucket binding "${bindingName}" not found. Configure in wrangler.toml:
-
-[[r2_buckets]]
-binding = "${bindingName}"
-bucket_name = "your-bucket-name"`
-      );
-    }
-    return new R2FileSystemDirectoryHandle(r2Bucket, "");
-  };
-}
-export {
-  createFetchHandler,
-  getCtx,
-  getEnv,
-  initializeRuntime
-};

package/src/env.d.ts

@@ -1,9 +0,0 @@
-// Vite-style import.meta.env declaration
-interface ImportMetaEnv {
-	MODE?: string;
-	[key: string]: string | undefined;
-}
-
-interface ImportMeta {
-	readonly env?: ImportMetaEnv;
-}

package/src/filesystem-assets.d.ts

@@ -1,55 +0,0 @@
-/**
- * CFAssetsDirectoryHandle - FileSystemDirectoryHandle over CF ASSETS binding
- *
- * Wraps Cloudflare's Workers Static Assets binding to provide the standard
- * File System Access API interface, enabling shovel's `self.dirs.open("dist")`
- * to work seamlessly with bundled static assets.
- *
- * @example
- * ```ts
- * // In production CF Worker
- * const dist = new CFAssetsDirectoryHandle(env.ASSETS, "/assets");
- * const file = await dist.getFileHandle("style.abc123.css");
- * const content = await (await file.getFile()).text();
- * ```
- */
-/**
- * Cloudflare ASSETS binding interface
- */
-export interface CFAssetsBinding {
-    fetch(request: Request | string): Promise<Response>;
-}
-/**
- * FileSystemDirectoryHandle implementation over Cloudflare ASSETS binding.
- *
- * Provides read-only access to static assets deployed with a CF Worker.
- * Directory listing is not supported (ASSETS binding limitation).
- */
-export declare class CFAssetsDirectoryHandle implements FileSystemDirectoryHandle {
-    #private;
-    readonly kind: "directory";
-    readonly name: string;
-    constructor(assets: CFAssetsBinding, basePath?: string);
-    getFileHandle(name: string, _options?: FileSystemGetFileOptions): Promise<FileSystemFileHandle>;
-    getDirectoryHandle(name: string, _options?: FileSystemGetDirectoryOptions): Promise<FileSystemDirectoryHandle>;
-    removeEntry(_name: string, _options?: FileSystemRemoveOptions): Promise<void>;
-    resolve(_possibleDescendant: FileSystemHandle): Promise<string[] | null>;
-    entries(): AsyncIterableIterator<[string, FileSystemHandle]>;
-    keys(): AsyncIterableIterator<string>;
-    values(): AsyncIterableIterator<FileSystemHandle>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileSystemHandle]>;
-    isSameEntry(other: FileSystemHandle): Promise<boolean>;
-}
-/**
- * FileSystemFileHandle implementation for CF ASSETS binding files.
- */
-export declare class CFAssetsFileHandle implements FileSystemFileHandle {
-    #private;
-    readonly kind: "file";
-    readonly name: string;
-    constructor(assets: CFAssetsBinding, path: string, name: string);
-    getFile(): Promise<File>;
-    createWritable(_options?: FileSystemCreateWritableOptions): Promise<FileSystemWritableFileStream>;
-    createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
-    isSameEntry(other: FileSystemHandle): Promise<boolean>;
-}

package/src/filesystem-assets.js

@@ -1,106 +0,0 @@
-/// <reference types="./filesystem-assets.d.ts" />
-// src/filesystem-assets.ts
-var CFAssetsDirectoryHandle = class _CFAssetsDirectoryHandle {
-  kind;
-  name;
-  #assets;
-  #basePath;
-  constructor(assets, basePath = "/") {
-    this.kind = "directory";
-    this.#assets = assets;
-    this.#basePath = basePath.endsWith("/") ? basePath : basePath + "/";
-    this.name = basePath.split("/").filter(Boolean).pop() || "assets";
-  }
-  async getFileHandle(name, _options) {
-    const path = this.#basePath + name;
-    const response = await this.#assets.fetch(
-      new Request("https://assets" + path)
-    );
-    if (!response.ok) {
-      throw new DOMException(
-        `A requested file or directory could not be found: ${name}`,
-        "NotFoundError"
-      );
-    }
-    return new CFAssetsFileHandle(this.#assets, path, name);
-  }
-  async getDirectoryHandle(name, _options) {
-    return new _CFAssetsDirectoryHandle(this.#assets, this.#basePath + name);
-  }
-  async removeEntry(_name, _options) {
-    throw new DOMException("Assets directory is read-only", "NotAllowedError");
-  }
-  async resolve(_possibleDescendant) {
-    return null;
-  }
-  // eslint-disable-next-line require-yield
-  async *entries() {
-    throw new DOMException(
-      "Directory listing not supported for ASSETS binding. Use an asset manifest for enumeration.",
-      "NotSupportedError"
-    );
-  }
-  // eslint-disable-next-line require-yield
-  async *keys() {
-    throw new DOMException(
-      "Directory listing not supported for ASSETS binding",
-      "NotSupportedError"
-    );
-  }
-  // eslint-disable-next-line require-yield
-  async *values() {
-    throw new DOMException(
-      "Directory listing not supported for ASSETS binding",
-      "NotSupportedError"
-    );
-  }
-  [Symbol.asyncIterator]() {
-    return this.entries();
-  }
-  isSameEntry(other) {
-    return Promise.resolve(
-      other instanceof _CFAssetsDirectoryHandle && other.#basePath === this.#basePath
-    );
-  }
-};
-var CFAssetsFileHandle = class _CFAssetsFileHandle {
-  kind;
-  name;
-  #assets;
-  #path;
-  constructor(assets, path, name) {
-    this.kind = "file";
-    this.#assets = assets;
-    this.#path = path;
-    this.name = name;
-  }
-  async getFile() {
-    const response = await this.#assets.fetch(
-      new Request("https://assets" + this.#path)
-    );
-    if (!response.ok) {
-      throw new DOMException(
-        `A requested file or directory could not be found: ${this.name}`,
-        "NotFoundError"
-      );
-    }
-    const blob = await response.blob();
-    const contentType = response.headers.get("content-type") || "application/octet-stream";
-    return new File([blob], this.name, { type: contentType });
-  }
-  async createWritable(_options) {
-    throw new DOMException("Assets are read-only", "NotAllowedError");
-  }
-  async createSyncAccessHandle() {
-    throw new DOMException("Sync access not supported", "NotSupportedError");
-  }
-  isSameEntry(other) {
-    return Promise.resolve(
-      other instanceof _CFAssetsFileHandle && other.#path === this.#path
-    );
-  }
-};
-export {
-  CFAssetsDirectoryHandle,
-  CFAssetsFileHandle
-};

package/src/filesystem-r2.d.ts

@@ -1,91 +0,0 @@
-/**
- * Cloudflare R2 implementation of File System Access API
- *
- * Implements FileSystemDirectoryHandle and FileSystemFileHandle using Cloudflare R2 bindings
- * to provide R2 cloud storage with File System Access API compatibility.
- */
-import type { FileSystemConfig } from "@b9g/filesystem";
-/** R2 object metadata */
-export interface R2Object {
-    key: string;
-    uploaded: Date;
-    httpMetadata?: {
-        contentType?: string;
-    };
-    arrayBuffer(): Promise<ArrayBuffer>;
-}
-/** R2 list result */
-export interface R2Objects {
-    objects: Array<{
-        key: string;
-    }>;
-    delimitedPrefixes: string[];
-}
-/** R2 bucket interface */
-export interface R2Bucket {
-    get(key: string): Promise<R2Object | null>;
-    head(key: string): Promise<R2Object | null>;
-    put(key: string, value: ArrayBuffer | Uint8Array): Promise<R2Object>;
-    delete(key: string): Promise<void>;
-    list(options?: {
-        prefix?: string;
-        delimiter?: string;
-    }): Promise<R2Objects>;
-}
-/**
- * Cloudflare R2 implementation of FileSystemWritableFileStream
- */
-export declare class R2FileSystemWritableFileStream extends WritableStream<Uint8Array> {
-    #private;
-    constructor(r2Bucket: R2Bucket, key: string);
-}
-/**
- * Cloudflare R2 implementation of FileSystemFileHandle
- */
-export declare class R2FileSystemFileHandle implements FileSystemFileHandle {
-    #private;
-    readonly kind: "file";
-    readonly name: string;
-    constructor(r2Bucket: R2Bucket, key: string);
-    getFile(): Promise<File>;
-    createWritable(): Promise<FileSystemWritableFileStream>;
-    createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
-    isSameEntry(other: FileSystemHandle): Promise<boolean>;
-    queryPermission(): Promise<PermissionState>;
-    requestPermission(): Promise<PermissionState>;
-}
-/**
- * Cloudflare R2 implementation of FileSystemDirectoryHandle
- */
-export declare class R2FileSystemDirectoryHandle implements FileSystemDirectoryHandle {
-    #private;
-    readonly kind: "directory";
-    readonly name: string;
-    constructor(r2Bucket: R2Bucket, prefix: string);
-    getFileHandle(name: string, options?: {
-        create?: boolean;
-    }): Promise<FileSystemFileHandle>;
-    getDirectoryHandle(name: string, options?: {
-        create?: boolean;
-    }): Promise<FileSystemDirectoryHandle>;
-    removeEntry(name: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    resolve(_possibleDescendant: FileSystemHandle): Promise<string[] | null>;
-    entries(): AsyncIterableIterator<[string, FileSystemHandle]>;
-    keys(): AsyncIterableIterator<string>;
-    values(): AsyncIterableIterator<FileSystemHandle>;
-    isSameEntry(other: FileSystemHandle): Promise<boolean>;
-    queryPermission(): Promise<PermissionState>;
-    requestPermission(): Promise<PermissionState>;
-}
-/**
- * R2 filesystem adapter
- */
-export declare class R2FileSystemAdapter {
-    #private;
-    constructor(r2Bucket: R2Bucket, config?: FileSystemConfig);
-    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
-    getConfig(): FileSystemConfig;
-    dispose(): Promise<void>;
-}