alchemy 0.1.4 → 0.1.6

package/src/stripe/price.ts

@@ -0,0 +1,244 @@
+import Stripe from "stripe";
+import type { Context } from "../resource";
+import { Resource } from "../resource";
+
+/**
+ * Properties for price recurring configuration
+ */
+export interface PriceRecurring {
+  /**
+   * Specifies billing frequency. Either 'day', 'week', 'month' or 'year'.
+   */
+  interval: Stripe.PriceCreateParams.Recurring.Interval;
+
+  /**
+   * The number of intervals between subscription billings. For example, interval=month and interval_count=3 bills every 3 months.
+   */
+  intervalCount?: number;
+
+  /**
+   * Configures how the quantity per period should be determined, can be either 'metered' or 'licensed'.
+   * 'licensed' will automatically bill the quantity set for a plan when adding it to a subscription,
+   * 'metered' will aggregate the total usage based on usage records.
+   */
+  usageType?: Stripe.PriceCreateParams.Recurring.UsageType;
+
+  /**
+   * Specifies a usage aggregation strategy for prices of `usage_type=metered`. Allowed values are `sum` for summing up all usage during a period,
+   * `last_during_period` for picking the last usage record reported within a period,
+   * `last_ever` for picking the last usage record ever (across period bounds) or `max` which picks the usage record with the maximum reported usage during a period.
+   */
+  aggregateUsage?: Stripe.PriceCreateParams.Recurring.AggregateUsage;
+}
+
+type TaxBehavior = Stripe.PriceCreateParams.TaxBehavior;
+type BillingScheme = Stripe.PriceCreateParams.BillingScheme;
+
+/**
+ * Properties for creating a Stripe price
+ */
+export interface PriceProps {
+  /**
+   * The ID of the product that this price will belong to
+   */
+  product: string;
+
+  /**
+   * Three-letter ISO currency code, in lowercase. Must be a supported currency.
+   */
+  currency: string;
+
+  /**
+   * A positive integer in cents (or local equivalent) representing how much to charge (e.g., 999 for $9.99).
+   * Alternatively, use unit_amount_decimal to specify a precise amount.
+   */
+  unitAmount?: number;
+
+  /**
+   * Same as unit_amount, but accepts a decimal string (e.g., '9.99') with at most 12 decimal places.
+   * Only one of unit_amount and unit_amount_decimal can be set.
+   */
+  unitAmountDecimal?: string;
+
+  /**
+   * Whether the price can be used for new purchases
+   */
+  active?: boolean;
+
+  /**
+   * Describes how to compute the price per period. Either `per_unit` or `tiered`.
+   * `per_unit` indicates that the fixed amount (specified in `unit_amount` or `unit_amount_decimal`)
+   * will be charged per unit in `quantity`.
+   * `tiered` indicates that the unit pricing will be computed using a tiering strategy.
+   */
+  billingScheme?: BillingScheme;
+
+  /**
+   * A brief description of the price, hidden from customers.
+   */
+  nickname?: string;
+
+  /**
+   * The recurring components of a price such as `interval` and `interval_count`.
+   */
+  recurring?: PriceRecurring;
+
+  /**
+   * Set of key-value pairs that you can attach to an object.
+   */
+  metadata?: Record<string, string>;
+
+  /**
+   * Specifies whether the price is considered inclusive of taxes or exclusive of taxes.
+   * One of inclusive, exclusive, or unspecified.
+   */
+  taxBehavior?: TaxBehavior;
+}
+
+/**
+ * Output from the Stripe price
+ */
+export interface PriceOutput extends PriceProps {
+  /**
+   * The ID of the price
+   */
+  id: string;
+
+  /**
+   * Time at which the object was created
+   */
+  createdAt: number;
+
+  /**
+   * Has the value true if the object exists in live mode or the value false if the object exists in test mode
+   */
+  livemode: boolean;
+
+  /**
+   * The type of the price - either 'one_time' or 'recurring'
+   */
+  type: Stripe.Price.Type;
+
+  /**
+   * The lookup key (if any) used by the customer to identify this price object
+   */
+  lookupKey?: string;
+}
+
+export class Price extends Resource(
+  "stripe::Price",
+  async (ctx: Context<PriceOutput>, props: PriceProps) => {
+    // Get Stripe API key from context or environment
+    const apiKey = process.env.STRIPE_API_KEY;
+    if (!apiKey) {
+      throw new Error("STRIPE_API_KEY environment variable is required");
+    }
+
+    // Initialize Stripe client
+    const stripe = new Stripe(apiKey);
+
+    if (ctx.event === "delete") {
+      try {
+        if (ctx.event === "delete" && ctx.output?.id) {
+          // Prices can't be deleted, only deactivated
+          await stripe.prices.update(ctx.output.id, { active: false });
+        }
+      } catch (error) {
+        // Ignore if the price doesn't exist
+        console.error("Error deactivating price:", error);
+      }
+
+      // Return a minimal output for deleted state
+      return {
+        ...props,
+        id: "",
+        createdAt: 0,
+        livemode: false,
+        type: (props.recurring ? "recurring" : "one_time") as Stripe.Price.Type,
+      };
+    } else {
+      try {
+        let price: Stripe.Price;
+
+        if (ctx.event === "update" && ctx.output?.id) {
+          // Update existing price (limited properties can be updated)
+          price = await stripe.prices.update(ctx.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;
+          }
+
+          // 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,
+            };
+          }
+
+          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
+        const output: PriceOutput = {
+          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,
+        };
+
+        return output;
+      } catch (error) {
+        console.error("Error creating/updating price:", error);
+        throw error;
+      }
+    }
+  },
+) {}

