alchemy 0.62.2 → 0.63.0

package/src/sentry/client-key.ts

@@ -10,6 +10,8 @@ import { SentryApi } from "./api.ts";
 export interface ClientKeyProps {
   /**
    * The name of the key
+   *
+   * @default ${app}-${stage}-${id}
    */
   name?: string;
 
@@ -68,6 +70,11 @@ export interface ClientKey
    */
   id: string;
 
+  /**
+   * Name of the Client Key.
+   */
+  name: string;
+
   /**
    * The label of the key
    */
@@ -180,11 +187,45 @@ export const ClientKey = Resource(
   "sentry::ClientKey",
   async function (
     this: Context<ClientKey>,
-    _id: string,
+    id: string,
     props: ClientKeyProps,
   ): Promise<ClientKey> {
     const api = new SentryApi({ authToken: props.authToken });
 
+    // it's possible that `this.output.name` is undefined because a previous version
+    // of alchemy had a bug where it didn't set the name on the output
+    // so, we try to find the key by ID and use the name from the API response
+    const lookupName = async () => {
+      if (!this.output?.id) {
+        // not running in the update phase
+        return undefined;
+      } else if (this.output.name) {
+        return this.output.name;
+      }
+      const name = (
+        await getClientKeyName(api, {
+          organization: props.organization,
+          project: props.project,
+          keyId: this.output.id,
+        })
+      )?.name;
+
+      if (name) {
+        this.output.name = name;
+      }
+
+      return name;
+    };
+
+    const clientKeyName =
+      props.name ?? (await lookupName()) ?? this.scope.createPhysicalName(id);
+
+    if (this.phase === "update") {
+      if (this.output.name !== clientKeyName) {
+        this.replace();
+      }
+    }
+
     if (this.phase === "delete") {
       try {
         if (this.output?.id) {
@@ -217,24 +258,24 @@ export const ClientKey = Resource(
           } catch (error) {
             // Check if this is a "key already exists" error and adopt is enabled
             if (
-              props.adopt &&
+              (props.adopt ?? this.scope.adopt) &&
               error instanceof Error &&
               error.message.includes("already exists") &&
-              props.name
+              clientKeyName
             ) {
               logger.log(
-                `Client key '${props.name}' already exists, adopting it`,
+                `Client key '${clientKeyName}' already exists, adopting it`,
               );
               // Find the existing key by name
               const existingKey = await findClientKeyByName(
                 api,
                 props.organization,
                 props.project,
-                props.name,
+                clientKeyName,
               );
               if (!existingKey) {
                 throw new Error(
-                  `Failed to find existing client key '${props.name}' for adoption`,
+                  `Failed to find existing client key '${clientKeyName}' for adoption`,
                 );
               }
               response = await api.get(
@@ -257,6 +298,7 @@ export const ClientKey = Resource(
         return this({
           ...props,
           id: data.id,
+          name: clientKeyName,
           label: data.label,
           public: data.public,
           secret: data.secret,
@@ -294,3 +336,29 @@ async function findClientKeyByName(
   const key = keys.find((k) => k.name === name);
   return key ? { id: key.id } : null;
 }
+
+/**
+ * Find a client key by ID
+ */
+async function getClientKeyName(
+  api: SentryApi,
+  {
+    organization,
+    project,
+    keyId,
+  }: {
+    organization: string;
+    project: string;
+    keyId: string;
+  },
+): Promise<{ id: string; name: string } | null> {
+  const response = await api.get(
+    `/projects/${organization}/${project}/keys/${keyId}`,
+  );
+  if (!response.ok) {
+    throw new Error(`API error: ${response.statusText}`);
+  }
+
+  const key = (await response.json()) as { id: string; name: string };
+  return key ? { id: key.id, name: key.name } : null;
+}

package/src/sentry/project.ts

@@ -10,8 +10,10 @@ import { SentryApi } from "./api.ts";
 export interface ProjectProps {
   /**
    * The name for the project
+   *
+   * @default ${app}-${stage}-${id}
    */
-  name: string;
+  name?: string;
 
   /**
    * Uniquely identifies a project and is used for the interface
@@ -63,6 +65,11 @@ export interface Project
    */
   id: string;
 
+  /**
+   * The name for the project
+   */
+  name: string;
+
   /**
    * The team that owns the project
    */
@@ -282,11 +289,43 @@ export const Project = Resource(
   "sentry::Project",
   async function (
     this: Context<Project>,
-    _id: string,
+    id: string,
     props: ProjectProps,
   ): Promise<Project> {
     const api = new SentryApi({ authToken: props.authToken });
 
+    // it's possible that `this.output.name` is undefined because a previous version
+    // of alchemy had a bug where it didn't set the name on the output
+    // so, we try to find the key by ID and use the name from the API response
+    const lookupName = async () => {
+      if (!this.output) {
+        return undefined;
+      } else if (this.output.name) {
+        return this.output.name;
+      }
+      const name = await getProjectName(
+        api,
+        props.organization,
+        this.output.id,
+      );
+      if (name) {
+        this.output.name = name;
+      }
+      return name;
+    };
+
+    const projectName =
+      props.name ?? (await lookupName()) ?? this.scope.createPhysicalName(id);
+
+    if (this.phase === "update" && this.output.name !== projectName) {
+      await api.put(
+        `/projects/${props.organization}/${this.output.slug || this.output.id}/`,
+        {
+          name: projectName,
+        },
+      );
+    }
+
     if (this.phase === "delete") {
       try {
         if (this.output?.id) {
@@ -319,22 +358,22 @@ export const Project = Resource(
           } catch (error) {
             // Check if this is a "project already exists" error and adopt is enabled
             if (
-              props.adopt &&
+              (props.adopt ?? this.scope.adopt) &&
               error instanceof Error &&
               error.message.includes("already exists")
             ) {
               logger.log(
-                `Project '${props.slug || props.name}' already exists, adopting it`,
+                `Project '${props.slug || projectName}' already exists, adopting it`,
               );
               // Find the existing project by slug
               const existingProject = await findProjectBySlug(
                 api,
                 props.organization,
-                props.slug || props.name,
+                props.slug || projectName,
               );
               if (!existingProject) {
                 throw new Error(
-                  `Failed to find existing project '${props.slug || props.name}' for adoption`,
+                  `Failed to find existing project '${props.slug || projectName}' for adoption`,
                 );
               }
               response = await api.get(
@@ -357,6 +396,7 @@ export const Project = Resource(
         return this({
           ...props,
           id: data.id,
+          name: projectName,
           team: data.team,
           teams: data.teams,
           isBookmarked: data.isBookmarked,
@@ -419,3 +459,16 @@ async function findProjectBySlug(
   const project = projects.find((p) => p.slug === slug);
   return project ? { id: project.id, slug: project.slug } : null;
 }
+
+async function getProjectName(
+  api: SentryApi,
+  organization: string,
+  slug: string,
+): Promise<string | undefined> {
+  const response = await api.get(`/projects/${organization}/${slug}/`);
+  if (!response.ok) {
+    throw new Error(`API error: ${response.statusText}`);
+  }
+
+  return ((await response.json()) as { name: string }).name;
+}

package/src/sentry/team.ts

@@ -10,8 +10,10 @@ import { SentryApi } from "./api.ts";
 export interface TeamProps {
   /**
    * The name for the team
+   *
+   * @default ${app}-${stage}-${id}
    */
-  name: string;
+  name?: string;
 
   /**
    * Uniquely identifies a team and is used for the interface
@@ -46,6 +48,11 @@ export interface Team extends Resource<"sentry::Team">, TeamProps {
    */
   id: string;
 
+  /**
+   * Name of the Team.
+   */
+  name: string;
+
   /**
    * Time at which the team was created
    */
@@ -127,11 +134,36 @@ export const Team = Resource(
   "sentry::Team",
   async function (
     this: Context<Team>,
-    _id: string,
+    id: string,
     props: TeamProps,
   ): Promise<Team> {
     const api = new SentryApi({ authToken: props.authToken });
 
+    // it's possible that `this.output.name` is undefined because a previous version
+    // of alchemy had a bug where it didn't set the name on the output
+    // so, we try to find the key by ID and use the name from the API response
+    const lookupName = async () => {
+      if (!this.output) {
+        return undefined;
+      } else if (this.output?.name) {
+        return this.output.name;
+      }
+      const name = await getTeamName(api, props.organization, this.output.id);
+      if (name) {
+        this.output.name = name;
+      }
+      return name;
+    };
+
+    const teamName =
+      props.name ?? (await lookupName()) ?? this.scope.createPhysicalName(id);
+
+    if (this.phase === "update" && this.output.name !== teamName) {
+      // TODO(sam): can we rename without destroying?
+      // -> no: https://docs.sentry.io/api/teams/update-a-team/
+      this.replace();
+    }
+
     if (this.phase === "delete") {
       try {
         if (this.output?.id) {
@@ -164,22 +196,22 @@ export const Team = Resource(
           } catch (error) {
             // Check if this is a "team already exists" error and adopt is enabled
             if (
-              props.adopt &&
+              (props.adopt ?? this.scope.adopt) &&
               error instanceof Error &&
               error.message.includes("already exists")
             ) {
               logger.log(
-                `Team '${props.slug || props.name}' already exists, adopting it`,
+                `Team '${props.slug || teamName}' already exists, adopting it`,
               );
               // Find the existing team by slug
               const existingTeam = await findTeamBySlug(
                 api,
                 props.organization,
-                props.slug || props.name,
+                props.slug || teamName,
               );
               if (!existingTeam) {
                 throw new Error(
-                  `Failed to find existing team '${props.slug || props.name}' for adoption`,
+                  `Failed to find existing team '${props.slug || teamName}' for adoption`,
                 );
               }
               response = await api.get(
@@ -192,13 +224,16 @@ export const Team = Resource(
         }
 
         if (!response.ok) {
-          throw new Error(`API error: ${response.statusText}`);
+          throw new Error(
+            `API error: ${response.statusText} ${await response.text()}`,
+          );
         }
 
         const data = (await response.json()) as Omit<Team, keyof TeamProps>;
         return this({
           ...props,
           id: data.id,
+          name: teamName,
           dateCreated: data.dateCreated,
           isMember: data.isMember,
           teamRole: data.teamRole,
@@ -234,3 +269,16 @@ async function findTeamBySlug(
   const team = teams.find((t) => t.slug === slug);
   return team ? { id: team.id, slug: team.slug } : null;
 }
+
+async function getTeamName(
+  api: SentryApi,
+  organization: string,
+  slug: string,
+): Promise<string | undefined> {
+  const response = await api.get(`/teams/${organization}/${slug}/`);
+  if (!response.ok) {
+    throw new Error(`API error: ${response.statusText}`);
+  }
+
+  return ((await response.json()) as { name: string }).name;
+}

package/src/serde.ts

@@ -1,10 +1,4 @@
 import { decryptWithKey, encrypt } from "./encrypt.ts";
-import {
-  InnerResourceScope,
-  ResourceFQN,
-  ResourceKind,
-  type Resource,
-} from "./resource.ts";
 import { isScope, type Scope } from "./scope.ts";
 import { isSecret, Secret } from "./secret.ts";
 
@@ -65,44 +59,6 @@ export type Serialized<T> = T extends
                       }
                     : T;
 
-export type SerializedScope = {
-  [fqn: ResourceFQN]: Serialized<Resource>;
-};
-
-export async function serializeScope(scope: Scope): Promise<SerializedScope> {
-  const map: SerializedScope = {};
-
-  return serializeScope(scope);
-
-  async function serializeScope(scope: Scope): Promise<SerializedScope> {
-    await Promise.all(
-      Array.from(scope.resources.values()).map(async (resource) => {
-        if (resource[ResourceKind] === "alchemy::Scope") {
-          return;
-        }
-        map[resource[ResourceFQN]] = await serialize(scope, await resource, {
-          transform: (value) => {
-            if (isSecret(value)) {
-              return {
-                "@secret-env": value.name,
-              };
-            }
-            return value;
-          },
-        });
-        const innerScope = await resource[InnerResourceScope];
-        if (innerScope) {
-          await serializeScope(innerScope);
-        }
-      }),
-    );
-    await Promise.all(
-      Array.from(scope.children.values()).map((scope) => serializeScope(scope)),
-    );
-    return map;
-  }
-}
-
 export async function serialize(
   scope: Scope,
   value: any,

package/src/state/d1-state-store.ts

@@ -1,13 +1,16 @@
-import { drizzle, type RemoteCallback } from "drizzle-orm/sqlite-proxy";
+import type { RemoteCallback } from "drizzle-orm/sqlite-proxy";
 import assert from "node:assert";
 import { extractCloudflareResult } from "../cloudflare/api-response.ts";
-import type { CloudflareApi, CloudflareApiOptions } from "../cloudflare/api.ts";
+import {
+  createCloudflareApi,
+  type CloudflareApi,
+  type CloudflareApiOptions,
+} from "../cloudflare/api.ts";
 import type { Scope } from "../scope.ts";
 import { memoize } from "../util/memoize.ts";
+import { importPeer } from "../util/peer.ts";
 import { MIGRATIONS_DIRECTORY } from "./migrations.ts";
-import { SQLiteStateStoreOperations } from "./operations.ts";
 import { StateStoreProxy } from "./proxy.ts";
-import * as schema from "./schema.ts";
 
 export interface D1StateStoreOptions extends CloudflareApiOptions {
   databaseName?: string;
@@ -26,6 +29,7 @@ export class D1StateStore extends StateStoreProxy {
 
   async provision(): Promise<StateStoreProxy.Dispatch> {
     const db = await createDatabaseClient(this.options);
+    const { SQLiteStateStoreOperations } = await import("./operations.js");
     const operations = new SQLiteStateStoreOperations(db, {
       chain: this.scope.chain,
     });
@@ -34,7 +38,10 @@ export class D1StateStore extends StateStoreProxy {
 }
 
 const createDatabaseClient = memoize(async (options: D1StateStoreOptions) => {
-  const { createCloudflareApi } = await import("../cloudflare/api.ts");
+  const { drizzle } = await importPeer(
+    import("drizzle-orm/sqlite-proxy"),
+    "D1StateStore",
+  );
   const api = await createCloudflareApi(options);
   const database = await upsertDatabase(
     api,
@@ -63,7 +70,7 @@ const createDatabaseClient = memoize(async (options: D1StateStoreOptions) => {
     };
   };
   return drizzle(remoteCallback, {
-    schema,
+    schema: await import("./schema.js"),
   });
 });
 

package/src/state/sqlite-state-store.ts

@@ -3,10 +3,9 @@ import fs from "node:fs";
 import path from "node:path";
 import type { Scope } from "../scope.ts";
 import { memoize } from "../util/memoize.ts";
+import { importPeer } from "../util/peer.ts";
 import { MIGRATIONS_DIRECTORY } from "./migrations.ts";
-import { SQLiteStateStoreOperations } from "./operations.ts";
 import { StateStoreProxy } from "./proxy.ts";
-import * as schema from "./schema.ts";
 
 interface BunSQLiteStateStoreOptions {
   /**
@@ -82,6 +81,7 @@ export class SQLiteStateStore extends StateStoreProxy {
 
   async provision(): Promise<StateStoreProxy.Dispatch> {
     const db = await createDatabase(this.options);
+    const { SQLiteStateStoreOperations } = await import("./operations.js");
     const operations = new SQLiteStateStoreOperations(db, {
       chain: this.scope.chain,
     });
@@ -125,12 +125,12 @@ async function createBunSQLiteDatabase(
     ".alchemy/state.sqlite";
   ensureDirectory(filename);
   const { Database } = await import("bun:sqlite");
-  const { drizzle } = await import("drizzle-orm/bun-sqlite").catch(() => {
-    throw new Error(
-      "[SQLiteStateStore] Missing `drizzle-orm` peer dependency. Please `bun install drizzle-orm`.",
-    );
-  });
+  const { drizzle } = await importPeer(
+    import("drizzle-orm/bun-sqlite"),
+    "SQLiteStateStore",
+  );
   const { migrate } = await import("drizzle-orm/bun-sqlite/migrator");
+  const schema = await import("./schema.js");
   // Bun's constructor throws if we pass in an empty object or if extraneous
   // options are passed in, so here's some ugly destructuring!
   const { engine: _engine, filename: _filename, ...rest } = options ?? {};
@@ -154,17 +154,16 @@ async function createLibSQLDatabase(
   if (filename) {
     ensureDirectory(filename);
   }
-  const { createClient } = await import("@libsql/client").catch(() => {
-    throw new Error(
-      "[SQLiteStateStore] Missing `@libsql/client` peer dependency. Please `npm install @libsql/client`.",
-    );
-  });
-  const { drizzle } = await import("drizzle-orm/libsql").catch(() => {
-    throw new Error(
-      "[SQLiteStateStore] Missing `drizzle-orm` peer dependency. Please `npm install drizzle-orm`.",
-    );
-  });
+  const { drizzle } = await importPeer(
+    import("drizzle-orm/libsql"),
+    "SQLiteStateStore",
+  );
+  const { createClient } = await importPeer(
+    import("@libsql/client"),
+    "SQLiteStateStore (libsql)",
+  );
   const { migrate } = await import("drizzle-orm/libsql/migrator");
+  const schema = await import("./schema.js");
   const client = createClient({ url, ...options });
   await client.execute("PRAGMA journal_mode = WAL;");
   const db = drizzle(client, {

package/src/stripe/card.ts

@@ -209,7 +209,7 @@ export const Card = Resource(
     _id: string,
     props: CardProps,
   ): Promise<Card> {
-    const stripe = createStripeClient({ apiKey: props.apiKey });
+    const stripe = await createStripeClient({ apiKey: props.apiKey });
 
     if (this.phase === "delete") {
       try {
@@ -279,7 +279,10 @@ export const Card = Resource(
             createParams,
           )) as Stripe.Card;
         } catch (error) {
-          if (isStripeConflictError(error) && props.adopt) {
+          if (
+            isStripeConflictError(error) &&
+            (props.adopt ?? this.scope.adopt)
+          ) {
             throw new Error(
               "Card adoption is not supported - cards cannot be uniquely identified for adoption",
             );

package/src/stripe/client.ts

@@ -1,13 +1,20 @@
-import Stripe from "stripe";
+import type Stripe from "stripe";
 import type { Secret } from "../secret.ts";
-import { withExponentialBackoff } from "../util/retry.ts";
 import { logger } from "../util/logger.ts";
+import { importPeer } from "../util/peer.ts";
+import { withExponentialBackoff } from "../util/retry.ts";
 
 export interface StripeClientOptions {
   apiKey?: Secret | string;
 }
 
-export function createStripeClient(options: StripeClientOptions = {}): Stripe {
+export async function createStripeClient(
+  options: StripeClientOptions = {},
+): Promise<Stripe> {
+  const { default: Stripe } = await importPeer(
+    import("stripe"),
+    "Stripe resources",
+  );
   let apiKey: string;
 
   if (options.apiKey) {

package/src/stripe/coupon.ts

@@ -163,7 +163,8 @@ export const Coupon = Resource(
     _id: string,
     props: CouponProps,
   ): Promise<Coupon> {
-    const stripe = createStripeClient({ apiKey: props.apiKey });
+    const adopt = props.adopt ?? this.scope.adopt;
+    const stripe = await createStripeClient({ apiKey: props.apiKey });
 
     if (this.phase === "delete") {
       try {
@@ -217,7 +218,7 @@ export const Coupon = Resource(
           try {
             coupon = await stripe.coupons.create(createParams);
           } catch (error) {
-            if (isStripeConflictError(error) && props.adopt) {
+            if (isStripeConflictError(error) && adopt) {
               if (props.id) {
                 const existingCoupon = await stripe.coupons.retrieve(props.id);
                 const updateParams: Stripe.CouponUpdateParams = {
@@ -236,7 +237,7 @@ export const Coupon = Resource(
             }
           }
         } catch (error) {
-          if (isStripeConflictError(error) && props.adopt) {
+          if (isStripeConflictError(error) && adopt) {
             if (props.id) {
               const existingCoupon = await stripe.coupons.retrieve(props.id);
               const updateParams: Stripe.CouponUpdateParams = {

package/src/stripe/customer.ts

@@ -282,7 +282,7 @@ export const Customer = Resource(
     _id: string,
     props: CustomerProps,
   ): Promise<Customer> {
-    const stripe = createStripeClient({ apiKey: props.apiKey });
+    const stripe = await createStripeClient({ apiKey: props.apiKey });
 
     if (this.phase === "delete") {
       try {
@@ -385,7 +385,7 @@ export const Customer = Resource(
           };
         }
 
-        if (props.adopt && props.email) {
+        if ((props.adopt ?? this.scope.adopt) && props.email) {
           const existingCustomers = await stripe.customers.list({
             email: props.email,
             limit: 1,

package/src/stripe/entitlements-feature.ts

@@ -101,7 +101,7 @@ export const EntitlementsFeature = Resource(
     _id: string,
     props: EntitlementsFeatureProps,
   ): Promise<EntitlementsFeature> {
-    const stripe = createStripeClient({ apiKey: props.apiKey });
+    const stripe = await createStripeClient({ apiKey: props.apiKey });
 
     if (this.phase === "delete") {
       return this.destroy();
@@ -130,7 +130,10 @@ export const EntitlementsFeature = Resource(
         try {
           feature = await stripe.entitlements.features.create(createParams);
         } catch (error) {
-          if (isStripeConflictError(error) && props.adopt) {
+          if (
+            isStripeConflictError(error) &&
+            (props.adopt ?? this.scope.adopt)
+          ) {
             const existingFeatures = await stripe.entitlements.features.list({
               lookup_key: props.lookupKey,
               limit: 1,

package/src/stripe/file.ts

@@ -153,7 +153,8 @@ export const File = Resource(
     _id: string,
     props: FileProps,
   ): Promise<File> {
-    const stripe = createStripeClient({ apiKey: props.apiKey });
+    const adopt = props.adopt ?? this.scope.adopt;
+    const stripe = await createStripeClient({ apiKey: props.apiKey });
 
     if (this.phase === "delete") {
       return this.destroy();
@@ -171,7 +172,7 @@ export const File = Resource(
             purpose: props.purpose,
           });
         } catch (error) {
-          if (isStripeConflictError(error) && props.adopt) {
+          if (isStripeConflictError(error) && adopt) {
             throw new Error(
               "File adoption is not supported - files are immutable and cannot be adopted",
             );