alchemy 0.43.0 → 0.43.2

package/src/cloudflare/wrangler.json.ts

@@ -27,7 +27,7 @@ export interface WranglerJsonProps {
   /**
    * Path to write the wrangler.json file to
    *
-   * @default cwd/wrangler.json
+   * @default worker.cwd/wrangler.json
    */
   path?: string;
 
@@ -89,14 +89,27 @@ export const WranglerJson = Resource(
     _id: string,
     props: WranglerJsonProps,
   ): Promise<WranglerJson> {
-    // Default path is wrangler.json in current directory
-    const filePath = props.path || "wrangler.jsonc";
-
     if (this.phase === "delete") {
       return this.destroy();
     }
 
-    if (props.worker.entrypoint === undefined) {
+    const cwd = props.worker.cwd
+      ? path.resolve(props.worker.cwd)
+      : process.cwd();
+
+    const toAbsolute = <T extends string | undefined>(input: T): T => {
+      return (input ? path.resolve(cwd, input) : undefined) as T;
+    };
+
+    const main = toAbsolute(props.main ?? props.worker.entrypoint);
+    let filePath = toAbsolute(props.path ?? cwd);
+    if (!path.basename(filePath).match(".json")) {
+      filePath = path.join(filePath, props.name ?? "wrangler.jsonc");
+    }
+
+    const dirname = path.dirname(filePath);
+
+    if (!main) {
       throw new Error(
         "Worker must have an entrypoint to generate a wrangler.json",
       );
@@ -107,16 +120,27 @@ export const WranglerJson = Resource(
     const spec: WranglerJsonSpec = {
       name: worker.name,
       // Use entrypoint as main if it exists
-      main: props.main ?? worker.entrypoint,
+      main: path.relative(dirname, main),
       // see: https://developers.cloudflare.com/workers/configuration/compatibility-dates/
       compatibility_date: worker.compatibilityDate,
       compatibility_flags: props.worker.compatibilityFlags,
-      assets: props.assets,
+      assets: props.assets
+        ? {
+            directory: toAbsolute(props.assets.directory),
+            binding: props.assets.binding,
+          }
+        : undefined,
     };
 
     // Process bindings if they exist
     if (worker.bindings) {
-      processBindings(spec, worker.bindings, worker.eventSources, worker.name);
+      processBindings(
+        spec,
+        worker.bindings,
+        worker.eventSources,
+        worker.name,
+        cwd,
+      );
     }
 
     // Add environment variables as vars
@@ -128,13 +152,17 @@ export const WranglerJson = Resource(
       spec.triggers = { crons: worker.crons };
     }
 
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    if (spec.assets) {
+      spec.assets.directory = path.relative(dirname, spec.assets.directory);
+    }
+
+    await fs.mkdir(dirname, { recursive: true });
     await fs.writeFile(filePath, await formatJson(spec));
 
     // Return the resource
     return this({
       ...props,
-      path: filePath,
+      path: path.relative(cwd, filePath),
       spec,
       createdAt: Date.now(),
       updatedAt: Date.now(),
@@ -381,6 +409,7 @@ function processBindings(
   bindings: Bindings,
   eventSources: EventSource[] | undefined,
   workerName: string,
+  workerCwd: string,
 ): void {
   // Arrays to collect different binding types
   const kvNamespaces: { binding: string; id: string; preview_id: string }[] =
@@ -527,7 +556,7 @@ function processBindings(
       secrets.push(bindingName);
     } else if (binding.type === "assets") {
       spec.assets = {
-        directory: binding.path,
+        directory: path.resolve(workerCwd, binding.path),
         binding: bindingName,
       };
     } else if (binding.type === "workflow") {

package/src/internal/docs/providers.ts

@@ -199,6 +199,8 @@ async function generateProviderDocs({
         See ${alchemy.file("./README.md")} to understand the overview of Alchemy.
         See ${alchemy.file("./.cursorrules")} to better understand the structure and convention of an Alchemy Resource.
 
+        Documentation should be written in the mdx format for an Astro Starlight documentation site.
+
         Relevant files for the ${providerName} Service:
         ${alchemy.files(files)}
         

package/src/os/exec.ts

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import { join } from "node:path";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import type { Secret } from "../secret.ts";
 
 /**
  * Properties for executing a shell command
@@ -47,7 +48,7 @@ export interface ExecProps {
   /**
    * Environment variables to set
    */
-  env?: Record<string, string>;
+  env?: Record<string, string | Secret<string>>;
 
   /**
    * Whether to inherit stdio from parent process
@@ -123,6 +124,19 @@ export interface Exec extends Resource<"os::Exec">, ExecProps {
  * });
  *
  * @example
+ * // Run a command with secrets in environment variables
+ * import alchemy from "alchemy";
+ *
+ * const deploy = await Exec("deploy-app", {
+ *   command: "npm run deploy",
+ *   env: {
+ *     NODE_ENV: "production",
+ *     API_KEY: alchemy.secret(process.env.API_KEY),
+ *     DATABASE_URL: alchemy.secret(process.env.DATABASE_URL)
+ *   }
+ * });
+ *
+ * @example
  * // Run a memoized command that only re-executes when the command changes
  * const memoizedCmd = await Exec("status-check", {
  *   command: "git status",
@@ -198,10 +212,23 @@ export const Exec = Resource(
       // Parse the command into command and args
       const [cmd, ...args] = props.command.split(/\s+/);
 
+      // Process environment variables, extracting values from secrets
+      const processedEnv: Record<string, string> = {};
+      if (props.env) {
+        for (const [key, value] of Object.entries(props.env)) {
+          if (typeof value === "string") {
+            processedEnv[key] = value;
+          } else {
+            // Handle Secret objects
+            processedEnv[key] = value.unencrypted;
+          }
+        }
+      }
+
       // Use spawn for better stdio control
       const childProcess = spawn(cmd, args, {
         cwd: props.cwd || process.cwd(),
-        env: { ...process.env, ...props.env },
+        env: { ...process.env, ...processedEnv },
         shell: true, // Use shell to handle complex commands
         stdio: inheritStdio ? "inherit" : "pipe", // Inherit stdio when requested
       });
@@ -342,13 +369,14 @@ export async function exec(
 }
 
 async function hashInputs(cwd: string, patterns: string[]) {
-  const { glob, readFile } = await import("node:fs/promises");
+  const { glob } = await import("glob");
+  const { readFile } = await import("node:fs/promises");
 
   const hashes = new Map<string, string>();
 
   await Promise.all(
     patterns.flatMap(async (pattern) => {
-      const files = await Array.fromAsync(glob(pattern, { cwd }));
+      const files = await glob(pattern, { cwd });
       return Promise.all(
         files.map(async (file: string) => {
           const path = join(cwd, file);

package/src/scope.ts

@@ -48,7 +48,11 @@ export type PendingDeletions = Array<{
 }>;
 
 // TODO: support browser
-const DEFAULT_STAGE = process.env.ALCHEMY_STAGE ?? process.env.USER ?? "dev";
+const DEFAULT_STAGE =
+  process.env.ALCHEMY_STAGE ??
+  process.env.USER ??
+  process.env.USERNAME ??
+  "dev";
 
 declare global {
   var __ALCHEMY_STORAGE__: AsyncLocalStorage<Scope>;

package/src/util/deferred-promise.ts

@@ -1,5 +1,7 @@
+import { promiseWithResolvers } from "./promise-with-resolvers.ts";
+
 export class DeferredPromise<T> {
-  private promise = Promise.withResolvers<T>();
+  private promise = promiseWithResolvers<T>();
 
   status: "pending" | "fulfilled" | "rejected" = "pending";
 

package/src/util/promise-with-resolvers.ts

@@ -0,0 +1,30 @@
+/**
+ * Interface for the return type of promiseWithResolvers
+ */
+export interface PromiseWithResolvers<T> {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: any) => void;
+}
+
+/**
+ * Node 20+ compatible implementation of Promise.withResolvers()
+ * Falls back to native Promise.withResolvers when available (Node 22+)
+ */
+export function promiseWithResolvers<T>(): PromiseWithResolvers<T> {
+  // Use native implementation if available
+  if (typeof Promise.withResolvers === "function") {
+    return Promise.withResolvers<T>();
+  }
+
+  // Fallback implementation for Node 20+
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: any) => void;
+
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return { promise, resolve, reject };
+}