alchemy 0.42.1 → 0.43.1

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 };
+}