alchemy 0.4.0 → 0.5.0

package/lib/cloudflare/static-site-router.js

@@ -1,115 +0,0 @@
-import { Hono } from "hono";
-let isInit = false;
-const app = new Hono();
-export default {
-    async fetch(request, env) {
-        if (!isInit) {
-            isInit = true;
-            for (const [key, value] of Object.entries(env)) {
-                if (key.startsWith("ROUTE_")) {
-                    const service = value;
-                    const patternKey = `__${key}`;
-                    if (!(patternKey in env)) {
-                        throw new Error(`Missing pattern key: ${patternKey}`);
-                    }
-                    const pattern = env[`__${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) {
-        const cache = caches.default;
-        await cache.put(request.url, response.clone());
-    }
-    async function respond(status, filePath, object) {
-        // 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/lib/cloudflare/static-site.d.ts

@@ -1,211 +0,0 @@
-import type { Context } from "../context";
-import type { BundleProps } from "../esbuild/bundle";
-import { Resource } from "../resource";
-import { Worker } from "./worker";
-/**
- * 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 declare const StaticSite: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<StaticSite>, id: string, props: StaticSiteProps) => Promise<StaticSite>);

package/lib/cloudflare/static-site.js

@@ -1,213 +0,0 @@
-import { exec } from "child_process";
-import { promises as fs } from "fs";
-import path from "node:path";
-import { promisify } from "util";
-import { Resource } from "../resource";
-import { createCloudflareApi } from "./api";
-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;
-/**
- * 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 (id, props) {
-    // 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) {
-            // 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) {
-        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 = {
-        ASSETS: kv,
-        INDEX_PAGE: indexPage,
-        // Add error page binding if specified
-        ...(props.errorPage ? { ERROR_PAGE: props.errorPage } : {}),
-    };
-    const routes = {};
-    // 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,
-            }),
-        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/lib/cloudflare/upload-asset-manifest.d.ts

@@ -1,11 +0,0 @@
-import type { CloudflareApi } from "./api";
-import type { AssetManifest } from "./asset-manifest";
-type AssetItem = AssetManifest[number];
-type UploadResult = {
-    item: AssetItem;
-    success: boolean;
-    status?: number;
-    error?: unknown;
-};
-export declare function uploadAssetManifest(api: CloudflareApi, namespaceId: string, manifest: AssetManifest): Promise<UploadResult[]>;
-export {};

package/lib/cloudflare/upload-asset-manifest.js

@@ -1,56 +0,0 @@
-import fs from "node:fs/promises";
-// Maximum number of concurrent uploads
-const MAX_CONCURRENT = 100; // Adjust based on API limits and performance testing
-export async function uploadAssetManifest(api, namespaceId, manifest) {
-    const results = [];
-    // Process in batches with controlled concurrency
-    let index = 0;
-    const activePromises = new Set();
-    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) {
-        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;
-        }
-    }
-}

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

@@ -1,93 +0,0 @@
-import crypto from "crypto";
-import { promises as fs } from "fs";
-import { glob } from "glob";
-import path from "path";
-import { getContentType } from "../util/content-type";
-import type {
-  AssetManifest,
-  AssetManifestEntry,
-  FileOption,
-} from "./asset-manifest";
-
-export async function generateAssetManifest(
-  dir: string,
-  fileOptions: FileOption[] = [
-    {
-      files: "**",
-      cacheControl: "max-age=0,no-cache,no-store,must-revalidate",
-    },
-    {
-      files: ["**/*.js", "**/*.css", "**/*.png", "**/*.webp"],
-      cacheControl: "max-age=31536000,public,immutable",
-    },
-  ]
-): Promise<AssetManifest> {
-  // First, collect all file info based on fileOptions (reversed to prioritize later rules)
-  const fileInfos: Array<{
-    file: string;
-    cacheControl: string;
-    contentType?: string;
-  }> = [];
-  const filesProcessed: Set<string> = new Set();
-
-  // Process file options in reverse order (later rules override earlier ones)
-  // Use for...of to maintain order but allow await inside the loop
-  const reversedOptions = [...fileOptions].reverse();
-  for (const fileOption of reversedOptions) {
-    const patterns = Array.isArray(fileOption.files)
-      ? fileOption.files
-      : [fileOption.files];
-
-    // Get all files matching the pattern
-    const files = (
-      await Promise.all(
-        patterns.map(async (p) => {
-          // Use glob as async function instead of globSync
-          return glob(p, {
-            cwd: path.resolve(dir),
-            nodir: true,
-            dot: true,
-            ignore: [
-              ".git/**",
-              "node_modules/**",
-              ...(typeof fileOption.ignore === "string"
-                ? [fileOption.ignore]
-                : (fileOption.ignore ?? [])),
-            ],
-          });
-        })
-      )
-    )
-      .flat()
-      .filter((file) => !filesProcessed.has(file));
-
-    // Add files to processed set
-    for (const file of files) {
-      filesProcessed.add(file);
-      fileInfos.push({
-        file,
-        cacheControl: fileOption.cacheControl,
-        contentType: fileOption.contentType,
-      });
-    }
-  }
-
-  // Process all files in parallel
-  const manifestEntries = await Promise.all(
-    fileInfos.map(async ({ file, cacheControl, contentType }) => {
-      const source = path.resolve(dir, file);
-      const content = await fs.readFile(source);
-      const hash = crypto.createHash("sha256").update(content).digest("hex");
-
-      return {
-        source,
-        key: file,
-        hash,
-        cacheControl,
-        contentType: contentType ?? getContentType(file),
-      } satisfies AssetManifestEntry;
-    })
-  );
-
-  return manifestEntries;
-}