alchemy 0.16.0 → 0.16.1

package/src/cloudflare/r2-rest-state-store.ts

@@ -1,6 +1,7 @@
+import { ResourceScope } from "../resource.js";
 import type { Scope } from "../scope.js";
-import { deserialize, serialize } from "../serde.js";
-import type { State, StateStore } from "../state.js";
+import { serialize } from "../serde.js";
+import { deserializeState, type State, type StateStore } from "../state.js";
 import { withExponentialBackoff } from "../util/retry.js";
 import { CloudflareApiError, handleApiError } from "./api-error.js";
 import {
@@ -211,15 +212,14 @@ export class R2RestStateStore implements StateStore {
       }
 
       // Parse and deserialize the state data
-      const rawData = await response.json();
-      const state = (await deserialize(this.scope, rawData)) as State;
+      const state = await deserializeState(this.scope, await response.text());
 
       // Create a new state object with proper output
       return {
         ...state,
         output: {
           ...(state.output || {}),
-          Scope: this.scope,
+          [ResourceScope]: this.scope,
         },
       };
     } catch (error: any) {

package/src/cloudflare/worker.ts

@@ -814,7 +814,7 @@ async function prepareWorkerMetadata<B extends Bindings>(
       meta.bindings.push({
         type: "service",
         name: bindingName,
-        service: binding.id,
+        service: binding.name,
       });
     } else if (binding.type === "durable_object_namespace") {
       meta.bindings.push({

package/src/context.ts

@@ -1,10 +1,12 @@
 import { DestroyedSignal } from "./destroy.js";
-import type {
-  Resource,
+import {
   ResourceFQN,
   ResourceID,
   ResourceKind,
-  ResourceProps,
+  ResourceScope,
+  ResourceSeq,
+  type Resource,
+  type ResourceProps,
 } from "./resource.js";
 import type { Scope } from "./scope.js";
 import type { State } from "./state.js";
@@ -96,23 +98,29 @@ export function context<
   state: State<Kind, Props, Out>;
   replace: () => void;
 }): Context<Out> {
-  function create(props: Omit<Out, "Kind" | "ID" | "Scope">): Out;
-  function create(id: string, props: Omit<Out, "Kind" | "ID" | "Scope">): Out;
+  type InternalSymbols =
+    | typeof ResourceID
+    | typeof ResourceKind
+    | typeof ResourceFQN
+    | typeof ResourceSeq
+    | typeof ResourceScope;
+  function create(props: Omit<Out, InternalSymbols>): Out;
+  function create(id: string, props: Omit<Out, InternalSymbols>): Out;
   function create(
     ...args:
-      | [props: Omit<Out, "Kind" | "ID" | "Scope">]
-      | [id: string, props: Omit<Out, "Kind" | "ID" | "Scope">]
+      | [props: Omit<Out, InternalSymbols>]
+      | [id: string, props: Omit<Out, InternalSymbols>]
   ): Out {
     const [ID, props] =
       typeof args[0] === "string" ? (args as [string, any]) : [id, args[0]];
 
     return {
       ...props,
-      Kind: kind,
-      ID,
-      FQN: fqn,
-      Scope: scope,
-      Seq: seq,
+      [ResourceKind]: kind,
+      [ResourceID]: ID,
+      [ResourceFQN]: fqn,
+      [ResourceScope]: scope,
+      [ResourceSeq]: seq,
     } as Out;
   }
   return Object.assign(create, {
@@ -138,5 +146,5 @@ export function context<
       throw new DestroyedSignal();
     },
     create,
-  }) as Context<Out>;
+  }) as unknown as Context<Out>;
 }

package/src/destroy.ts

@@ -1,6 +1,15 @@
 import { alchemy } from "./alchemy.js";
 import { context } from "./context.js";
-import { PROVIDERS, type Provider, type Resource } from "./resource.js";
+import {
+  PROVIDERS,
+  ResourceFQN,
+  ResourceID,
+  ResourceKind,
+  ResourceScope,
+  ResourceSeq,
+  type Provider,
+  type Resource,
+} from "./resource.js";
 import { Scope } from "./scope.js";
 
 export class DestroyedSignal extends Error {}
@@ -52,34 +61,36 @@ export async function destroy<Type extends string>(
     return;
   }
 
