alchemy 0.12.21 → 0.14.0

package/src/os/exec.ts

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawn, type SpawnOptions } from "node:child_process";
 import type { Context } from "../context.js";
 import { Resource } from "../resource.js";
 
@@ -117,87 +117,128 @@ export const Exec = Resource(
   async function (
     this: Context<Exec>,
     id: string,
-    props: ExecProps
+    props: ExecProps,
   ): Promise<Exec> {
     if (this.phase === "delete") {
       // Nothing to actually delete for an exec command
       return this.destroy();
-    } else if (
+    }
+    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;
-
-      // Default to inheriting stdio unless explicitly set to false
-      const inheritStdio = props.inheritStdio !== false;
-
-      try {
-        // Parse the command into command and args
-        const [cmd, ...args] = props.command.split(/\s+/);
-
-        // Use spawn for better stdio control
-        const childProcess = spawn(cmd, args, {
-          cwd: props.cwd || process.cwd(),
-          env: { ...process.env, ...props.env },
-          shell: true, // Use shell to handle complex commands
-          stdio: inheritStdio ? "inherit" : "pipe", // Inherit stdio when requested
+    }
+    // Default values
+    let stdout = "";
+    let stderr = "";
+    let exitCode = 0;
+
+    // Default to inheriting stdio unless explicitly set to false
+    const inheritStdio = props.inheritStdio !== false;
+
+    try {
+      // Parse the command into command and args
+      const [cmd, ...args] = props.command.split(/\s+/);
+
+      // Use spawn for better stdio control
+      const childProcess = spawn(cmd, args, {
+        cwd: props.cwd || process.cwd(),
+        env: { ...process.env, ...props.env },
+        shell: true, // Use shell to handle complex commands
+        stdio: inheritStdio ? "inherit" : "pipe", // Inherit stdio when requested
+      });
+
+      if (!inheritStdio) {
+        // If not inheriting stdio, collect output manually
+        childProcess.stdout?.on("data", (data) => {
+          stdout += data.toString();
         });
 
-        if (!inheritStdio) {
-          // If not inheriting stdio, collect output manually
-          childProcess.stdout?.on("data", (data) => {
-            stdout += data.toString();
-          });
-
-          childProcess.stderr?.on("data", (data) => {
-            stderr += data.toString();
-          });
-        }
-
-        // Wait for the process to complete
-        exitCode = await new Promise<number>((resolve, reject) => {
-          childProcess.on("close", (code) => {
-            resolve(code || 0);
-          });
-
-          childProcess.on("error", (err) => {
-            stderr += err.toString();
-            resolve(1);
-          });
+        childProcess.stderr?.on("data", (data) => {
+          stderr += data.toString();
         });
-      } catch (error: any) {
-        // If not throwing, capture the error information
-        exitCode = 1;
-        stderr += String(error);
       }
 
-      if (exitCode !== 0) {
-        throw new Error(
-          `Command failed with exit code ${exitCode}: ${props.command}\n${stderr}`
-        );
-      }
+      // Wait for the process to complete
+      exitCode = await new Promise<number>((resolve, reject) => {
+        childProcess.on("close", (code) => {
+          resolve(code || 0);
+        });
 
-      // Return the execution result
-      return this({
-        id,
-        command: props.command,
-        cwd: props.cwd,
-        env: props.env,
-        memoize: props.memoize,
-        inheritStdio,
-        exitCode,
-        stdout,
-        stderr,
-        executedAt: Date.now(),
-        completed: true,
+        childProcess.on("error", (err) => {
+          stderr += err.toString();
+          resolve(1);
+        });
       });
+    } catch (error: any) {
+      // If not throwing, capture the error information
+      exitCode = 1;
+      stderr += String(error);
     }
-  }
+
+    if (exitCode !== 0) {
+      throw new Error(
+        `Command failed with exit code ${exitCode}: ${props.command}\n${stderr}`,
+      );
+    }
+
+    // Return the execution result
+    return this({
+      id,
+      command: props.command,
+      cwd: props.cwd,
+      env: props.env,
+      memoize: props.memoize,
+      inheritStdio,
+      exitCode,
+      stdout,
+      stderr,
+      executedAt: Date.now(),
+      completed: true,
+    });
+  },
 );
+
+const defaultOptions: SpawnOptions = {
+  stdio: "inherit",
+  env: {
+    ...process.env,
+  },
+  shell: true,
+};
+
+/**
+ * Execute a shell command.
+ */
+export async function exec(
+  command: string,
+  options?: Partial<SpawnOptions>,
+): Promise<void> {
+  const [cmd, ...args] = command.split(/\s+/);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      ...defaultOptions,
+      ...options,
+      env: {
+        ...defaultOptions.env,
+        ...options?.env,
+      },
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}

package/src/resource.ts

@@ -69,7 +69,7 @@ type IsClass = {
 type ResourceLifecycleHandler = (
   this: Context<any, any>,
   id: string,
-  props: any
+  props: any,
 ) => Promise<Resource<string>>;
 
 // see: https://x.com/samgoodwin89/status/1904640134097887653
@@ -100,7 +100,7 @@ export function Resource<
 
   const provider = ((
     resourceID: string,
-    props: ResourceProps
+    props: ResourceProps,
   ): Promise<Resource<string>> => {
     const scope = _Scope.current;
 
@@ -116,7 +116,7 @@ export function Resource<
       if (otherResource?.Kind !== type) {
         scope.fail();
         throw new Error(
-          `Resource ${resourceID} already exists in the stack and is of a different type: '${otherResource?.Kind}' !== '${type}'`
+          `Resource ${resourceID} already exists in the stack and is of a different type: '${otherResource?.Kind}' !== '${type}'`,
         );
       }
       // console.warn(

package/src/scope.ts

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import type { Phase } from "./alchemy.js";
 import { destroy } from "./destroy.js";
 import { FileSystemStateStore } from "./fs/file-system-state-store.js";
 import type { PendingResource, ResourceID } from "./resource.js";
@@ -14,6 +15,7 @@ export type ScopeOptions = {
   password?: string;
   stateStore?: StateStoreType;
   quiet?: boolean;
+  phase?: Phase;
 };
 
 // TODO: support browser
@@ -40,6 +42,7 @@ export class Scope {
   public readonly password: string | undefined;
   public readonly state: StateStore;
   public readonly quiet: boolean;
+  public readonly phase: Phase;
 
   private isErrored = false;
 
@@ -56,6 +59,11 @@ export class Scope {
     this.state = options.stateStore
       ? options.stateStore(this)
       : new FileSystemStateStore(this);
+    const phase = options.phase ?? this.parent?.phase;
+    if (phase === undefined) {
+      throw new Error("Phase is required");
+    }
+    this.phase = phase;
   }
 
   public async delete(resourceID: ResourceID) {
@@ -74,9 +82,8 @@ export class Scope {
     const app = this.appName ? [this.appName] : [];
     if (this.parent) {
       return [...this.parent.chain, ...thisScope];
-    } else {
-      return [...app, this.stage, ...thisScope];
     }
+    return [...app, this.stage, ...thisScope];
   }
 
   public fail() {
@@ -110,15 +117,18 @@ export class Scope {
   }
 
   public async finalize() {
+    if (this.phase === "read") {
+      return;
+    }
     if (!this.isErrored) {
       // TODO: need to detect if it is in error
       const resourceIds = await this.state.list();
       const aliveIds = new Set(this.resources.keys());
       const orphanIds = Array.from(
-        resourceIds.filter((id) => !aliveIds.has(id))
+        resourceIds.filter((id) => !aliveIds.has(id)),
       );
       const orphans = await Promise.all(
-        orphanIds.map(async (id) => (await this.state.get(id))!.output)
+        orphanIds.map(async (id) => (await this.state.get(id))!.output),
       );
       await destroy.all(orphans, {
         quiet: this.quiet,

package/src/secret.ts

@@ -100,13 +100,12 @@ export namespace secret {
   async function _env(
     name: string,
     value?: string,
-    error?: string
+    error?: string,
   ): Promise<Secret> {
     const result = await alchemy.env(name, value, error);
     if (typeof result === "string") {
       return secret(result);
-    } else {
-      throw new Error(`Secret environment variable ${name} is not a string`);
     }
+    throw new Error(`Secret environment variable ${name} is not a string`);
   }
 }

package/src/serde.ts

@@ -18,11 +18,12 @@ export async function serialize(
   value: any,
   options?: {
     encrypt?: boolean;
-  }
+  },
 ): Promise<any> {
   if (Array.isArray(value)) {
     return Promise.all(value.map((value) => serialize(scope, value, options)));
-  } else if (value instanceof Secret) {
+  }
+  if (value instanceof Secret) {
     if (!scope.password) {
       throw new Error("Cannot serialize secret without password");
     }
@@ -32,26 +33,31 @@ export async function serialize(
           ? await encrypt(value.unencrypted, scope.password)
           : value.unencrypted,
     };
-  } else if (isType(value)) {
+  }
+  if (isType(value)) {
     return {
       "@schema": value.toJSON(),
     };
-  } else if (value instanceof Date) {
+  }
+  if (value instanceof Date) {
     return {
       "@date": value.toISOString(),
     };
-  } else if (value instanceof Scope) {
+  }
+  if (value instanceof Scope) {
     return undefined;
-  } else if (value && typeof value === "object") {
+  }
+  if (value && typeof value === "object") {
     return Object.fromEntries(
       await Promise.all(
         Object.entries(value).map(async ([key, value]) => [
           key,
           await serialize(scope, value, options),
-        ])
-      )
+        ]),
+      ),
     );
-  } else if (typeof value === "function") {
+  }
+  if (typeof value === "function") {
     // can't serialize functions
     return undefined;
   }
@@ -61,28 +67,30 @@ export async function serialize(
 export async function deserialize(scope: Scope, value: any): Promise<any> {
   if (Array.isArray(value)) {
     return await Promise.all(
-      value.map(async (item) => await deserialize(scope, item))
+      value.map(async (item) => await deserialize(scope, item)),
     );
-  } else if (value && typeof value === "object") {
+  }
+  if (value && typeof value === "object") {
     if (typeof value["@secret"] === "string") {
       if (!scope.password) {
         throw new Error("Cannot deserialize secret without password");
       }
       return new Secret(await decryptWithKey(value["@secret"], scope.password));
-    } else if ("@schema" in value) {
+    }
+    if ("@schema" in value) {
       return value["@schema"];
-    } else if ("@date" in value) {
+    }
+    if ("@date" in value) {
       return new Date(value["@date"]);
-    } else {
-      return Object.fromEntries(
-        await Promise.all(
-          Object.entries(value).map(async ([key, value]) => [
-            key,
-            await deserialize(scope, value),
-          ])
-        )
-      );
     }
+    return Object.fromEntries(
+      await Promise.all(
+        Object.entries(value).map(async ([key, value]) => [
+          key,
+          await deserialize(scope, value),
+        ]),
+      ),
+    );
   }
   return value;
 }

package/src/stripe/price.ts

@@ -180,7 +180,7 @@ export const Price = Resource(
   async function (
     this: Context<Price>,
     id: string,
-    props: PriceProps
+    props: PriceProps,
   ): Promise<Price> {
     // Get Stripe API key from context or environment
     const apiKey = process.env.STRIPE_API_KEY;
@@ -203,87 +203,84 @@ export const Price = Resource(
       }
 
       return this.destroy();
-    } else {
-      try {
-        let price: Stripe.Price;
-
-        if (this.phase === "update" && this.output?.id) {
-          // Update existing price (limited properties can be updated)
-          price = await stripe.prices.update(this.output.id, {
-            active: props.active,
-            metadata: props.metadata,
-            nickname: props.nickname,
-          });
-        } else {
-          // Create new price
-          const createParams: Stripe.PriceCreateParams = {
-            currency: props.currency,
-            product: props.product,
-            active: props.active,
-            billing_scheme: props.billingScheme,
-            nickname: props.nickname,
-            metadata: props.metadata,
-            tax_behavior: props.taxBehavior,
-          };
-
-          // Add unit amount fields
-          if (props.unitAmount !== undefined) {
-            createParams.unit_amount = props.unitAmount;
-          } else if (props.unitAmountDecimal !== undefined) {
-            createParams.unit_amount_decimal = props.unitAmountDecimal;
-          }
+    }
+    try {
+      let price: Stripe.Price;
 
-          // Add recurring parameters if present
-          if (props.recurring) {
-            createParams.recurring = {
-              interval: props.recurring.interval,
-              interval_count: props.recurring.intervalCount,
-              usage_type: props.recurring.usageType,
-              aggregate_usage: props.recurring.aggregateUsage,
-            };
-          }
+      if (this.phase === "update" && this.output?.id) {
+        // Update existing price (limited properties can be updated)
+        price = await stripe.prices.update(this.output.id, {
+          active: props.active,
+          metadata: props.metadata,
+          nickname: props.nickname,
+        });
+      } else {
+        // Create new price
+        const createParams: Stripe.PriceCreateParams = {
+          currency: props.currency,
+          product: props.product,
+          active: props.active,
+          billing_scheme: props.billingScheme,
+          nickname: props.nickname,
+          metadata: props.metadata,
+          tax_behavior: props.taxBehavior,
+        };
 
-          price = await stripe.prices.create(createParams);
+        // Add unit amount fields
+        if (props.unitAmount !== undefined) {
+          createParams.unit_amount = props.unitAmount;
+        } else if (props.unitAmountDecimal !== undefined) {
+          createParams.unit_amount_decimal = props.unitAmountDecimal;
         }
 
-        // Transform Stripe recurring object to our format
-        const recurring = price.recurring
-          ? {
-              interval: price.recurring
-                .interval as Stripe.PriceCreateParams.Recurring.Interval,
-              intervalCount: price.recurring.interval_count,
-              usageType: price.recurring
-                .usage_type as Stripe.PriceCreateParams.Recurring.UsageType,
-              aggregateUsage: price.recurring
-                .aggregate_usage as Stripe.PriceCreateParams.Recurring.AggregateUsage,
-            }
-          : undefined;
+        // Add recurring parameters if present
+        if (props.recurring) {
+          createParams.recurring = {
+            interval: props.recurring.interval,
+            interval_count: props.recurring.intervalCount,
+            usage_type: props.recurring.usageType,
+            aggregate_usage: props.recurring.aggregateUsage,
+          };
+        }
 
-        // Map Stripe API response to our output format
-        return this({
-          id: price.id,
-          product:
-            typeof price.product === "string"
-              ? price.product
-              : price.product.id,
-          currency: price.currency,
-          unitAmount: price.unit_amount || undefined,
-          unitAmountDecimal: price.unit_amount_decimal || undefined,
-          active: price.active,
-          billingScheme: price.billing_scheme as BillingScheme,
-          nickname: price.nickname || undefined,
-          recurring: recurring,
-          metadata: price.metadata || undefined,
-          taxBehavior: price.tax_behavior as TaxBehavior,
-          createdAt: price.created,
-          livemode: price.livemode,
-          type: price.type as Stripe.Price.Type,
-          lookupKey: price.lookup_key || undefined,
-        });
-      } catch (error) {
-        console.error("Error creating/updating price:", error);
-        throw error;
+        price = await stripe.prices.create(createParams);
       }
+
+      // Transform Stripe recurring object to our format
+      const recurring = price.recurring
+        ? {
+            interval: price.recurring
+              .interval as Stripe.PriceCreateParams.Recurring.Interval,
+            intervalCount: price.recurring.interval_count,
+            usageType: price.recurring
+              .usage_type as Stripe.PriceCreateParams.Recurring.UsageType,
+            aggregateUsage: price.recurring
+              .aggregate_usage as Stripe.PriceCreateParams.Recurring.AggregateUsage,
+          }
+        : undefined;
+
+      // Map Stripe API response to our output format
+      return this({
+        id: price.id,
+        product:
+          typeof price.product === "string" ? price.product : price.product.id,
+        currency: price.currency,
+        unitAmount: price.unit_amount || undefined,
+        unitAmountDecimal: price.unit_amount_decimal || undefined,
+        active: price.active,
+        billingScheme: price.billing_scheme as BillingScheme,
+        nickname: price.nickname || undefined,
+        recurring: recurring,
+        metadata: price.metadata || undefined,
+        taxBehavior: price.tax_behavior as TaxBehavior,
+        createdAt: price.created,
+        livemode: price.livemode,
+        type: price.type as Stripe.Price.Type,
+        lookupKey: price.lookup_key || undefined,
+      });
+    } catch (error) {
+      console.error("Error creating/updating price:", error);
+      throw error;
     }
-  }
+  },
 );