alchemy 0.4.0 → 0.5.0

package/src/cloudflare/static-site-router.ts

@@ -1,157 +0,0 @@
-import { Hono } from "hono";
-
-// see: https://developers.cloudflare.com/workers/runtime-apis/cache/
-declare var caches: {
-  default: Cache;
-};
-
-// injected by src/cloudflare/static-site.ts
-declare var __ASSET_MANIFEST__: Record<string, string>;
-
-export type Env = {
-  ASSETS: KVNamespace;
-  INDEX_PAGE: string;
-  ERROR_PAGE?: string;
-  /**
-   * Optional backend worker bound to this static site
-   * Used to handle requests that don't match any static files
-   */
-  BACKEND_WORKER?: Service;
-} & {
-  // the binding to route the fetch call to
-  [key in `ROUTE_${string}`]: Service;
-} & {
-  // the route to match on, e.g. /api/*
-  [key in `__ROUTE_${string}`]: string;
-};
-
-let isInit = false;
-const app = new Hono<{ Bindings: Env }>();
-
-export default {
-  async fetch(request: Request, env: Env): Promise<Response> {
-    if (!isInit) {
-      isInit = true;
-      for (const [key, value] of Object.entries(env)) {
-        if (key.startsWith("ROUTE_")) {
-          const service = value as Service;
-          const patternKey = `__${key}`;
-          if (!(patternKey in env)) {
-            throw new Error(`Missing pattern key: ${patternKey}`);
-          }
-          const pattern = (env as any)[`__${key}`];
-          // TODO(sam): we should support narrowing down METHOD
-          app.all(pattern, (ctx) => service.fetch(ctx.req.raw));
-        }
-      }
-    }
-    return app.fetch(request, env);
-  },
-};
-
-// fall back to assuming the request is a static file
-app.notFound(async (ctx) => {
-  const request = ctx.req;
-  const env = ctx.env;
-  const url = new URL(request.url);
-  const pathname = url.pathname.replace(/^\//, "");
-  const filePath = pathname === "" ? env.INDEX_PAGE : pathname;
-
-  // Return from cache if available
-  const cachedResponse = await lookupCache();
-  if (cachedResponse) {
-    return cachedResponse;
-  }
-
-  // Fetch from KV
-  {
-    const object = await env.ASSETS.getWithMetadata(filePath, {
-      type: "arrayBuffer",
-    });
-    if (object.value) {
-      return await respond(200, filePath, object);
-    }
-  }
-  {
-    const guess = filePath + (filePath.endsWith("/") ? "" : "/") + "index.html";
-    const object = await env.ASSETS.getWithMetadata(guess, {
-      type: "arrayBuffer",
-    });
-    if (object.value) {
-      return await respond(200, guess, object);
-    }
-  }
-  {
-    const guess = filePath + ".html";
-    const object = await env.ASSETS.getWithMetadata(guess, {
-      type: "arrayBuffer",
-    });
-    if (object.value) {
-      return await respond(200, guess, object);
-    }
-  }
-
-  // Handle error page
-  if (env.ERROR_PAGE) {
-    const object = await env.ASSETS.getWithMetadata(env.ERROR_PAGE, {
-      type: "arrayBuffer",
-    });
-    if (object.value) {
-      return await respond(404, env.ERROR_PAGE, object);
-    }
-  } else {
-    const object = await env.ASSETS.getWithMetadata(env.INDEX_PAGE, {
-      type: "arrayBuffer",
-    });
-    if (object.value) {
-      return await respond(200, env.INDEX_PAGE, object);
-    }
-  }
-
-  return new Response("Page Not Found", { status: 404 });
-
-  async function lookupCache() {
-    const cache = caches.default;
-    const r = await cache.match(request.url);
-
-    // cache does not exist
-    if (!r) return;
-
-    // cache exists but etag does not match
-    if (r.headers.get("etag") !== __ASSET_MANIFEST__[filePath]) return;
-
-    // cache exists
-    return r;
-  }
-
-  async function saveCache(response: Response) {
-    const cache = caches.default;
-    await cache.put(request.url, response.clone());
-  }
-
-  async function respond(
-    status: number,
-    filePath: string,
-    object: KVNamespaceGetWithMetadataResult<any, any>
-  ) {
-    // build response
-    const headers = new Headers();
-    if (__ASSET_MANIFEST__[filePath]) {
-      headers.set("etag", __ASSET_MANIFEST__[filePath]);
-      headers.set("content-type", object.metadata.contentType);
-      headers.set("cache-control", object.metadata.cacheControl);
-    }
-
-    // Create response with the raw data directly
-    const response = new Response(object.value, {
-      status,
-      headers,
-    });
-
-    if (request.method === "GET") {
-      await saveCache(response);
-    }
-
-    return response;
-  }
-});

package/src/cloudflare/static-site.ts

@@ -1,416 +0,0 @@
-import { exec } from "child_process";
-import { promises as fs } from "fs";
-import path from "node:path";
-import { promisify } from "util";
-import type { Context } from "../context";
-import type { BundleProps } from "../esbuild/bundle";
-import { Resource } from "../resource";
-import { createCloudflareApi } from "./api";
-import type { Bindings } from "./bindings";
-import { generateAssetManifest } from "./generate-asset-manifest";
-import { KVNamespace } from "./kv-namespace";
-import { uploadAssetManifest } from "./upload-asset-manifest";
-import { Worker } from "./worker";
-
-const __dirname = import.meta.dirname;
-
-/**
- * Idea of using KV with timeout inspired by SST: https://github.com/sst/sst/blob/dev/platform/src/components/cloudflare/static-site.ts
- */
-
-/**
- * Properties for creating or updating a StaticSite
- */
-export interface StaticSiteProps {
-  /**
-   * Name for the site
-   * This is mandatory - must be explicitly specified
-   */
-  name: string;
-
-  /**
-   * Path to the directory containing static assets
-   */
-  dir: string;
-
-  /**
-   * Custom Worker script to serve the site
-   * If not provided, a default script will be used
-   */
-  workerScript?: string;
-
-  /**
-   * Worker script format
-   * 'esm' - ECMAScript modules (default)
-   * 'cjs' - CommonJS modules
-   * @default 'esm'
-   */
-  format?: "esm" | "cjs";
-
-  /**
-   * Custom error page path (relative to directory)
-   * @example "404.html"
-   */
-  errorPage?: string;
-
-  /**
-   * Index page filename
-   * @default "index.html"
-   */
-  indexPage?: string;
-
-  /**
-   * Configure how the static site's assets are uploaded to KV
-   */
-  assets?: {
-    /**
-     * File options for configuring caching behavior
-     */
-    fileOptions?: {
-      /**
-       * File pattern(s) to match
-       * Can be a glob string or array of glob strings
-       */
-      files: string | string[];
-
-      /**
-       * Files to ignore (glob patterns)
-       */
-      ignore?: string | string[];
-
-      /**
-       * Cache-Control header to set for matching files
-       */
-      cacheControl: string;
-
-      /**
-       * Content-Type to set (overrides auto-detection)
-       */
-      contentType?: string;
-    }[];
-  };
-
-  /**
-   * Whether the site should be deployed to production
-   * @default true
-   */
-  production?: boolean;
-
-  build?: {
-    /**
-     * Command to run before deploying the site
-     * Will be executed in the shell to build the site
-     */
-    command?: string;
-  };
-
-  /**
-   * Bundle options for the worker script
-   */
-  bundle?: Partial<BundleProps>;
-
-  /**
-   * Additional workers to route requests to.
-   */
-  routes?: {
-    [key: string]: Worker;
-  };
-}
-
-/**
- * Output returned after StaticSite creation/update
- */
-export interface StaticSite extends Resource<"cloudflare::StaticSite"> {
-  /**
-   * The ID of the worker
-   */
-  workerId: string;
-
-  /**
-   * Name for the site
-   */
-  name: string;
-
-  /**
-   * Path to the directory containing static assets
-   */
-  directory: string;
-
-  /**
-   * Worker script format
-   */
-  format?: "esm" | "cjs";
-
-  /**
-   * Custom error page path
-   */
-  errorPage?: string;
-
-  /**
-   * Index page filename
-   */
-  indexPage?: string;
-
-  /**
-   * Time at which the site was created
-   */
-  createdAt: number;
-
-  /**
-   * Time at which the site was last updated
-   */
-  updatedAt: number;
-
-  /**
-   * List of uploaded asset files
-   */
-  assets: string[];
-
-  /**
-   * Whether the site is deployed to production
-   */
-  production?: boolean;
-
-  /**
-   * The URL of the deployed site
-   */
-  url?: string;
-
-  /**
-   * Information about the backend worker if configured
-   */
-  routes?: Record<string, string>;
-}
-
-/**
- * A StaticSite resource deploys static web content to Cloudflare Workers, using KV for asset storage.
- * It provides an efficient way to serve static websites with global distribution and caching.
- *
- * @example
- * // Create a basic static site with default settings
- * const basicSite = await StaticSite("my-site", {
- *   name: "my-site",
- *   dir: "./dist",
- *   url: true
- * });
- *
- * @example
- * // Create a static site with custom build command and minification disabled
- * const devSite = await StaticSite("dev-site", {
- *   name: "dev-site",
- *   dir: "./public",
- *   build: {
- *     command: "npm run build"
- *   },
- *   bundle: {
- *     minify: false
- *   }
- * });
- *
- * @example
- * // Create a static site with a backend API worker
- * const backend = await Worker("api-backend", {
- *   name: "api-backend",
- *   entrypoint: "./src/api.ts"
- * });
- *
- * const fullSite = await StaticSite("full-site", {
- *   name: "full-site",
- *   dir: "./dist",
- *   routes: {
- *     "/api/*": backend
- *   }
- * });
- *
- * @example
- * // Create a static site with a custom domain using the CustomDomain resource
- * const site = await StaticSite("custom-site", {
- *   name: "custom-site",
- *   dir: "./www",
- *   errorPage: "404.html",
- *   indexPage: "home.html"
- * });
- *
- * // Then configure the custom domain separately
- * const domain = await CustomDomain("custom-domain", {
- *   name: "www.example.com",
- *   zoneId: "abcdef123456789",
- *   workerName: site.name
- * });
- *
- * @example
- * // Create a static site with multiple domains (primary + redirects)
- * const site = await StaticSite("multi-domain-site", {
- *   name: "multi-domain-site",
- *   dir: "./public"
- * });
- *
- * @see https://developers.cloudflare.com/workers/platform/sites
- */
-export const StaticSite = Resource(
-  "cloudflare::StaticSite",
-  {
-    alwaysUpdate: true,
-  },
-  async function (
-    this: Context<StaticSite>,
-    id: string,
-    props: StaticSiteProps
-  ) {
-    // Create Cloudflare API client with automatic account discovery
-    const api = await createCloudflareApi();
-
-    if (this.phase === "delete") {
-      // For delete operations, we'll rely on the Worker delete to clean up
-      // Return empty output for deleted state
-      return this.destroy();
-    }
-
-    // Validate that a name is provided
-    if (!props.name) {
-      throw new Error(
-        "StaticSite name is required - must be explicitly specified"
-      );
-    }
-
-    // Validate directory exists
-    if (!props.dir) {
-      throw new Error("Directory is required for StaticSite");
-    }
-
-    // Run build command if provided
-    if (props.build?.command) {
-      try {
-        if (!this.quiet) {
-          console.log(props.build.command);
-        }
-        const execAsync = promisify(exec);
-        const { stdout, stderr } = await execAsync(props.build.command, {
-          cwd: process.cwd(),
-        });
-
-        if (stdout && !this.quiet) console.log(stdout);
-      } catch (error: any) {
-        // Log detailed error information
-        console.error(`Build command failed with exit code ${error.code}`);
-        if (error.stdout) console.error(`Command stdout: ${error.stdout}`);
-        if (error.stderr) console.error(`Command stderr: ${error.stderr}`);
-
-        // Throw a more descriptive error that includes the exit code and stderr
-        throw new Error(
-          `Build command "${props.build.command}" failed with exit code ${error.code}:\n${error.stderr || error.message}`
-        );
-      }
-    }
-
-    try {
-      const dirStat = await fs.stat(props.dir);
-      if (!dirStat.isDirectory()) {
-        throw new Error(`"${props.dir}" is not a directory`);
-      }
-    } catch (error: any) {
-      throw new Error(
-        `Directory "${props.dir}" does not exist: ${error.message}`
-      );
-    }
-
-    // Use the provided name
-    const siteName = props.name;
-    const indexPage = props.indexPage || "index.html";
-
-    // Step 1: Create or get the KV namespace for assets
-    const [kv, assetManifest] = await Promise.all([
-      KVNamespace("assets", {
-        title: `${siteName}-assets`,
-      }),
-      generateAssetManifest(props.dir),
-    ]);
-
-    // Step 3: Upload assets to KV
-    await uploadAssetManifest(api, kv.namespaceId, assetManifest);
-
-    // Prepare the bindings for the worker
-    const bindings: Bindings = {
-      ASSETS: kv,
-      INDEX_PAGE: indexPage,
-      // Add error page binding if specified
-      ...(props.errorPage ? { ERROR_PAGE: props.errorPage } : {}),
-    };
-
-    const routes: Record<string, string> = {};
-    // Create backend worker if configured
-    if (props.routes) {
-      for (const [path, worker] of Object.entries(props.routes)) {
-        // @ts-ignore - TODO: need to use Resolved<Worker> to get the string ...
-        routes[path] = worker.id;
-        bindings[`ROUTE_${worker.id}`] = worker;
-      }
-    }
-
-    // Create asset manifest banner for static site router
-    const assetManifestBanner = `const __ASSET_MANIFEST__ = ${JSON.stringify(
-      Object.fromEntries(assetManifest.map((item) => [item.key, item.hash]))
-    )};\n`;
-
-    const bundleOptions = {
-      ...props.bundle,
-      options: {
-        ...props.bundle?.options,
-        banner: {
-          js: assetManifestBanner,
-          ...props.bundle?.options?.banner,
-        },
-      },
-    };
-
-    // Determine the entrypoint file - check for .ts first, fallback to .js
-    let entrypointFile = "static-site-router.js";
-    try {
-      const tsFile = path.resolve(__dirname, "static-site-router.ts");
-      await fs.access(tsFile);
-      // If we reach here, the TypeScript file exists
-      entrypointFile = "static-site-router.ts";
-    } catch (error) {
-      // TypeScript file doesn't exist, use JavaScript (default)
-    }
-
-    const worker = await Worker("worker", {
-      name: siteName,
-      url: true,
-      format: props.format || "esm",
-      // If a custom worker script is provided, use it, otherwise use the entrypoint from router
-      ...(props.workerScript
-        ? { script: props.workerScript }
-        : {
-            entrypoint: path.resolve(__dirname, entrypointFile),
-            bundle: bundleOptions as any,
-          }),
-      bindings,
-      env: {
-        ...Object.fromEntries(
-          Object.entries(routes).map(([key, value]) => [
-            `__ROUTE_${value}`,
-            key,
-          ])
-        ),
-      },
-    });
-
-    const now = Date.now();
-
-    return this({
-      workerId: worker.id,
-      name: siteName,
-      directory: props.dir,
-      format: props.format || "esm",
-      errorPage: props.errorPage,
-      indexPage,
-      assets: assetManifest.map((item) => item.key),
-      createdAt: this.output?.createdAt || now,
-      updatedAt: now,
-      production: props.production !== false,
-      url: worker.url,
-      routes,
-    });
-  }
-);

package/src/cloudflare/upload-asset-manifest.ts

@@ -1,85 +0,0 @@
-import fs from "node:fs/promises";
-import type { CloudflareApi } from "./api";
-import type { AssetManifest } from "./asset-manifest";
-
-// Maximum number of concurrent uploads
-const MAX_CONCURRENT = 100; // Adjust based on API limits and performance testing
-
-// Define types for our queue operations
-type AssetItem = AssetManifest[number];
-type UploadResult = {
-  item: AssetItem;
-  success: boolean;
-  status?: number;
-  error?: unknown;
-};
-
-export async function uploadAssetManifest(
-  api: CloudflareApi,
-  namespaceId: string,
-  manifest: AssetManifest
-): Promise<UploadResult[]> {
-  const results: UploadResult[] = [];
-
-  // Process in batches with controlled concurrency
-  let index = 0;
-  const activePromises = new Set<Promise<void>>();
-
-  while (index < manifest.length || activePromises.size > 0) {
-    // Fill up to MAX_CONCURRENT active uploads
-    while (activePromises.size < MAX_CONCURRENT && index < manifest.length) {
-      const item = manifest[index++];
-      const promise = uploadItem(item).then((result) => {
-        results.push(result);
-        activePromises.delete(promise);
-      });
-      activePromises.add(promise);
-    }
-
-    // Wait for at least one promise to complete if we have any active
-    if (activePromises.size > 0) {
-      await Promise.race(activePromises);
-    }
-  }
-
-  return results;
-
-  async function uploadItem(item: AssetItem): Promise<UploadResult> {
-    const content = await fs.readFile(item.source);
-
-    // Create metadata object
-    const metadata = {
-      key: item.key,
-      hash: item.hash,
-      contentType: item.contentType,
-      cacheControl: item.cacheControl,
-    };
-
-    // Create FormData for multipart upload
-    const formData = new FormData();
-    formData.append("metadata", JSON.stringify(metadata));
-
-    // Add file content as 'value' - Fix for binary file corruption
-    const blob = new Blob([new Uint8Array(content)], {
-      type: item.contentType,
-    });
-    formData.append("value", blob);
-
-    try {
-      const response = await api.put(
-        `/accounts/${api.accountId}/storage/kv/namespaces/${namespaceId}/values/${item.key}`,
-        formData
-      );
-
-      const result = { item, success: response.ok, status: response.status };
-      if (!result.success) {
-        console.warn(`Error uploading asset ${item.key}: ${result.status}`);
-      }
-      return result;
-    } catch (error) {
-      const result = { item, success: false, error };
-      console.warn(`Error uploading asset ${item.key}: ${error}`);
-      return result;
-    }
-  }
-}