-  if (instance.Kind === Scope.KIND) {
+  if (instance[ResourceKind] === Scope.KIND) {
     const scope = new Scope({
-      parent: instance.Scope,
-      scopeName: instance.ID,
+      parent: instance[ResourceScope],
+      scopeName: instance[ResourceID],
     });
     console.log("Destroying scope", scope.chain.join("/"));
     return await destroy(scope, options);
   }
 
-  const Provider: Provider<Type> | undefined = PROVIDERS.get(instance.Kind);
+  const Provider: Provider<Type> | undefined = PROVIDERS.get(
+    instance[ResourceKind],
+  );
   if (!Provider) {
     throw new Error(
-      `Cannot destroy resource "${instance.FQN}" type ${instance.Kind} - no provider found. You may need to import the provider in your alchemy.config.ts.`,
+      `Cannot destroy resource "${instance[ResourceFQN]}" type ${instance[ResourceKind]} - no provider found. You may need to import the provider in your alchemy.config.ts.`,
     );
   }
 
-  const scope = instance.Scope;
+  const scope = instance[ResourceScope];
   if (!scope) {
-    console.warn(`Resource "${instance.FQN}" has no scope`);
+    console.warn(`Resource "${instance[ResourceFQN]}" has no scope`);
   }
   const quiet = options?.quiet ?? scope.quiet;
 
   try {
     if (!quiet) {
-      console.log(`Delete:  "${instance.FQN}"`);
+      console.log(`Delete:  "${instance[ResourceFQN]}"`);
     }
 
-    const state = await scope.state.get(instance.ID);
+    const state = await scope.state.get(instance[ResourceID]);
 
     if (state === undefined) {
       return;
@@ -88,10 +99,10 @@ export async function destroy<Type extends string>(
     const ctx = context({
       scope,
       phase: "delete",
-      kind: instance.Kind,
-      id: instance.ID,
-      fqn: instance.FQN,
-      seq: instance.Seq,
+      kind: instance[ResourceKind],
+      id: instance[ResourceID],
+      fqn: instance[ResourceFQN],
+      seq: instance[ResourceSeq],
       props: state.props,
       state,
       replace: () => {
@@ -103,15 +114,18 @@ export async function destroy<Type extends string>(
     try {
       // BUG: this does not restore persisted scope
       await alchemy.run(
-        instance.ID,
+        instance[ResourceID],
         {
           // TODO(sam): this is an awful hack to differentiate between naked scopes and resources
-          isResource: instance.Kind !== "alchemy::Scope",
+          isResource: instance[ResourceKind] !== "alchemy::Scope",
           parent: scope,
         },
         async (scope) => {
           nestedScope = scope;
-          return await Provider.handler.bind(ctx)(instance.ID, state.props);
+          return await Provider.handler.bind(ctx)(
+            instance[ResourceID],
+            state.props,
+          );
         },
       );
     } catch (err) {
@@ -126,10 +140,10 @@ export async function destroy<Type extends string>(
       await destroy(nestedScope, options);
     }
 
-    await scope.delete(instance.ID);
+    await scope.delete(instance[ResourceID]);
 
     if (!quiet) {
-      console.log(`Deleted: "${instance.FQN}"`);
+      console.log(`Deleted: "${instance[ResourceFQN]}"`);
     }
   } catch (error) {
     console.error(error);
@@ -140,7 +154,7 @@ export async function destroy<Type extends string>(
 export namespace destroy {
   export async function all(resources: Resource[], options?: DestroyOptions) {
     if (options?.strategy !== "parallel") {
-      const sorted = resources.sort((a, b) => b.Seq - a.Seq);
+      const sorted = resources.sort((a, b) => b[ResourceSeq] - a[ResourceSeq]);
       for (const resource of sorted) {
         await destroy(resource, options);
       }

package/src/fs/file-system-state-store.ts

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
+import { ResourceScope } from "../resource.js";
 import type { Scope } from "../scope.js";
-import { deserialize, serialize } from "../serde.js";
-import type { State, StateStore } from "../state.js";
+import { serialize } from "../serde.js";
+import { deserializeState, type State, type StateStore } from "../state.js";
 import { ignore } from "../util/ignore.js";
 
 const stateRootDir = path.join(process.cwd(), ".alchemy");
@@ -50,14 +51,11 @@ export class FileSystemStateStore implements StateStore {
   async get(key: string): Promise<State | undefined> {
     try {
       const content = await fs.promises.readFile(this.getPath(key), "utf8");
-      const state = (await deserialize(
-        this.scope,
-        JSON.parse(content),
-      )) as State;
+      const state = await deserializeState(this.scope, content);
       if (state.output === undefined) {
         state.output = {} as any;
       }
-      state.output.Scope = this.scope;
+      state.output[ResourceScope] = this.scope;
       return state;
     } catch (error: any) {
       if (error.code === "ENOENT") {

package/src/resource.ts

@@ -5,8 +5,13 @@ import { Scope as _Scope } from "./scope.js";
 export const PROVIDERS = new Map<ResourceKind, Provider<string, any>>();
 
 export type ResourceID = string;
+export const ResourceID = Symbol.for("alchemy::ResourceID");
 export type ResourceFQN = string;
+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 ResourceSeq = Symbol.for("alchemy::ResourceSeq");
 
 export interface ProviderOptions {
   /**
@@ -37,12 +42,11 @@ export type PendingResource<
   Scope extends _Scope = _Scope,
   Seq extends number = number,
 > = Promise<Out> & {
-  Kind: Kind;
-  ID: ID;
-  FQN: FQN;
-  Seq: Seq;
-  Scope: Scope;
-  signal: () => void;
+  [ResourceKind]: Kind;
+  [ResourceID]: ID;
+  [ResourceFQN]: FQN;
+  [ResourceScope]: Scope;
+  [ResourceSeq]: Seq;
 };
 
 export interface Resource<
@@ -54,11 +58,11 @@ export interface Resource<
   Seq extends number = number,
 > {
   // use capital letters to avoid collision with conventional camelCase typescript properties
-  Kind: Kind;
-  ID: ID;
-  FQN: FQN;
-  Scope: Scope;
-  Seq: Seq;
+  [ResourceKind]: Kind;
+  [ResourceID]: ID;
+  [ResourceFQN]: FQN;
+  [ResourceScope]: Scope;
+  [ResourceSeq]: Seq;
 }
 
 // helper for semantic syntax highlighting (color as a type/class instead of function/value)
@@ -113,10 +117,10 @@ export function Resource<
       // TODO(sam): do we want to throw?
       // it's kind of awesome that you can re-create a resource and call apply
       const otherResource = scope.resources.get(resourceID);
-      if (otherResource?.Kind !== type) {
+      if (otherResource?.[ResourceKind] !== 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?.[ResourceKind]}' !== '${type}'`,
         );
       }
       // console.warn(
@@ -127,11 +131,11 @@ export function Resource<
     // get a sequence number (unique within the scope) for the resource
     const seq = scope.seq();
     const meta = {
-      Kind: type,
-      ID: resourceID,
-      FQN: scope.fqn(resourceID),
-      Seq: seq,
-      Scope: scope,
+      [ResourceKind]: type,
+      [ResourceID]: resourceID,
+      [ResourceFQN]: scope.fqn(resourceID),
+      [ResourceSeq]: seq,
+      [ResourceScope]: scope,
     } as any as PendingResource<Out>;
     const promise = apply(meta, props, options);
     const resource = Object.assign(promise, meta);

package/src/scope.ts

@@ -2,7 +2,7 @@ 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";
+import { ResourceID, type PendingResource } from "./resource.js";
 import type { StateStore, StateStoreType } from "./state.js";
 
 const scopeStorage = new AsyncLocalStorage<Scope>();
@@ -157,7 +157,7 @@ export class Scope {
     return `Scope(
   chain=${this.chain.join("/")},
   resources=[${Array.from(this.resources.values())
-    .map((r) => r.ID)
+    .map((r) => r[ResourceID])
     .join(",\n  ")}]
 )`;
   }

package/src/state.ts

@@ -1,5 +1,14 @@
-import type { Resource, ResourceProps } from "./resource.js";
-import type { Scope } from "./scope.js";
+import {
+  ResourceFQN,
+  ResourceID,
+  ResourceKind,
+  ResourceScope,
+  ResourceSeq,
+  type Resource,
+  type ResourceProps,
+} from "./resource.js";
+import { Scope } from "./scope.js";
+import { deserialize } from "./serde.js";
 
 export type State<
   Kind extends string = string,
@@ -41,3 +50,34 @@ export interface StateStore {
   set(key: string, value: State): Promise<void>;
   delete(key: string): Promise<void>;
 }
+
+export async function deserializeState(
+  scope: Scope,
+  content: string,
+): Promise<State> {
+  const state = (await deserialize(scope, JSON.parse(content))) as State;
+
+  if (ResourceID in state.output) {
+    // this is a new state
+    return state;
+  }
+  const output: any = state.output;
+  delete output.Kind;
+  delete output.ID;
+  delete output.FQN;
+  delete output.Scope;
+  delete output.Seq;
+  // fix this bug
+  if (state.kind === "scope") {
+    state.kind = Scope.KIND;
+  }
+  output[ResourceKind] = state.kind;
+  output[ResourceID] = state.id;
+  output[ResourceFQN] = state.fqn;
+  output[ResourceScope] = scope;
+  output[ResourceSeq] = state.seq;
+  state.output = output;
+  // re-write the state with the migrated format
+  await scope.state.set(state.id, state);
+  return state;
+}