alchemy 0.1.11 → 0.1.13

package/src/esbuild.ts

@@ -60,14 +60,12 @@ export interface BundleOutput {
 
 export class Bundle extends Resource(
   "esbuild::Bundle",
+  {
+    alwaysUpdate: true,
+  },
   async (ctx, props: BundleProps): Promise<BundleOutput> => {
     // Determine output path
-    const outputPath =
-      props.outfile ||
-      path.join(
-        props.outdir || "dist",
-        path.basename(props.entryPoint, path.extname(props.entryPoint)) + ".js",
-      );
+    const outputPath = getOutputPath(props);
 
     // Ensure output directory exists
     await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
@@ -79,22 +77,7 @@ export class Bundle extends Resource(
       return { path: outputPath, hash: "" };
     }
 
-    // Build the bundle
-    const result = await esbuild.build({
-      entryPoints: [props.entryPoint],
-      outfile: outputPath,
-      bundle: true,
-      format: props.format,
-      target: props.target,
-      minify: props.minify,
-      sourcemap: props.sourcemap,
-      external: props.external,
-      platform: props.platform,
-      metafile: true,
-      write: true,
-      ...props.options,
-    });
-
+    const result = await bundle(props);
     // Calculate hash of the output
     const contents = await fs.promises.readFile(outputPath);
     const hash = crypto.createHash("sha256").update(contents).digest("hex");
@@ -126,3 +109,32 @@ export class Bundle extends Resource(
     return ctx.get<string>("hash");
   }
 }
+
+export async function bundle(props: BundleProps) {
+  const outputPath = getOutputPath(props);
+  // Build the bundle
+  return await esbuild.build({
+    entryPoints: [props.entryPoint],
+    outfile: outputPath,
+    bundle: true,
+    format: props.format,
+    target: props.target,
+    minify: props.minify,
+    sourcemap: props.sourcemap,
+    external: props.external,
+    platform: props.platform,
+    metafile: true,
+    write: true,
+    ...props.options,
+  });
+}
+
+function getOutputPath(props: BundleProps) {
+  return (
+    props.outfile ||
+    path.join(
+      props.outdir || "dist",
+      path.basename(props.entryPoint, path.extname(props.entryPoint)) + ".js",
+    )
+  );
+}

package/src/global.ts

@@ -1,7 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { Provider, ResourceType } from "./resource";
-import { Scope } from "./scope";
 import { FileSystemStateStore } from "./state";
 
 export interface Config {
@@ -14,6 +13,7 @@ const alchemy = path.resolve(process.cwd(), "alchemy.ts");
 let _config: Config | undefined;
 
 const exists =
+  // @ts-ignore
   fs.promises.exists ??
   async function exists(path: string): Promise<boolean> {
     try {
@@ -51,8 +51,6 @@ export const defaultStage = config.defaultStage ?? _stage;
 
 export const defaultStateStore = config.stateStore ?? FileSystemStateStore;
 
-export const rootScope = new Scope(null);
-
 export const providers = new Map<
   ResourceType,
   Provider<ResourceType, any[], any>

package/src/index.ts

@@ -4,6 +4,7 @@ export * from "./error";
 export * from "./global";
 export * from "./input";
 export * from "./output";
+export * from "./print";
 export {
   Resource,
   type Context,
@@ -11,5 +12,4 @@ export {
   type DeleteContext,
   type UpdateContext,
 } from "./resource";
-
 export type { FileSystemStateStore as StateStore } from "./state";

package/src/main.ts

@@ -2,7 +2,7 @@
 import { parseArgs } from "util";
 
 const { values, positionals } = parseArgs({
-  args: Bun.argv.slice(2),
+  args: process.argv.slice(2),
   options: {
     help: {
       type: "boolean",

package/src/output.ts

@@ -1,5 +1,3 @@
-export type Eval<U> = U extends Output<infer V> ? Eval<V> : U;
-
 export function isOutput<T>(value: any): value is Output<T> {
   return (
     value && typeof value === "object" && typeof value.apply === "function"
@@ -13,43 +11,61 @@ export type Outputs<P extends readonly any[]> = P extends [
   ? [Output<First>, ...Outputs<Rest>]
   : [];
 
-export type Output<T> = {
-  apply<U>(fn: (value: T) => U): Output<Eval<U>>;
-} & (T extends string
-  ? {
-      [k in keyof typeof String.prototype]: Output<
-        (typeof String.prototype)[k]
-      >;
-    }
-  : T extends number
-    ? {
-        [K in keyof typeof Number.prototype]: Output<
-          (typeof Number.prototype)[K]
-        >;
-      }
-    : T extends boolean
-      ? {
-          [K in keyof typeof Boolean.prototype]: Output<
-            (typeof Boolean.prototype)[K]
-          >;
-        }
-      : T extends any[]
-        ? Outputs<T>
-        : {
-            [k in keyof T]: Output<T[k]>;
-          });
+export interface Output<T> {
+  apply<U>(fn: (value: T) => U): Output<U>;
+}
 
-export const Output = class<T, U> {
+export class OutputChain<T, U> {
+  public readonly fn: (value: T) => U;
   constructor(
     public readonly parent: Output<T>,
-    public readonly fn: (value: T) => U,
-  ) {}
+    fn: (value: T) => U,
+  ) {
+    let result:
+      | {
+          value: U;
+        }
+      | undefined;
+    this.fn = (value: T) => {
+      if (result === undefined) {
+        result = {
+          value: fn(value),
+        };
+      }
+      return result.value as U;
+    };
+  }
 
-  public apply<V>(fn: (value: U) => V): Output<V> {
-    // @ts-expect-error - we know we are an "Output"
-    return new Output(this, fn);
+  public apply<V>(fn: (value: U) => Output<V>): Output<V>;
+  public apply<V>(fn: (value: U) => V): Output<V>;
+  public apply<V>(fn: (value: U) => any): Output<V> {
+    return new OutputChain(this, fn);
   }
-} as new <T, U>(
-  parent: Output<T>,
-  fn: (value: T) => U,
-) => Output<U>;
+}
+
+export type Resolved<O> = O extends Output<infer U>
+  ? U
+  : O extends null
+    ? O
+    : O extends any[]
+      ? ResolveN<O>
+      : O extends object
+        ? {
+            [k in keyof O]: Resolved<O[k]>;
+          }
+        : O;
+
+type ResolveN<O extends any[]> = O extends [infer First, ...infer Rest]
+  ? [Resolved<First>, ...ResolveN<Rest>]
+  : [];
+
+// export data from a resource
+export type Export<Out> = Out extends null
+  ? Output<Out>
+  : Out extends any[]
+    ? Outputs<Out>
+    : Out extends object
+      ? {
+          [k in keyof Out]: Output<Out[k]>;
+        }
+      : Output<Out>;

package/src/print.ts

@@ -0,0 +1,18 @@
+import { Resource } from "./resource";
+
+export class Print extends Resource(
+  "Print",
+  {
+    alwaysUpdate: true,
+  },
+  async (
+    ctx,
+    values: {
+      [key: string]: any;
+    },
+  ) => {
+    if (ctx.event !== "delete") {
+      console.log(JSON.stringify(values, null, 2));
+    }
+  },
+) {}

package/src/resource.ts

@@ -3,14 +3,17 @@ import { type ApplyOptions, apply } from "./apply";
 import type { DestroyOptions } from "./destroy";
 import { defaultStateStore, deletions, providers } from "./global";
 import type { Inputs, Input as input } from "./input";
-import { Output } from "./output";
-import { Scope as IScope, getScope, pushScope } from "./scope";
+import { type Export, type Output, OutputChain, type Resolved } from "./output";
+import { type Scope as IScope, getScope, pushScope } from "./scope";
 import type { State, StateStore } from "./state";
 
 export type ResourceID = string;
+export type ResourceFQN = string;
 export type ResourceType = string;
 
 export const ResourceID = Symbol.for("ResourceID");
+export const ResourceFQN = Symbol.for("ResourceFQN");
+export const ResourceHandle = Symbol.for("ResourceHandle");
 export const Provider = Symbol.for("Provider");
 export const Input = Symbol.for("Input");
 export const Value = Symbol.for("Value");
@@ -22,6 +25,8 @@ export const Options = Symbol.for("Options");
 // properties that pierce through the Proxy
 const OrthogonalProperties = [
   ResourceID,
+  ResourceFQN,
+  ResourceHandle,
   Provider,
   Input,
   Value,
@@ -46,12 +51,18 @@ export type Resource<In extends any[] = any[], Out = any> = {
   [Apply]: <O>(value: Out) => O;
   [Provide]: (value: Out) => void;
   [Options]: ProviderOptions;
-} & Output<Out>;
+} & Output<Out> &
+  Export<
+    // the resource handler may export another Output - we need to resolve it first
+    // then, export that resolved value
+    Resolved<Out>
+  >;
 
 export interface BaseContext {
   quiet: boolean;
   stage: string;
   resourceID: ResourceID;
+  resourceFQN: ResourceFQN;
   scope: IScope;
   get<T>(key: string): Promise<T | undefined>;
   set<T>(key: string, value: T): Promise<void>;
@@ -65,6 +76,7 @@ export interface BaseContext {
 
 export interface CreateContext extends BaseContext {
   event: "create";
+  output?: undefined;
 }
 
 export interface UpdateContext<Outputs> extends BaseContext {
@@ -113,18 +125,24 @@ export function isResource(value: any): value is Resource {
   return value?.[ResourceID] !== undefined;
 }
 
+const applied = new Map<Object, any>();
+
+const destroyed = new WeakMap<Resource<any, any>, Promise<void>>();
+
+const i = 0;
+
 export function Resource<
-  const Type extends ResourceType,
+  // const Type extends ResourceType,
   Args extends any[],
   Out,
 >(
-  type: Type,
+  type: string,
   options: Partial<ProviderOptions>,
   func: (
     ctx: Context<Out>,
     ...args: Args
   ) => Promise<input<Out> | void> | input<Out> | void,
-): Provider<Type, Args, Awaited<Out>>;
+): Provider<string, Args, Awaited<Out>>;
 
 export function Resource<
   const Type extends ResourceType,
@@ -166,6 +184,8 @@ export function Resource<
 
   interface Resource {
     [ResourceID]: ResourceID;
+    [ResourceFQN]: string;
+    [ResourceHandle]: Object;
     [Provider]: Provider<Type, Args, Out>;
     [Input]: Inputs<Args>;
     [Value]?: Out;
@@ -190,7 +210,12 @@ export function Resource<
       }
       scope.nodes.set(id, node as any);
 
+      // const resourceFQN = scope.getScopePath(id) + "/" + id;
+
       this[ResourceID] = id;
+      this[ResourceHandle] = new Object();
+      // this[ResourceFQN] = resourceFQN;
+      // this[ResourceFQN] = i++;
       this[Provider] = Resource as any;
       this[Input] = input;
       this[Value] = undefined;
@@ -210,6 +235,8 @@ export function Resource<
         get(target: any, prop) {
           if (OrthogonalProperties.includes(prop as any)) {
             return target[prop];
+          } else if (prop === "apply") {
+            return target[Apply].bind(target);
           } else {
             return target[Apply]((value: Out) => value[prop as keyof Out]);
           }
@@ -217,8 +244,12 @@ export function Resource<
       });
     }
 
+    public apply<U>(fn: (value: Out) => U): Output<U> {
+      return this[Apply](fn);
+    }
+
     public [Apply]<U>(fn: (value: Out) => U): Output<U> {
-      return new Output<Out, U>(this as any, fn);
+      return new OutputChain<Out, U>(this as any, fn);
     }
 
     private box?: {
@@ -258,132 +289,146 @@ export function Resource<
     ): Promise<Awaited<Out | void>> {
       // const stack = resource[ResourceStack];
       const resourceID = resource[ResourceID];
-
-      let resourceState: State | undefined = await stateStore.get(resourceID);
-      if (resourceState === undefined) {
-        resourceState = {
-          provider: type,
-          status: "creating",
-          data: {},
-          output: undefined,
-          deps: [...deps],
-          inputs,
-        };
-        await stateStore.set(resourceID, resourceState);
-      }
-
       const resourceFQN = `${resource[Scope].getScopePath(stage)}/${resourceID}`;
+      const cacheKey = resource[ResourceHandle];
+      if (!applied.has(cacheKey)) {
+        let res, rej;
+        const promise = new Promise<Awaited<Out | void>>((resolve, reject) => {
+          res = resolve;
+          rej = reject;
+        });
+        applied.set(cacheKey, promise);
+        update().then(res).catch(rej);
+        return promise;
+      }
+      return await applied.get(cacheKey);
+
+      async function update(): Promise<Awaited<Out | void>> {
+        let resourceState: State | undefined = await stateStore.get(resourceID);
+        if (resourceState === undefined) {
+          resourceState = {
+            provider: type,
+            status: "creating",
+            data: {},
+            output: undefined,
+            deps: [...deps],
+            inputs,
+          };
+          await stateStore.set(resourceID, resourceState);
+        }
 
-      // Skip update if inputs haven't changed and resource is in a stable state
-      if (
-        resourceState.status === "created" ||
-        resourceState.status === "updated"
-      ) {
+        // Skip update if inputs haven't changed and resource is in a stable state
         if (
-          JSON.stringify(resourceState.inputs) === JSON.stringify(inputs) &&
-          !resource[Options].alwaysUpdate
+          resourceState.status === "created" ||
+          resourceState.status === "updated"
         ) {
-          if (!options?.quiet) {
-            console.log(`Skip:    ${resourceFQN} (no changes)`);
+          if (
+            JSON.stringify(resourceState.inputs) === JSON.stringify(inputs) &&
+            !resource[Options].alwaysUpdate
+          ) {
+            if (!options?.quiet) {
+              console.log(`Skip:    ${resourceFQN} (no changes)`);
+            }
+            if (resourceState.output !== undefined) {
+              resource[Provide](resourceState.output);
+            }
+            return resourceState.output;
           }
-          if (resourceState.output !== undefined) {
-            resource[Provide](resourceState.output);
-          }
-          return resourceState.output;
         }
-      }
 
-      const event = resourceState.status === "creating" ? "create" : "update";
-      resourceState.status = event === "create" ? "creating" : "updating";
-      resourceState.oldInputs = resourceState.inputs;
-      resourceState.inputs = inputs;
+        const event = resourceState.status === "creating" ? "create" : "update";
+        resourceState.status = event === "create" ? "creating" : "updating";
+        resourceState.oldInputs = resourceState.inputs;
+        resourceState.inputs = inputs;
 
-      if (!options?.quiet) {
-        console.log(
-          `${event === "create" ? "Create" : "Update"}:  ${resourceFQN}`,
-        );
-      }
+        if (!options?.quiet) {
+          console.log(
+            `${event === "create" ? "Create" : "Update"}:  ${resourceFQN}`,
+          );
+        }
 
-      await stateStore.set(resourceID, resourceState);
+        await stateStore.set(resourceID, resourceState);
 
-      let isReplaced = false;
+        let isReplaced = false;
+
+        const quiet = options.quiet ?? false;
+
+        const evaluated = await pushScope(
+          resource[Scope],
+          resourceID,
+          async () => {
+            const result = await func(
+              {
+                stage,
+                resourceID,
+                resourceFQN,
+                event,
+                scope: getScope(),
+                output: resourceState.output,
+                replace: () => {
+                  if (isReplaced) {
+                    console.warn(
+                      `Resource ${type} ${resourceFQN} is already marked as REPLACE`,
+                    );
+                    return;
+                  }
+                  isReplaced = true;
+                  deletions.push({
+                    id: resourceID,
+                    data: {
+                      ...resourceState!.data,
+                    },
+                    inputs: inputs,
+                  });
+                },
+                get: (key) => resourceState!.data[key],
+                set: async (key, value) => {
+                  resourceState!.data[key] = value;
+                  await stateStore.set(resourceID, resourceState!);
+                },
+                delete: async (key) => {
+                  const value = resourceState!.data[key];
+                  delete resourceState!.data[key];
+                  await stateStore.set(resourceID, resourceState!);
+                  return value;
+                },
+                quiet,
+              },
+              ...inputs,
+            );
 
-      const quiet = options.quiet ?? false;
+            if (result === undefined) {
+              return undefined;
+            }
 
-      const evaluated = await pushScope(
-        resource[Scope],
-        resourceID,
-        async () => {
-          const result = await func(
-            {
+            const evaluated = await apply(result as Out, {
               stage,
-              resourceID,
-              event,
               scope: getScope(),
-              output: resourceState.output,
-              replace: () => {
-                if (isReplaced) {
-                  console.warn(
-                    `Resource ${type} ${resourceFQN} is already marked as REPLACE`,
-                  );
-                  return;
-                }
-                isReplaced = true;
-                deletions.push({
-                  id: resourceID,
-                  data: {
-                    ...resourceState!.data,
-                  },
-                  inputs: inputs,
-                });
-              },
-              get: (key) => resourceState!.data[key],
-              set: async (key, value) => {
-                resourceState!.data[key] = value;
-                await stateStore.set(resourceID, resourceState!);
-              },
-              delete: async (key) => {
-                const value = resourceState!.data[key];
-                delete resourceState!.data[key];
-                await stateStore.set(resourceID, resourceState!);
-                return value;
-              },
               quiet,
-            },
-            ...inputs,
-          );
-
-          if (result === undefined) {
-            return undefined;
-          }
-
-          const evaluated = await apply(result as Out, {
-            stage,
-            scope: getScope(),
-            quiet,
-          });
-
-          return evaluated;
-        },
-      );
+            });
 
-      if (!options?.quiet) {
-        console.log(
-          `${event === "create" ? "Created" : "Updated"}: ${resourceFQN}`,
+            return evaluated;
+          },
         );
+
+        if (!options?.quiet) {
+          console.log(
+            `${event === "create" ? "Created" : "Updated"}: ${resourceFQN}`,
+          );
+        }
+        await stateStore.set(resourceID, {
+          provider: type,
+          data: resourceState.data,
+          status: event === "create" ? "created" : "updated",
+          output: evaluated,
+          inputs,
+          deps: [...deps],
+        });
+        if (evaluated !== undefined) {
+          resource[Provide](evaluated as Out);
+        }
+        return evaluated as Awaited<Out>;
       }
-      await stateStore.set(resourceID, {
-        provider: type,
-        data: resourceState.data,
-        status: event === "create" ? "created" : "updated",
-        output: evaluated,
-        inputs,
-        deps: [...deps],
-      });
-      if (evaluated !== undefined) {
-        resource[Provide](evaluated);
-      }
-      return evaluated;
     }
 
     static async delete(
@@ -394,8 +439,9 @@ export function Resource<
       inputs: Args,
       options: DestroyOptions,
     ) {
+      const { Scope } = await import("./scope");
       const resourceFQN = `${scope.getScopePath(stage)}/${resourceID}`;
-      const nestedScope = new IScope(resourceID, scope);
+      const nestedScope = new Scope(resourceID, scope);
 
       await alchemize({
         mode: "destroy",
@@ -415,6 +461,7 @@ export function Resource<
           stage,
           scope,
           resourceID: resourceID,
+          resourceFQN: resourceFQN,
           event: "delete",
           output: state.output,
           replace() {

package/src/scope.ts

@@ -1,10 +1,8 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import path from "node:path";
-import { rootScope } from "./global";
+import type { Output } from "./output";
 import type { Provider, Resource, ResourceID } from "./resource";
 
-const scopeGlobal = new Map<string | null, Scope>();
-
 const scopeStorage = new AsyncLocalStorage<Scope>();
 
 export class Scope {
@@ -16,6 +14,8 @@ export class Scope {
     }
   >();
 
+  public readonly callbacks: Output<void>[] = [];
+
   constructor(
     public readonly scopeName: string | null = null,
     public readonly parent: Scope | undefined = undefined,
@@ -29,6 +29,8 @@ export class Scope {
   }
 }
 
+export const rootScope = new Scope(null);
+
 export function getScope(): Scope {
   return scopeStorage.getStore() ?? rootScope;
 }
@@ -37,13 +39,7 @@ export function withScope<T>(
   scope: Scope,
   fn: () => T | Promise<T>,
 ): Promise<T> {
-  return scopeStorage.run(scope, async () => {
-    try {
-      return await fn();
-    } catch (error) {
-      throw error;
-    }
-  });
+  return scopeStorage.run(scope, async () => fn());
 }
 
 export function pushScope<T>(
@@ -51,6 +47,5 @@ export function pushScope<T>(
   scopeName: string,
   fn: () => T | Promise<T>,
 ): Promise<T> {
-  const newScope = new Scope(scopeName, parent);
-  return withScope(newScope, fn);
+  return scopeStorage.run(new Scope(scopeName, parent), async () => fn());
 }