alchemy 0.4.1 → 0.5.1

package/src/os/exec.ts

@@ -0,0 +1,190 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+
+const execAsync = promisify(exec);
+
+/**
+ * Properties for executing a shell command
+ */
+export interface ExecProps {
+  /**
+   * The command to execute (including any arguments)
+   */
+  command: string;
+
+  /**
+   * Whether to memoize the command (only re-run if the command changes)
+   *
+   * @default false
+   */
+  memoize?: boolean;
+
+  /**
+   * Working directory for the command
+   */
+  cwd?: string;
+
+  /**
+   * Environment variables to set
+   */
+  env?: Record<string, string>;
+
+  /**
+   * Maximum buffer size for stdout and stderr (in bytes)
+   * @default 1024 * 1024 (1MB)
+   */
+  maxBuffer?: number;
+
+  /**
+   * Whether to throw an error if the command exits with a non-zero status
+   */
+  throwOnError?: boolean;
+}
+
+/**
+ * Output returned after command execution
+ */
+export interface Exec extends Resource<"os::Exec">, ExecProps {
+  /**
+   * Unique identifier for this execution
+   */
+  id: string;
+
+  /**
+   * Exit code of the command
+   */
+  exitCode: number;
+
+  /**
+   * Standard output from the command
+   */
+  stdout: string;
+
+  /**
+   * Standard error from the command
+   */
+  stderr: string;
+
+  /**
+   * Time at which the command was executed
+   */
+  executedAt: number;
+
+  /**
+   * Whether the command has completed execution
+   */
+  completed: boolean;
+}
+
+/**
+ * Execute a shell command
+ *
+ * @example
+ * // Run a simple command
+ * const result = await Exec("list-files", {
+ *   command: "ls -la"
+ * });
+ *
+ * console.log(result.stdout);
+ *
+ * @example
+ * // Run a command in a specific directory with custom environment
+ * const build = await Exec("build-project", {
+ *   command: "npm run build",
+ *   cwd: "./my-project",
+ *   env: { NODE_ENV: "production" }
+ * });
+ *
+ * @example
+ * // Run a command with a larger buffer for output
+ * const logs = await Exec("get-logs", {
+ *   command: "cat large-log-file.log",
+ *   maxBuffer: 10 * 1024 * 1024 // 10MB
+ * });
+ *
+ * @example
+ * // Run a memoized command that only re-executes when the command changes
+ * const memoizedCmd = await Exec("status-check", {
+ *   command: "git status",
+ *   memoize: true
+ * });
+ *
+ * // This won't actually run the command again if nothing has changed
+ * await Exec("status-check", {
+ *   command: "git status",
+ *   memoize: true
+ * });
+ */
+export const Exec = Resource(
+  "os::Exec",
+  {
+    alwaysUpdate: true,
+  },
+  async function (
+    this: Context<Exec>,
+    id: string,
+    props: ExecProps
+  ): Promise<Exec> {
+    if (this.phase === "delete") {
+      // Nothing to actually delete for an exec command
+      return this.destroy();
+    } else if (
+      this.phase === "update" &&
+      props.memoize &&
+      this.output?.command === props.command
+    ) {
+      // If memoize is enabled and the command hasn't changed, return the existing output
+      return this.output;
+    } else {
+      // Default values
+      let stdout = "";
+      let stderr = "";
+      let exitCode = 0;
+
+      try {
+        console.log(props.command);
+        // Execute the command
+        const result = await execAsync(props.command, {
+          cwd: props.cwd || process.cwd(),
+          env: { ...process.env, ...props.env },
+          maxBuffer: props.maxBuffer || 1024 * 1024, // Default 1MB
+        });
+
+        stdout = result.stdout;
+        console.log(stdout);
+        stderr = result.stderr;
+        exitCode = 0; // Success
+      } catch (error: any) {
+        console.log("error", error);
+        if (props.throwOnError) {
+          throw error;
+        }
+
+        // If not throwing, capture the error information
+        exitCode = error.code || 1;
+        stdout = error.stdout || "";
+        stderr = error.stderr || String(error);
+        console.log(stdout);
+        console.error(stderr);
+      }
+
+      // Return the execution result
+      return this({
+        id,
+        command: props.command,
+        cwd: props.cwd,
+        env: props.env,
+        maxBuffer: props.maxBuffer,
+        throwOnError: props.throwOnError,
+        memoize: props.memoize,
+        exitCode,
+        stdout,
+        stderr,
+        executedAt: Date.now(),
+        completed: true,
+      });
+    }
+  }
+);

package/src/os/index.ts

@@ -0,0 +1 @@
+export * from "./exec";

package/src/secret.ts

@@ -5,7 +5,7 @@
  *
  * 1. Globally when initializing the alchemy application:
  * ```ts
- * const app = alchemy("my-app", {
+ * const app = await alchemy("my-app", {
  *   password: process.env.SECRET_PASSPHRASE
  * });
  * ```
@@ -55,7 +55,7 @@ export function isSecret(binding: any): binding is Secret {
  *
  * @example
  * // Global password for all secrets
- * const app = alchemy("my-app", {
+ * const app = await alchemy("my-app", {
  *   password: process.env.SECRET_PASSPHRASE
  * });
  *

package/src/web/vitepress/vitepress.ts

@@ -190,7 +190,7 @@ export const VitepressProject = Resource(
       // import { Document } from "alchemy/docs";
       // import path from "path";
 
-      // await using _ = alchemy("alchemy.run", {
+      // const app = await alchemy("alchemy.run", {
       //   stage: "prod",
       //   phase: process.argv.includes("--destroy") ? "destroy" : "up",
       //   password: process.env.SECRET_PASSPHRASE,

package/lib/cloudflare/generate-asset-manifest.d.ts

@@ -1,2 +0,0 @@
-import type { AssetManifest, FileOption } from "./asset-manifest";
-export declare function generateAssetManifest(dir: string, fileOptions?: FileOption[]): Promise<AssetManifest>;

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

@@ -1,68 +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";
-export async function generateAssetManifest(dir, fileOptions = [
-    {
-        files: "**",
-        cacheControl: "max-age=0,no-cache,no-store,must-revalidate",
-    },
-    {
-        files: ["**/*.js", "**/*.css", "**/*.png", "**/*.webp"],
-        cacheControl: "max-age=31536000,public,immutable",
-    },
-]) {
-    // First, collect all file info based on fileOptions (reversed to prioritize later rules)
-    const fileInfos = [];
-    const filesProcessed = 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),
-        };
-    }));
-    return manifestEntries;
-}

package/lib/cloudflare/static-site-router.d.ts

@@ -1,18 +0,0 @@
-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;
-} & {
-    [key in `ROUTE_${string}`]: Service;
-} & {
-    [key in `__ROUTE_${string}`]: string;
-};
-declare const _default: {
-    fetch(request: Request, env: Env): Promise<Response>;
-};
-export default _default;

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>);