package/src/stripe/product.ts

@@ -0,0 +1,193 @@
+import Stripe from "stripe";
+import type { Context } from "../resource";
+import { Resource } from "../resource";
+
+type ProductType = Stripe.Product.Type;
+
+/**
+ * Properties for creating a Stripe product
+ */
+export interface ProductProps {
+  /**
+   * The product's name
+   */
+  name: string;
+
+  /**
+   * The product's description
+   */
+  description?: string;
+
+  /**
+   * Whether the product is active
+   */
+  active?: boolean;
+
+  /**
+   * A list of up to 8 URLs of images for this product
+   */
+  images?: string[];
+
+  /**
+   * A URL of the product's thumbnail
+   */
+  url?: string;
+
+  /**
+   * Whether this product is shipped (physical goods)
+   */
+  shippable?: boolean;
+
+  /**
+   * Product type: good, service
+   */
+  type?: ProductType;
+
+  /**
+   * Unit label to use on invoices
+   */
+  unitLabel?: string;
+
+  /**
+   * A label for the product to be displayed on Checkout
+   */
+  statementDescriptor?: string;
+
+  /**
+   * Set of key-value pairs for this product
+   */
+  metadata?: Record<string, string>;
+
+  /**
+   * Default tax code for the product
+   */
+  taxCode?: string;
+}
+
+/**
+ * Output from the Stripe product
+ */
+export interface ProductOutput extends ProductProps {
+  /**
+   * The ID of the product
+   */
+  id: string;
+
+  /**
+   * Time at which the object was created
+   */
+  createdAt: number;
+
+  /**
+   * Has the value true if the object exists in live mode or the value false if the object exists in test mode
+   */
+  livemode: boolean;
+
+  /**
+   * Time at which the object was last updated
+   */
+  updatedAt: number;
+
+  /**
+   * Whether this product can be used for Checkout/Payment Links
+   */
+  packageDimensions?: {
+    height: number;
+    length: number;
+    weight: number;
+    width: number;
+  };
+}
+
+export class Product extends Resource(
+  "stripe::Product",
+  async (ctx: Context<ProductOutput>, props: ProductProps) => {
+    // Get Stripe API key from context or environment
+    const apiKey = process.env.STRIPE_API_KEY;
+    if (!apiKey) {
+      throw new Error("STRIPE_API_KEY environment variable is required");
+    }
+
+    // Initialize Stripe client
+    const stripe = new Stripe(apiKey);
+
+    if (ctx.event === "delete") {
+      try {
+        if (ctx.event === "delete" && ctx.output?.id) {
+          await stripe.products.update(ctx.output.id, { active: false });
+        }
+      } catch (error) {
+        // Ignore if the product doesn't exist
+        console.error("Error deactivating product:", error);
+      }
+
+      // Return a minimal output for deleted state
+      return {
+        ...props,
+        id: "",
+        createdAt: 0,
+        updatedAt: 0,
+        livemode: false,
+      };
+    } else {
+      try {
+        let product: Stripe.Product;
+
+        if (ctx.event === "update" && ctx.output?.id) {
+          // Update existing product
+          product = await stripe.products.update(ctx.output.id, {
+            name: props.name,
+            description: props.description,
+            active: props.active,
+            images: props.images,
+            url: props.url,
+            statement_descriptor: props.statementDescriptor,
+            metadata: props.metadata,
+            tax_code: props.taxCode,
+          });
+        } else {
+          // Create new product
+          product = await stripe.products.create({
+            name: props.name,
+            description: props.description,
+            active: props.active,
+            images: props.images,
+            url: props.url,
+            shippable: props.shippable,
+            type: props.type as Stripe.ProductCreateParams.Type,
+            unit_label: props.unitLabel,
+            statement_descriptor: props.statementDescriptor,
+            metadata: props.metadata,
+            tax_code: props.taxCode,
+          });
+        }
+
+        // Map Stripe API response to our output format
+        const output: ProductOutput = {
+          id: product.id,
+          name: product.name,
+          description: product.description || undefined,
+          active: product.active,
+          images: product.images || undefined,
+          url: product.url || undefined,
+          shippable: product.shippable || undefined,
+          type: product.type as ProductType,
+          unitLabel: product.unit_label || undefined,
+          statementDescriptor: product.statement_descriptor || undefined,
+          metadata: product.metadata || undefined,
+          taxCode:
+            typeof product.tax_code === "string" ? product.tax_code : undefined,
+          createdAt: product.created,
+          livemode: product.livemode,
+          updatedAt: product.updated,
+          packageDimensions: product.package_dimensions || undefined,
+        };
+
+        return output;
+      } catch (error) {
+        console.error("Error creating/updating product:", error);
+        throw error;
+      }
+    }
+  },
+) {}

