alchemy 0.1.12 → 0.1.13

package/src/destroy.ts

@@ -1,7 +1,7 @@
-import { defaultStage, defaultStateStore, rootScope } from "./global";
+import { defaultStage, defaultStateStore } from "./global";
 import type { Output } from "./output";
 import { Provider, ResourceID, isResource } from "./resource";
-import type { Scope } from "./scope";
+import { type Scope, rootScope } from "./scope";
 import type { State, StateStore } from "./state";
 
 export interface DestroyOptions {

package/src/esbuild.ts

@@ -60,6 +60,9 @@ export interface BundleOutput {
 
 export class Bundle extends Resource(
   "esbuild::Bundle",
+  {
+    alwaysUpdate: true,
+  },
   async (ctx, props: BundleProps): Promise<BundleOutput> => {
     // Determine output path
     const outputPath = getOutputPath(props);

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 {
@@ -52,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

@@ -1,8 +1,10 @@
+export * from "./$";
 export * from "./alchemize";
 export * from "./error";
 export * from "./global";
 export * from "./input";
 export * from "./output";
+export * from "./print";
 export {
   Resource,
   type Context,
@@ -10,5 +12,4 @@ export {
   type DeleteContext,
   type UpdateContext,
 } from "./resource";
-
 export type { FileSystemStateStore as StateStore } from "./state";

package/src/output.ts

@@ -16,18 +16,34 @@ export interface Output<T> {
 }
 
 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);
   }
 }
 
-export type Resolve<O> = O extends Output<infer U>
+export type Resolved<O> = O extends Output<infer U>
   ? U
   : O extends null
     ? O
@@ -35,12 +51,12 @@ export type Resolve<O> = O extends Output<infer U>
       ? ResolveN<O>
       : O extends object
         ? {
-            [k in keyof O]: Resolve<O[k]>;
+            [k in keyof O]: Resolved<O[k]>;
           }
         : O;
 
 type ResolveN<O extends any[]> = O extends [infer First, ...infer Rest]
-  ? [Resolve<First>, ...ResolveN<Rest>]
+  ? [Resolved<First>, ...ResolveN<Rest>]
   : [];
 
 // export data from a resource

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 { type Export, type Output, OutputChain, type Resolve } 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,
@@ -50,13 +55,14 @@ export type Resource<In extends any[] = any[], Out = any> = {
   Export<
     // the resource handler may export another Output - we need to resolve it first
     // then, export that resolved value
-    Resolve<Out>
+    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>;
@@ -119,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,
@@ -172,6 +184,8 @@ export function Resource<
 
   interface Resource {
     [ResourceID]: ResourceID;
+    [ResourceFQN]: string;
+    [ResourceHandle]: Object;
     [Provider]: Provider<Type, Args, Out>;
     [Input]: Inputs<Args>;
     [Value]?: Out;
@@ -196,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;
@@ -216,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]);
           }
@@ -223,6 +244,10 @@ 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 OutputChain<Out, U>(this as any, fn);
     }
@@ -264,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 as Out);
-      }
-      return evaluated as Awaited<Out>;
     }
 
     static async delete(
@@ -400,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",
@@ -421,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());
 }