alchemy 0.62.3 → 0.63.0

package/src/planetscale/database.ts

@@ -14,8 +14,10 @@ import {
 export interface DatabaseProps {
   /**
    * The name of the database
+   *
+   * @default ${app}-${stage}-${id}
    */
-  name: string;
+  name?: string;
 
   /**
    * The organization ID where the database will be created
@@ -104,6 +106,11 @@ export interface Database
    */
   id: string;
 
+  /**
+   * The name of the database
+   */
+  name: string;
+
   /**
    * The current state of the database
    */
@@ -173,9 +180,10 @@ export const Database = Resource(
   "planetscale::Database",
   async function (
     this: Context<Database>,
-    _id: string,
+    id: string,
     props: DatabaseProps,
   ): Promise<Database> {
+    const adopt = props.adopt ?? this.scope.adopt;
     const apiKey =
       props.apiKey?.unencrypted || process.env.PLANETSCALE_API_TOKEN;
     if (!apiKey) {
@@ -184,6 +192,16 @@ export const Database = Resource(
 
     const api = new PlanetScaleApi({ apiKey });
 
+    const databaseName =
+      props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+
+    if (this.phase === "update" && this.output.name !== databaseName) {
+      await api.patch(
+        `/organizations/${props.organizationId}/databases/${this.output.name}`,
+        { new_name: databaseName },
+      );
+    }
+
     if (this.phase === "delete") {
       try {
         if (this.output?.name) {
@@ -207,26 +225,26 @@ export const Database = Resource(
     try {
       // Check if database exists
       const getResponse = await api.get(
-        `/organizations/${props.organizationId}/databases/${props.name}`,
+        `/organizations/${props.organizationId}/databases/${databaseName}`,
       );
       const getData = await getResponse.json<any>();
-      if (this.phase === "update" || (props.adopt && getResponse.ok)) {
+      if (this.phase === "update" || (adopt && getResponse.ok)) {
         if (!getResponse.ok) {
-          throw new Error(`Database ${props.name} not found`);
+          throw new Error(`Database ${databaseName} not found`);
         }
         // Update database settings
         // If updating to a non-'main' default branch, create it first
         if (props.defaultBranch && props.defaultBranch !== "main") {
           const branchResponse = await api.get(
-            `/organizations/${props.organizationId}/databases/${props.name}/branches/${props.defaultBranch}`,
+            `/organizations/${props.organizationId}/databases/${databaseName}/branches/${props.defaultBranch}`,
           );
           if (!getData.ready) {
-            await waitForDatabaseReady(api, props.organizationId, props.name);
+            await waitForDatabaseReady(api, props.organizationId, databaseName);
           }
           if (!branchResponse.ok && branchResponse.status === 404) {
             // Create the branch
             const createBranchResponse = await api.post(
-              `/organizations/${props.organizationId}/databases/${props.name}/branches`,
+              `/organizations/${props.organizationId}/databases/${databaseName}/branches`,
               {
                 name: props.defaultBranch,
                 parent_branch: "main",
@@ -242,7 +260,7 @@ export const Database = Resource(
         }
 
         const updateResponse = await api.patch(
-          `/organizations/${props.organizationId}/databases/${props.name}`,
+          `/organizations/${props.organizationId}/databases/${databaseName}`,
           {
             automatic_migrations: props.automaticMigrations,
             migration_framework: props.migrationFramework,
@@ -265,7 +283,7 @@ export const Database = Resource(
         await fixClusterSize(
           api,
           props.organizationId,
-          props.name,
+          databaseName,
           props.defaultBranch || "main",
           props.clusterSize,
           getData.ready,
@@ -275,6 +293,7 @@ export const Database = Resource(
         return this({
           ...props,
           id: data.id,
+          name: databaseName,
           state: data.state,
           defaultBranch: data.default_branch,
           plan: data.plan,
@@ -285,14 +304,14 @@ export const Database = Resource(
       }
 
       if (getResponse.ok) {
-        throw new Error(`Database with name ${props.name} already exists`);
+        throw new Error(`Database with name ${databaseName} already exists`);
       }
 
       // Create new database
       const createResponse = await api.post(
         `/organizations/${props.organizationId}/databases`,
         {
-          name: props.name,
+          name: databaseName,
           region_slug: props.region?.slug,
           require_approval_for_deploy: props.requireApprovalForDeploy,
           allow_data_branching: props.allowDataBranching,
@@ -316,17 +335,17 @@ export const Database = Resource(
 
       // If a non-'main' default branch is specified, create it
       if (props.defaultBranch && props.defaultBranch !== "main") {
-        await waitForDatabaseReady(api, props.organizationId, props.name);
+        await waitForDatabaseReady(api, props.organizationId, databaseName);
 
         // Check if branch exists
         const branchResponse = await api.get(
-          `/organizations/${props.organizationId}/databases/${props.name}/branches/${props.defaultBranch}`,
+          `/organizations/${props.organizationId}/databases/${databaseName}/branches/${props.defaultBranch}`,
         );
 
         if (!branchResponse.ok && branchResponse.status === 404) {
           // Create the branch
           const createBranchResponse = await api.post(
-            `/organizations/${props.organizationId}/databases/${props.name}/branches`,
+            `/organizations/${props.organizationId}/databases/${databaseName}/branches`,
             {
               name: props.defaultBranch,
               parent_branch: "main",
@@ -342,7 +361,7 @@ export const Database = Resource(
           await fixClusterSize(
             api,
             props.organizationId,
-            props.name,
+            databaseName,
             props.defaultBranch || "main",
             props.clusterSize,
             false,
@@ -350,7 +369,7 @@ export const Database = Resource(
 
           // Update database to use new branch as default
           const updateResponse = await api.patch(
-            `/organizations/${props.organizationId}/databases/${props.name}`,
+            `/organizations/${props.organizationId}/databases/${databaseName}`,
             {
               default_branch: props.defaultBranch,
             },
@@ -366,6 +385,7 @@ export const Database = Resource(
           return this({
             ...props,
             id: data.id,
+            name: databaseName,
             state: updatedData.state,
             defaultBranch: updatedData.default_branch,
             plan: updatedData.plan,
@@ -379,6 +399,7 @@ export const Database = Resource(
       return this({
         ...props,
         id: data.id,
+        name: databaseName,
         state: data.state,
         defaultBranch: data.default_branch || "main",
         plan: data.plan,

package/src/planetscale/password.ts

@@ -14,8 +14,10 @@ import type { Database } from "./database.ts";
 export interface PasswordProps {
   /**
    * The name of the password
+   *
+   * @default ${app}-${stage}-${id}
    */
-  name: string;
+  name?: string;
 
   /**
    * The organization ID where the password will be created
@@ -73,6 +75,11 @@ export interface Password
    */
   id: string;
 
+  /**
+   * Name of the Password.
+   */
+  name: string;
+
   /**
    * The timestamp when the password expires (ISO 8601 format)
    */
@@ -255,7 +262,7 @@ export const Password = Resource(
   "planetscale::Password",
   async function (
     this: Context<Password>,
-    _id: string,
+    id: string,
     props: PasswordProps,
   ): Promise<Password> {
     const apiKey =
@@ -266,7 +273,7 @@ export const Password = Resource(
     const nameSlug = this.isReplacement
       ? lowercaseId()
       : (this.output?.nameSlug ?? lowercaseId());
-    const name = `${props.name.toLowerCase()}-${nameSlug}`;
+    const name = `${(props.name ?? this.output?.name ?? this.scope.createPhysicalName(id)).toLowerCase()}-${nameSlug}`;
 
     const api = new PlanetScaleApi({ apiKey });
     const branchName =

package/src/resource.ts

@@ -59,7 +59,6 @@ export const ResourceFQN = Symbol.for("alchemy::ResourceFQN");
 export type ResourceKind = string;
 export const ResourceKind = Symbol.for("alchemy::ResourceKind");
 export const ResourceScope = Symbol.for("alchemy::ResourceScope");
-export const InnerResourceScope = Symbol.for("alchemy::InnerResourceScope");
 export const ResourceSeq = Symbol.for("alchemy::ResourceSeq");
 
 export interface ProviderOptions {
@@ -97,7 +96,6 @@ export interface PendingResource<Out = unknown> extends Promise<Out> {
   [ResourceScope]: Scope;
   [ResourceSeq]: number;
   [DestroyStrategy]: DestroyStrategy;
-  [InnerResourceScope]: Promise<Scope>;
 }
 
 export interface Resource<Kind extends ResourceKind = ResourceKind> {
@@ -187,7 +185,6 @@ export function Resource<
 
     // get a sequence number (unique within the scope) for the resource
     const seq = scope.seq();
-    let resolveInnerScope: ((scope: Scope) => void) | undefined;
     const meta = {
       [ResourceKind]: type,
       [ResourceID]: resourceID,
@@ -195,14 +192,8 @@ export function Resource<
       [ResourceSeq]: seq,
       [ResourceScope]: scope,
       [DestroyStrategy]: options?.destroyStrategy ?? "sequential",
-      [InnerResourceScope]: new Promise<Scope>((resolve) => {
-        resolveInnerScope = resolve;
-      }),
     } as any as PendingResource<Out>;
-    const promise = apply(meta, props, {
-      ...options,
-      resolveInnerScope,
-    });
+    const promise = apply(meta, props, options);
     const resource = Object.assign(promise, meta);
     scope.resources.set(resourceID, resource);
     return resource;

package/src/scope.ts

@@ -15,7 +15,6 @@ import {
   type ResourceProps,
 } from "./resource.ts";
 import type { State, StateStore, StateStoreType } from "./state.ts";
-import { D1StateStore } from "./state/d1-state-store.ts";
 import { FileSystemStateStore } from "./state/file-system-state-store.ts";
 import { InstrumentedStateStore } from "./state/instrumented-state-store.ts";
 import {
@@ -84,6 +83,12 @@ export interface ScopeOptions extends ProviderCredentials {
    * @default "./.alchemy"
    */
   dotAlchemy?: string;
+  /**
+   * Whether to adopt resources if they already exist but are not yet managed by your Alchemy app.
+   *
+   * @default false
+   */
+  adopt?: boolean;
 }
 
 /**
@@ -123,7 +128,6 @@ export const DEFAULT_STAGE =
 
 declare global {
   var __ALCHEMY_STORAGE__: AsyncLocalStorage<Scope>;
-  var __ALCHEMY_GLOBALS__: Scope[];
 }
 
 const ScopeSymbol = Symbol.for("alchemy::Scope");
@@ -139,17 +143,9 @@ export class Scope {
 
   public static storage = (globalThis.__ALCHEMY_STORAGE__ ??=
     new AsyncLocalStorage<Scope>());
-  public static globals: Scope[] = (globalThis.__ALCHEMY_GLOBALS__ ??= []);
 
   public static getScope(): Scope | undefined {
-    const scope = Scope.storage.getStore();
-    if (!scope) {
-      if (Scope.globals.length > 0) {
-        return Scope.globals[Scope.globals.length - 1];
-      }
-      return undefined;
-    }
-    return scope;
+    return Scope.storage.getStore();
   }
 
   public static get root(): Scope {
@@ -176,10 +172,12 @@ export class Scope {
   public readonly local: boolean;
   public readonly watch: boolean;
   public readonly force: boolean;
+  public readonly adopt: boolean;
   public readonly destroyStrategy: DestroyStrategy;
   public readonly logger: LoggerApi;
   public readonly telemetryClient: ITelemetryClient;
   public readonly dataMutex: AsyncMutex;
+  public readonly dotAlchemy: string;
 
   // Provider credentials for scope-level credential overrides
   public readonly providerCredentials: ProviderCredentials;
@@ -198,8 +196,6 @@ export class Scope {
     return this.scopeName;
   }
 
-  public readonly dotAlchemy: string;
-
   constructor(options: ScopeOptions) {
     // Extract core scope options first
     const {
@@ -216,10 +212,16 @@ export class Scope {
       destroyStrategy,
       telemetryClient,
       logger,
+      adopt,
       dotAlchemy,
       ...providerCredentials
     } = options;
 
+    this.dotAlchemy =
+      dotAlchemy ??
+      this.parent?.dotAlchemy ??
+      path.join(process.cwd(), ".alchemy");
+
     this.scopeName = scopeName;
     this.name = this.scopeName;
     this.parent = parent ?? Scope.getScope();
@@ -234,10 +236,6 @@ export class Scope {
         `Scope name "${this.scopeName}" cannot contain double colons`,
       );
     }
-    this.dotAlchemy =
-      options.dotAlchemy ??
-      this.parent?.dotAlchemy ??
-      path.join(process.cwd(), ".alchemy");
 
     this.stage = stage ?? this.parent?.stage ?? DEFAULT_STAGE;
     this.parent?.children.set(this.scopeName!, this);
@@ -266,6 +264,7 @@ export class Scope {
     this.local = local ?? this.parent?.local ?? false;
     this.watch = watch ?? this.parent?.watch ?? false;
     this.force = force ?? this.parent?.force ?? false;
+    this.adopt = adopt ?? this.parent?.adopt ?? false;
     this.destroyStrategy =
       destroyStrategy ?? this.parent?.destroyStrategy ?? "sequential";
     if (this.local) {
@@ -275,7 +274,9 @@ export class Scope {
     }
 
     this.stateStore =
-      stateStore ?? this.parent?.stateStore ?? defaultStateStore;
+      stateStore ??
+      this.parent?.stateStore ??
+      ((scope) => new FileSystemStateStore(scope));
     this.telemetryClient = telemetryClient ?? this.parent?.telemetryClient!;
     this.state = new InstrumentedStateStore(
       this.stateStore(this),
@@ -287,6 +288,14 @@ export class Scope {
     this.dataMutex = new AsyncMutex();
   }
 
+  public createPhysicalName(id: string, delimiter = "-"): string {
+    const app = this.appName;
+    const stage = this.stage;
+    return [app, ...this.chain.slice(2), id, stage]
+      .map((s) => s.replaceAll(/[^a-z0-9_-]/gi, delimiter))
+      .join(delimiter);
+  }
+
   public async spawn<
     E extends ((line: string) => string | undefined) | undefined,
   >(
@@ -294,9 +303,8 @@ export class Scope {
     id: string,
     options: Omit<IdempotentSpawnOptions, "log" | "stateFile">,
   ): Promise<E extends undefined ? undefined : string> {
-    const dotAlchemy = path.join(process.cwd(), ".alchemy");
-    const logsDir = path.join(dotAlchemy, "logs");
-    const pidsDir = path.join(dotAlchemy, "pids");
+    const logsDir = path.join(this.dotAlchemy, "logs");
+    const pidsDir = path.join(this.dotAlchemy, "pids");
 
     const result = await idempotentSpawn({
       log: path.join(logsDir, `${id}.log`),
@@ -496,14 +504,6 @@ export class Scope {
     if (this.finalized && !shouldForce) {
       return;
     }
-    if (this.parent === undefined && Scope.globals.length > 0) {
-      const last = Scope.globals.pop();
-      if (last !== this) {
-        throw new Error(
-          "Running in AsyncLocaStorage.enterWith emulation mode and attempted to finalize a global Scope that wasn't top of the stack",
-        );
-      }
-    }
     this.finalized = true;
     // trigger and await all deferred promises
     await Promise.all(this.deferred.map((fn) => fn()));
@@ -667,15 +667,6 @@ export class Scope {
   }
 }
 
-const defaultStateStore: StateStoreType = (scope: Scope) => {
-  switch (process.env.ALCHEMY_STATE_STORE) {
-    case "d1":
-      return new D1StateStore(scope);
-    default:
-      return new FileSystemStateStore(scope);
-  }
-};
-
 declare global {
   // for runtime
   // TODO(sam): maybe inject is a better way to achieve this

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