package/src/stripe/webhook.ts

@@ -0,0 +1,184 @@
+import Stripe from "stripe";
+import type { Context } from "../resource";
+import { Resource } from "../resource";
+
+export type EnabledEvent = Stripe.WebhookEndpointUpdateParams.EnabledEvent;
+
+/**
+ * Properties for creating a Stripe webhook endpoint
+ */
+export interface WebhookEndpointProps {
+  /**
+   * The URL of the webhook endpoint
+   */
+  url: string;
+
+  /**
+   * The list of events to enable for this endpoint
+   */
+  enabledEvents: EnabledEvent[];
+
+  /**
+   * Description of the webhook
+   */
+  description?: string;
+
+  /**
+   * Whether the webhook is active
+   */
+  active?: boolean;
+
+  /**
+   * The API version events are rendered as for this webhook
+   */
+  apiVersion?: string;
+
+  /**
+   * Whether to include mounted endpoint events automatically
+   */
+  connect?: boolean;
+
+  /**
+   * Webhook endpoint metadata
+   */
+  metadata?: Record<string, string>;
+}
+
+/**
+ * Output from the Stripe webhook endpoint
+ */
+export interface WebhookEndpointOutput extends WebhookEndpointProps {
+  /**
+   * The ID of the webhook
+   */
+  id: string;
+
+  /**
+   * The webhook endpoint's secret key, used to verify signatures on received events
+   */
+  secret: string;
+
+  /**
+   * The webhook endpoint's application
+   */
+  application?: string;
+
+  /**
+   * Time at which the object was created
+   */
+  createdAt: number;
+
+  /**
+   * Has the value true if the object exists in live mode or the value false if the object exists in test mode
+   */
+  livemode: boolean;
+
+  /**
+   * Time at which the object was last updated
+   */
+  updatedAt: number;
+
+  /**
+   * The status of the webhook
+   */
+  status: string;
+}
+
+export class WebhookEndpoint extends Resource(
+  "stripe::WebhookEndpoint",
+  async (ctx: Context<WebhookEndpointOutput>, props: WebhookEndpointProps) => {
+    // Get Stripe API key from context or environment
+    const apiKey = process.env.STRIPE_API_KEY;
+    if (!apiKey) {
+      throw new Error("STRIPE_API_KEY environment variable is required");
+    }
+
+    // Initialize Stripe client
+    const stripe = new Stripe(apiKey);
+
+    if (ctx.event === "delete") {
+      try {
+        // Get the webhook ID from the stored output
+        if (ctx.event === "delete" && ctx.output?.id) {
+          await stripe.webhookEndpoints.del(ctx.output.id);
+        }
+      } catch (error) {
+        // Ignore if the webhook doesn't exist
+        console.error("Error deleting webhook:", error);
+      }
+
+      // Return a minimal output for deleted state
+      return {
+        ...props,
+        id: "",
+        secret: "",
+        createdAt: 0,
+        updatedAt: 0,
+        livemode: false,
+        status: "deleted",
+      };
+    } else {
+      try {
+        let webhook: Stripe.WebhookEndpoint;
+
+        if (ctx.event === "update" && ctx.output?.id) {
+          // Update existing webhook
+          webhook = await stripe.webhookEndpoints.update(ctx.output.id, {
+            url: props.url,
+            enabled_events: props.enabledEvents,
+            description: props.description,
+            disabled: props.active === false,
+            metadata: props.metadata,
+          });
+        } else {
+          // Create new webhook
+          webhook = await stripe.webhookEndpoints.create({
+            url: props.url,
+            enabled_events: props.enabledEvents,
+            description: props.description,
+            metadata: props.metadata,
+          });
+
+          // For connect parameter, need to handle it separately if it exists
+          if (props.connect !== undefined) {
+            // Note: connect is specified at creation time and cannot be updated
+            console.log(
+              "Note: 'connect' parameter will be applied at creation time only",
+            );
+          }
+        }
+
+        // Store the secret if available
+        let secret = "";
+        if (webhook.secret) {
+          secret = webhook.secret;
+        } else if (ctx.event === "update" && ctx.output?.secret) {
+          secret = ctx.output.secret;
+        }
+
+        // Map Stripe API response to our output format
+        const output: WebhookEndpointOutput = {
+          id: webhook.id,
+          url: webhook.url,
+          enabledEvents: webhook.enabled_events as EnabledEvent[],
+          description: webhook.description || undefined,
+          active: webhook.status === "enabled",
+          apiVersion: webhook.api_version || undefined,
+          // connect: !!webhook.connect,
+          metadata: webhook.metadata || undefined,
+          secret: secret,
+          application: webhook.application || undefined,
+          createdAt: webhook.created,
+          livemode: webhook.livemode,
+          updatedAt: webhook.created, // Using created timestamp as updated
+          status: webhook.status,
+        };
+
+        return output;
+      } catch (error) {
+        console.error("Error creating/updating webhook:", error);
+        throw error;
+      }
+    }
+  },
+) {}

