alchemy 0.16.10 → 0.17.0

package/src/cloudflare/wrangler.json.ts

@@ -67,7 +67,7 @@ export const WranglerJson = Resource(
   "cloudflare::WranglerJson",
   async function (
     this: Context<WranglerJson>,
-    id: string,
+    _id: string,
     props: WranglerJsonProps,
   ): Promise<WranglerJson> {
     // Default path is wrangler.json in current directory
@@ -409,7 +409,7 @@ function processBindings(
       // Service binding
       services.push({
         binding: bindingName,
-        service: binding.id,
+        service: binding.name,
       });
     } else if (binding.type === "kv_namespace") {
       // KV Namespace binding
@@ -506,6 +506,8 @@ function processBindings(
         binding: bindingName,
         pipeline: binding.name,
       });
+    } else if (binding.type === "json") {
+      // TODO(sam): anything to do here? not sure wrangler.json supports this
     } else {
       // biome-ignore lint/correctness/noVoidTypeReturn: it returns never
       return assertNever(binding);

package/src/cloudflare/zone.ts

@@ -305,7 +305,7 @@ export const Zone = Resource(
   "cloudflare::Zone",
   async function (
     this: Context<Zone>,
-    id: string,
+    _id: string,
     props: ZoneProps,
   ): Promise<Zone> {
     // Create Cloudflare API client with automatic account discovery

package/src/destroy.ts

@@ -39,11 +39,11 @@ export async function destroy<Type extends string>(
     } satisfies DestroyOptions;
 
     // destroy all active resources
-    await destroy.all(Array.from(scope.resources.values()), options);
+    await destroyAll(Array.from(scope.resources.values()), options);
 
     // then detect orphans and destroy them
     const orphans = await scope.state.all();
-    await destroy.all(
+    await destroyAll(
       Object.values(orphans).map((orphan) => ({
         ...orphan.output,
         Scope: scope,
@@ -151,27 +151,16 @@ 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[ResourceSeq] - a[ResourceSeq]);
-      for (const resource of sorted) {
-        await destroy(resource, options);
-      }
-    } else {
-      await Promise.all(
-        resources.map((resource) => destroy(resource, options)),
-      );
-    }
-  }
-
-  export async function sequentially(
-    ...resources: (Resource<string> | undefined | null)[]
-  ) {
-    for (const resource of resources) {
-      if (resource) {
-        await destroy(resource);
-      }
+export async function destroyAll(
+  resources: Resource[],
+  options?: DestroyOptions,
+) {
+  if (options?.strategy !== "parallel") {
+    const sorted = resources.sort((a, b) => b[ResourceSeq] - a[ResourceSeq]);
+    for (const resource of sorted) {
+      await destroy(resource, options);
     }
+  } else {
+    await Promise.all(resources.map((resource) => destroy(resource, options)));
   }
 }

package/src/dns/import-dns.ts

@@ -133,7 +133,7 @@ export const ImportDnsRecords = Resource(
   "dns::ImportDnsRecords",
   async function (
     this: Context<ImportDnsRecords>,
-    id: string,
+    _id: string,
     props: ImportDnsRecordsProps,
   ): Promise<ImportDnsRecords> {
     // For delete phase, just return destroyed state since this is a read-only resource

package/src/encrypt.ts

@@ -1,5 +1,3 @@
-import sodium from "libsodium-wrappers";
-
 /**
  * Encrypt a value with a symmetric key using libsodium
  *
@@ -8,6 +6,7 @@ import sodium from "libsodium-wrappers";
  * @returns The base64-encoded encrypted value with nonce
  */
 export async function encrypt(value: string, key: string): Promise<string> {
+  const sodium = (await import("libsodium-wrappers")).default;
   // Initialize libsodium
   await sodium.ready;
 
@@ -46,6 +45,7 @@ export async function decryptWithKey(
   encryptedValue: string,
   key: string,
 ): Promise<string> {
+  const sodium = (await import("libsodium-wrappers")).default;
   // Initialize libsodium
   await sodium.ready;
 

package/src/env.ts

@@ -16,16 +16,23 @@ async function _env<T = string>(
   if (value !== undefined) {
     return value;
   }
+  const env = await resolveEnv();
+  if (name in env) {
+    return env[name] as T;
+  }
+  throw new Error(error ?? `Environment variable ${name} is not set`);
+}
+
+async function resolveEnv(): Promise<Record<string, any>> {
   if (typeof process !== "undefined") {
-    // we are in a node environment
-    return process.env[name]! as T;
+    return process.env;
   }
-  // we are in a browser environment
   try {
     const { env } = await import("cloudflare:workers");
-    if (name in env) {
-      return env[name as keyof typeof env] as T;
-    }
-  } catch (error) {}
-  throw new Error(error ?? `Environment variable ${name} is not set`);
+    return env;
+  } catch (_error) {}
+  if (typeof import.meta !== "undefined") {
+    return import.meta.env;
+  }
+  throw new Error("No environment found");
 }

package/src/esbuild/bundle.ts

@@ -1,4 +1,4 @@
-import esbuild from "esbuild";
+import type esbuild from "esbuild";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -122,7 +122,7 @@ export const Bundle = Resource(
   },
   async function <Props extends BundleProps>(
     this: Context<Bundle<any>>,
-    id: string,
+    _id: string,
     props: Props,
   ): Promise<Bundle<Props>> {
     if (this.phase === "delete") {
@@ -193,7 +193,7 @@ export async function bundle(props: BundleProps) {
     // write:
     //   props.outdir === undefined && props.outfile === undefined ? false : true,
     // write: false,
-    entryPoints: [props.entryPoint],
+    entryPoints: [entryPoint],
     outdir: props.outdir ? props.outdir : props.outfile ? undefined : ".out",
     outfile: props.outfile,
     bundle: true,
@@ -208,5 +208,6 @@ export async function bundle(props: BundleProps) {
   if (process.env.DEBUG) {
     console.log(options);
   }
+  const esbuild = await import("esbuild");
   return await esbuild.build(options);
 }

package/src/fs/copy-file.ts

@@ -63,7 +63,7 @@ export const CopyFile = Resource(
   "fs::CopyFile",
   async function (
     this: Context<CopyFile>,
-    id: string,
+    _id: string,
     props: CopyFileProps,
   ): Promise<CopyFile> {
     const { src, dest, overwrite = true } = props;

package/src/github/client.ts

@@ -17,7 +17,7 @@ export async function getGitHubTokenFromCLI(): Promise<string | null> {
     // Get the auth token
     const { stdout: token } = await execAsync("gh auth token");
     return token?.trim() || null;
-  } catch (error) {
+  } catch (_error) {
     return null;
   }
 }

package/src/github/repository-environment.ts

@@ -173,7 +173,7 @@ export const RepositoryEnvironment = Resource(
   "github::RepositoryEnvironment",
   async function (
     this: Context<RepositoryEnvironment>,
-    id: string,
+    _id: string,
     props: RepositoryEnvironmentProps,
   ): Promise<RepositoryEnvironment> {
     // Create authenticated Octokit client
@@ -210,7 +210,7 @@ export const RepositoryEnvironment = Resource(
     }
     try {
       // Check if the environment already exists
-      let environmentId: number | undefined = undefined; // Use undefined instead of 0
+      let environmentId: number | undefined; // Use undefined instead of 0
       try {
         const { data: environments } =
           await octokit.rest.repos.getAllEnvironments({

package/src/github/secret.ts

@@ -134,7 +134,7 @@ export const GitHubSecret = Resource(
   "github::Secret",
   async function (
     this: Context<GitHubSecretOutput>,
-    id: string,
+    _id: string,
     props: GitHubSecretProps,
   ): Promise<GitHubSecretOutput> {
     // Create authenticated Octokit client - will automatically handle token resolution

package/src/internal/docs/providers.ts

@@ -52,7 +52,7 @@ export type Providers = {
 export async function Providers({
   srcDir,
   outDir,
-  filter,
+  // filter,
   parallel = true,
 }: DocsProps): Promise<Providers> {
   outDir = typeof outDir === "string" ? outDir : outDir.path;

package/src/neon/api-error.ts

@@ -53,11 +53,11 @@ export async function handleApiError(
 
   try {
     errorData = await response.json();
-  } catch (e) {
+  } catch (_e) {
     // If we can't parse JSON, just use the response text
     try {
       errorData = { message: await response.text() };
-    } catch (textError) {
+    } catch (_textError) {
       errorData = { message: response.statusText };
     }
   }

package/src/os/exec.ts

@@ -218,7 +218,7 @@ export const Exec = Resource(
       }
 
       // Wait for the process to complete
-      exitCode = await new Promise<number>((resolve, reject) => {
+      exitCode = await new Promise<number>((resolve, _reject) => {
         childProcess.on("close", (code) => {
           resolve(code || 0);
         });

package/src/resource.ts

@@ -1,6 +1,6 @@
 import { apply } from "./apply.js";
 import type { Context } from "./context.js";
-import { Scope as _Scope } from "./scope.js";
+import { Scope as _Scope, type Scope } from "./scope.js";
 
 export const PROVIDERS = new Map<ResourceKind, Provider<string, any>>();
 
@@ -11,6 +11,7 @@ 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 {
@@ -34,35 +35,21 @@ export type Provider<
     handler: F;
   };
 
-export type PendingResource<
-  Out = unknown,
-  Kind extends ResourceKind = ResourceKind,
-  ID extends ResourceID = ResourceID,
-  FQN extends ResourceFQN = ResourceFQN,
-  Scope extends _Scope = _Scope,
-  Seq extends number = number,
-> = Promise<Out> & {
-  [ResourceKind]: Kind;
-  [ResourceID]: ID;
-  [ResourceFQN]: FQN;
+export interface PendingResource<Out = unknown> extends Promise<Out> {
+  [ResourceKind]: ResourceKind;
+  [ResourceID]: ResourceID;
+  [ResourceFQN]: ResourceFQN;
   [ResourceScope]: Scope;
-  [ResourceSeq]: Seq;
-};
+  [ResourceSeq]: number;
+  [InnerResourceScope]: Promise<Scope>;
+}
 
-export interface Resource<
-  // give each name types for syntax highlighting (differentiation)
-  Kind extends ResourceKind = ResourceKind,
-  ID extends ResourceID = ResourceID,
-  FQN extends ResourceFQN = ResourceFQN,
-  Scope extends _Scope = _Scope,
-  Seq extends number = number,
-> {
-  // use capital letters to avoid collision with conventional camelCase typescript properties
+export interface Resource<Kind extends ResourceKind = ResourceKind> {
   [ResourceKind]: Kind;
-  [ResourceID]: ID;
-  [ResourceFQN]: FQN;
+  [ResourceID]: ResourceID;
+  [ResourceFQN]: ResourceFQN;
   [ResourceScope]: Scope;
-  [ResourceSeq]: Seq;
+  [ResourceSeq]: number;
 }
 
 // helper for semantic syntax highlighting (color as a type/class instead of function/value)
@@ -102,7 +89,7 @@ export function Resource<
 
   type Out = Awaited<ReturnType<F>>;
 
-  const provider = ((
+  const provider = (async (
     resourceID: string,
     props: ResourceProps,
   ): Promise<Resource<string>> => {
@@ -123,21 +110,25 @@ export function Resource<
           `Resource ${resourceID} already exists in the stack and is of a different type: '${otherResource?.[ResourceKind]}' !== '${type}'`,
         );
       }
-      // console.warn(
-      //   `Resource ${resourceID} already exists in the stack: ${scope.chain.join("/")}`,
-      // );
     }
 
     // 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,
       [ResourceFQN]: scope.fqn(resourceID),
       [ResourceSeq]: seq,
       [ResourceScope]: scope,
+      [InnerResourceScope]: new Promise<Scope>((resolve) => {
+        resolveInnerScope = resolve;
+      }),
     } as any as PendingResource<Out>;
-    const promise = apply(meta, props, options);
+    const promise = apply(meta, props, {
+      ...options,
+      resolveInnerScope,
+    });
     const resource = Object.assign(promise, meta);
     scope.resources.set(resourceID, resource);
     return resource;

package/src/runtime/bind.ts

@@ -0,0 +1,95 @@
+import { isPromise } from "node:util/types";
+import type { Binding as CloudflareBinding } from "../cloudflare/bindings.js";
+import type { Bound as CloudflareBound } from "../cloudflare/bound.js";
+import { isWorkerStub } from "../cloudflare/worker-stub.js";
+import { isWorker } from "../cloudflare/worker.js";
+import { env } from "../env.js";
+import { ResourceFQN, ResourceScope, type Resource } from "../resource.js";
+import { isRuntime } from "./global.js";
+
+/**
+ * Get a Resource's Binding from the Environment.
+ */
+export function getBinding<T extends Resource>(resource: T): Promise<Bound<T>> {
+  return env[getBindKey(resource)] as Promise<Bound<T>>;
+}
+
+export function tryGetBinding<T extends Resource>(
+  resource: T,
+): Promise<Bound<T>> | undefined {
+  if (isRuntime) {
+    return getBinding(resource);
+  }
+  return undefined;
+}
+
+/**
+ * Compute a unique key for where to store a Resource's Binding.
+ */
+export function getBindKey(resource: Resource): string {
+  if (isWorker(resource) || isWorkerStub(resource)) {
+    return `worker:${resource.name}`;
+  }
+  const fqn = resource[ResourceFQN];
+  const scope = resource[ResourceScope];
+  const prefix = `${scope.appName}/${scope.stage}`;
+  const key = fqn.slice(prefix.length + 1).replace(/[^a-zA-Z0-9-_]/g, "_");
+  return key;
+}
+
+export type Bound<T> = T extends CloudflareBinding ? CloudflareBound<T> : T;
+
+/**
+ * Create a lazy binding of a Resource to an environment that exposes the Resource's methods
+ * throw a Proxy that delays initialization of the binding until the Resource's methods are accessed.
+ *
+ * This allows us to run the same code during build time and runtime.
+ */
+export async function bind<T extends Resource>(
+  resource: T | Promise<T>,
+  options?: {
+    reify?: (value: T, key: string) => Promise<Bound<T>>;
+    /** @default true */
+    bindThis?: boolean;
+  },
+): Promise<Bound<T>> {
+  if (isPromise(resource)) {
+    return resource.then((r) => bind(r, options)) as Promise<Bound<T>>;
+  }
+  let _runtime: [Bound<T>] | undefined;
+  const runtime = async (): Promise<Bound<T>> =>
+    (_runtime ??= [
+      await (options?.reify
+        ? options.reify(resource, getBindKey(resource))
+        : getBinding(resource)),
+    ])[0];
+
+  return new Proxy(() => {}, {
+    get: (target: any, prop: string) => {
+      if (prop in target) {
+        return (resource as T)[prop as keyof T];
+      } else if (prop === "then" || prop === "catch" || prop === "finally") {
+        return target[prop];
+      }
+      return async (...args: any[]) => {
+        const rt: Bound<T> = await runtime();
+        if (rt === undefined) {
+          throw new Error(`Resource ${resource[ResourceFQN]} is not bound`);
+        }
+        const method = rt[prop as keyof Bound<T>];
+        if (typeof method !== "function") {
+          throw new Error(
+            `Method ${prop} on '${resource[ResourceFQN]}' is not a function`,
+          );
+        }
+        if (options?.bindThis !== false) {
+          return method.bind(rt)(...args);
+        }
+        return method(...args);
+      };
+    },
+    // apply: (target, thisArg, argArray) => {
+    //   return target(thisArg, ...argArray);
+    // },
+  }) as T & Bound<T>;
+}

package/src/runtime/global.ts

@@ -0,0 +1,10 @@
+import type { SerializedScope } from "../serde.js";
+
+declare global {
+  const __ALCHEMY_WORKER_NAME__: string;
+  const __ALCHEMY_RUNTIME__: true;
+  const __ALCHEMY_SERIALIZED_SCOPE__: SerializedScope;
+}
+
+// __ALCHEMY_SERIALIZED_SCOPE__ is injected by esbuild when bundling a Worker
+export const isRuntime = typeof __ALCHEMY_RUNTIME__ !== "undefined";

package/src/runtime/plugin.ts

@@ -0,0 +1,162 @@
+import type {
+  CallExpression,
+  Declaration,
+  Expression,
+  FunctionDeclaration,
+  TsType,
+  VariableDeclaration,
+} from "@swc/core";
+import type { Plugin } from "esbuild";
+import fs from "node:fs/promises";
+
+/**
+ * Bundles a single Worker function entrypoint by:
+ * 1. Evaluate the script and detect which resources are included in its bundle.
+ * 2. Create a static map of Resource ID -> State
+ * 3. Apply esbuild with {@link bootstrapPlugin} to erase Resource lifecycle operations
+ * 4. The final bundle should then tree-shake away all infrastructure-code, leaving only runtime code.
+ *
+ * TODO(sam): should we inline the state map in the bundle or bind to a Cloudflare Worker with a blob?
+ * TODO(sam): what should we do with secrets? Seems like we could auto-bind them and resolve without requiring encryption logic.
+ *
+ * @param file the `.ts` file containing an `export default function`
+ */
+export function bundleEntrypoint(_file: string) {}
+
+/**
+ * This is a plugin that bootstraps Alchemy Infrastructure into Runtime by replacing Resources
+ * with a stub that loads from a statically bundled state.
+ *
+ * Take the following table for example:
+ * ```ts
+ * const Table = Resource(
+ *   "dynamodb::Table",
+ *   async function(this, id, props) {
+ *     // lifecycle logic in here
+ *   }
+ * );
+ * ```
+ *
+ * The plugin replaces the Resource with a stub:
+ * ```ts
+ * const Table = (id, props) => STATE.get(id)
+ * ```
+ */
+export const bootstrapPlugin: Plugin = {
+  name: "alchemy-bootstrap",
+  async setup(build) {
+    const { parse, print } = await import("@swc/core");
+    const { Visitor } = await import("@swc/core/Visitor.js");
+
+    async function expr(expr: string) {
+      return (
+        (await parse(`const __temp__ = ${expr}`)).body[0] as VariableDeclaration
+      ).declarations[0].init!;
+    }
+    async function decl(decl: string) {
+      return (await parse(decl)).body[0] as Declaration;
+    }
+
+    const Provider = await decl("async function Resource() {}");
+    const Resource = await expr("(id) => STATE.get(id)");
+    // const alchemy = await expr("(async () => {})");
+
+    // Add a global STATE object to bundle for resource lookup
+    build.onLoad(
+      {
+        filter: /.*\.(ts|js)x?/,
+      },
+      async (args) => {
+        try {
+          const source = await fs.readFile(args.path, "utf-8");
+
+          function transformed(code: string) {
+            return {
+              contents: code,
+              loader: args.path.endsWith(".ts")
+                ? args.path.endsWith(".tsx")
+                  ? "tsx"
+                  : "ts"
+                : args.path.endsWith(".jsx")
+                  ? "jsx"
+                  : "js",
+            } as const;
+          }
+
+          // Parse the source code using SWC
+          const ast = await parse(source, {
+            syntax: "typescript",
+            tsx: args.path.endsWith(".tsx"),
+            decorators: true,
+            dynamicImport: true,
+          });
+
+          // function text({ span }: HasSpan) {
+          //   return source.slice(
+          //     span.start - ast.span.start,
+          //     span.end - ast.span.start,
+          //   );
+          // }
+
+          // Create visitor to transform Resource calls
+          class ResourceTransformer extends Visitor {
+            visitTsType(n: TsType): TsType {
+              return n;
+            }
+            visitFunctionDeclaration(decl: FunctionDeclaration): Declaration {
+              const param = decl.params[0];
+              if (
+                decl.identifier.value === "Resource" &&
+                param?.pat.type === "Identifier" &&
+                param.pat.value === "type" &&
+                decl.body
+              ) {
+                return Provider;
+              }
+              return decl;
+            }
+            visitCallExpression(expr: CallExpression): Expression {
+              // Check if this is a Resource call
+              if (
+                expr.callee.type === "Identifier" &&
+                expr.callee.value === "Resource" &&
+                expr.arguments.length >= 2
+              ) {
+                return Resource;
+                // } else if (
+                //   expr.callee.type === "Identifier" &&
+                //   expr.callee.value === "alchemy"
+                // ) {
+                //   return alchemy;
+              }
+
+              return super.visitCallExpression(expr);
+            }
+          }
+
+          // Apply the transformation
+          const visitor = new ResourceTransformer();
+          const program = visitor.visitProgram(ast);
+
+          // Print the transformed AST back to code
+          const { code } = await print(program, {
+            sourceMaps: true,
+            minify: false,
+          });
+
+          return transformed(code);
+        } catch (error: unknown) {
+          console.error(`Error transforming ${args.path}:`, error);
+          return {
+            errors: [
+              {
+                text: `Failed to transform: ${error instanceof Error ? error.message : String(error)}`,
+                location: { file: args.path },
+              },
+            ],
+          };
+        }
+      },
+    );
+  },
+};

package/src/runtime/shims.js

@@ -0,0 +1,34 @@
+import { env } from "cloudflare:workers";
+import { Scope } from "../scope.js";
+import { Secret } from "../secret.js";
+import { deserialize } from "../serde.js";
+
+globalThis.process.env = env;
+
+export const __ALCHEMY_RUNTIME__ = true;
+
+export var __ALCHEMY_SERIALIZED_SCOPE__ = JSON.parse(
+  env.__ALCHEMY_SERIALIZED_SCOPE__,
+);
+
+export const STATE = {
+  async get(id) {
+    const fqn = globalThis.__ALCHEMY_SCOPE__.current.fqn(id);
+    const state = __ALCHEMY_SERIALIZED_SCOPE__[fqn];
+    if (!state) {
+      throw new Error(
+        `Resource ${fqn} not found in __ALCHEMY_SERIALIZED_SCOPE__\n${JSON.stringify(__ALCHEMY_SERIALIZED_SCOPE__, null, 2)}`,
+      );
+    }
+    return await deserialize(Scope.current, state, {
+      transform: (value) => {
+        if (value && typeof value === "object" && value["@secret-env"]) {
+          return {
+            value: new Secret(env[value["@secret-env"]]),
+          };
+        }
+      },
+    });
+  },
+};
+// export const process = { env };