package/src/typescript/install-dependencies.ts

@@ -0,0 +1,61 @@
+import { tool } from "ai";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { z } from "zod";
+
+const execAsync = promisify(exec);
+
+export const installDependencies = tool({
+  description:
+    "Installs dependencies using bun with support for different dependency types (runtime, dev, or peer)",
+  parameters: z.object({
+    packages: z.array(z.string()).describe("Array of package names to install"),
+    type: z
+      .enum(["runtime", "dev", "peer"])
+      .optional()
+      .describe(
+        "Type of dependency to install: runtime, dev, or peer. Default 'runtime'.",
+      ),
+  }),
+  execute: async ({ packages, type }) => {
+    if (packages.length === 0) {
+      throw new Error("No packages specified for installation");
+    }
+
+    let command = "bun add";
+
+    // Add appropriate flags based on dependency type
+    switch (type) {
+      case "dev":
+        command += " -D";
+        break;
+      case "peer":
+        command += " --peer";
+        break;
+      // runtime dependencies don't need a special flag
+    }
+
+    // Add packages to the command
+    command += " " + packages.join(" ");
+
+    try {
+      console.log(`Executing: ${command}`);
+      const { stdout, stderr } = await execAsync(command);
+
+      if (stderr) {
+        console.warn("Installation warnings:", stderr);
+      }
+
+      return {
+        success: true,
+        command,
+        output: stdout,
+        packages,
+        type,
+      };
+    } catch (error: any) {
+      console.error("Installation failed:", error);
+      throw new Error(`Failed to install packages: ${error.message}`);
+    }
+  },
+});

package/test/aws/function.test.ts

@@ -7,11 +7,11 @@ import {
 import { describe, expect, test } from "bun:test";
 import path from "node:path";
 import { apply } from "../../src/apply";
-import { Function } from "../../src/components/aws/function";
-import type { PolicyDocument } from "../../src/components/aws/policy";
-import { Role } from "../../src/components/aws/role";
-import { Bundle } from "../../src/components/esbuild";
+import { Function } from "../../src/aws/function";
+import type { PolicyDocument } from "../../src/aws/policy";
+import { Role } from "../../src/aws/role";
 import { destroy } from "../../src/destroy";
+import { Bundle } from "../../src/esbuild";
 
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 

package/test/aws/queue.test.ts

@@ -5,7 +5,7 @@ import {
 } from "@aws-sdk/client-sqs";
 import { describe, expect, test } from "bun:test";
 import { apply } from "../../src/apply";
-import { Queue } from "../../src/components/aws/queue";
+import { Queue } from "../../src/aws/queue";
 import { destroy } from "../../src/destroy";
 
 const sqs = new SQSClient({});