alchemy-effect 0.5.0 → 0.6.0

package/src/cloudflare/r2/bucket.ts

@@ -23,12 +23,12 @@ export interface Bucket<
   ID extends string = string,
   Props extends BucketProps = BucketProps,
 > extends Resource<
-    "Cloudflare.R2.Bucket",
-    ID,
-    Props,
-    BucketAttr<Props>,
-    Bucket
-  > {}
+  "Cloudflare.R2.Bucket",
+  ID,
+  Props,
+  BucketAttr<Props>,
+  Bucket
+> {}
 
 export const Bucket = Resource<{
   <const ID extends string, const Props extends BucketProps>(

package/src/output.ts

@@ -132,9 +132,11 @@ const proxy = (self: any): any => {
   return proxy;
 };
 
-export abstract class BaseExpr<A = any, Src extends Resource = any, Req = any>
-  implements Output<A, Src, Req>
-{
+export abstract class BaseExpr<
+  A = any,
+  Src extends Resource = any,
+  Req = any,
+> implements Output<A, Src, Req> {
   declare readonly kind: any;
   declare readonly src: Src;
   declare readonly req: Req;

package/src/plan.ts

@@ -11,25 +11,25 @@ import type {
 } from "./binding.ts";
 import type { Capability } from "./capability.ts";
 import type { Diff, NoopDiff, UpdateDiff } from "./diff.ts";
+import { InstanceId } from "./instance-id.ts";
 import * as Output from "./output.ts";
 import type { Instance } from "./policy.ts";
 import type { Provider } from "./provider.ts";
-import { type ProviderService, getProviderByType } from "./provider.ts";
+import { getProviderByType, type ProviderService } from "./provider.ts";
 import type { AnyResource, Resource, ResourceTags } from "./resource.ts";
 import { isService, type IService, type Service } from "./service.ts";
 import {
+  State,
+  StateStoreError,
   type CreatedResourceState,
   type CreatingResourceState,
   type ReplacedResourceState,
   type ReplacingResourceState,
+  type ResourceState,
   type UpdatedResourceState,
   type UpdatingReourceState,
-  State,
-  StateStoreError,
-  type ResourceState,
 } from "./state.ts";
 import { asEffect } from "./util.ts";
-import { InstanceId } from "./instance-id.ts";
 
 export type PlanError = never;
 
@@ -136,8 +136,9 @@ export interface Delete<R extends Resource = AnyResource> extends BaseNode<R> {
   state: ResourceState;
 }
 
-export interface NoopUpdate<R extends Resource = AnyResource>
-  extends BaseNode<R> {
+export interface NoopUpdate<
+  R extends Resource = AnyResource,
+> extends BaseNode<R> {
   action: "noop";
   state: CreatedResourceState | UpdatedResourceState;
 }
@@ -205,7 +206,9 @@ export type TransitiveResources<
                       >
                     ? Src extends Found
                       ? Found
-                      : TransitiveResources<Src, Src | Found>
+                      : string extends Src["id"]
+                        ? Found
+                        : TransitiveResources<Src, Src | Found>
                     : Found;
               }[keyof Resources["props"][prop]];
     }[keyof Resources["props"]],
@@ -292,6 +295,7 @@ export const plan = <const Resources extends (Service | Resource)[]>(
       resourceIds.map((id) =>
         state.get({ stack: app.name, stage: app.stage, resourceId: id }),
       ),
+      { concurrency: "unbounded" },
     );
 
     type ResolveEffect<T> = Effect.Effect<T, ResolveErr, ResolveReq>;
@@ -414,13 +418,16 @@ export const plan = <const Resources extends (Service | Resource)[]>(
         } else if (Output.isExpr(input)) {
           return yield* resolveOutput(input);
         } else if (Array.isArray(input)) {
-          return yield* Effect.all(input.map(resolveInput));
+          return yield* Effect.all(input.map(resolveInput), {
+            concurrency: "unbounded",
+          });
         } else if (typeof input === "object") {
           return Object.fromEntries(
             yield* Effect.all(
               Object.entries(input).map(([key, value]) =>
                 resolveInput(value).pipe(Effect.map((value) => [key, value])),
               ),
+              { concurrency: "unbounded" },
             ),
           );
         }
@@ -441,7 +448,9 @@ export const plan = <const Resources extends (Service | Resource)[]>(
           const upstream = yield* resolveOutput(expr.expr);
           return Output.hasOutputs(upstream) ? expr : yield* expr.f(upstream);
         } else if (Output.isAllExpr(expr)) {
-          return yield* Effect.all(expr.outs.map(resolveOutput));
+          return yield* Effect.all(expr.outs.map(resolveOutput), {
+            concurrency: "unbounded",
+          });
         }
         return yield* Effect.die(new Error("Not implemented yet"));
       });
@@ -754,6 +763,7 @@ export const plan = <const Resources extends (Service | Resource)[]>(
               }
             }),
           ),
+        { concurrency: "unbounded" },
       )).map((update) => [update.resource.id, update]),
     ) as IPlan["resources"];
 
@@ -778,8 +788,8 @@ export const plan = <const Resources extends (Service | Resource)[]>(
                     .read({
                       id,
                       instanceId: oldState.instanceId,
-                      olds: oldState.props as any,
-                      output: oldState.attr as any,
+                      olds: oldState.props as never,
+                      output: oldState.attr as never,
                       bindings: oldState.bindings ?? [],
                     })
                     .pipe(
@@ -788,11 +798,6 @@ export const plan = <const Resources extends (Service | Resource)[]>(
                       ),
                     );
                 }
-                if (attr === undefined) {
-                  // skip deletion if we have no record of any attributes
-                  // TODO(sam): should we open up provider.delete to accept undefined and let it try and generate a physical name and delete?
-                  return undefined;
-                }
               }
               return [
                 id,
@@ -815,6 +820,7 @@ export const plan = <const Resources extends (Service | Resource)[]>(
             }
           }),
         ),
+        { concurrency: "unbounded" },
       )).filter((v) => !!v),
     );
 
@@ -948,9 +954,9 @@ const diffBindings = Effect.fn(function* ({
     },
   );
 
-  return (yield* Effect.all(bindings.map(diffBinding))).filter(
-    (action): action is BindNode => action !== null,
-  );
+  return (yield* Effect.all(bindings.map(diffBinding), {
+    concurrency: "unbounded",
+  })).filter((action): action is BindNode => action !== null);
 });
 
 const isBindingDiff = Effect.fn(function* ({

package/src/provider.ts

@@ -7,17 +7,18 @@ import type { Resource } from "./resource.ts";
 import type { Runtime } from "./runtime.ts";
 import type { Service } from "./service.ts";
 
-export interface Provider<R extends Resource | Service>
-  extends Context.TagClass<
-    Provider<R>,
-    R["type"],
-    ProviderService<any>
-    // TODO(sam): we are using any here because the R["type"] is enough and gaining access to the sub type (e.g. SQS.Queue)
-    // is currently not possible in the current approach
+export interface Provider<
+  R extends Resource | Service,
+> extends Context.TagClass<
+  Provider<R>,
+  R["type"],
+  ProviderService<any>
+  // TODO(sam): we are using any here because the R["type"] is enough and gaining access to the sub type (e.g. SQS.Queue)
+  // is currently not possible in the current approach
 
-    // preferred:
-    // ProviderService<R>
-  > {}
+  // preferred:
+  // ProviderService<R>
+> {}
 
 type BindingData<Res extends Resource> = [Res] extends [Runtime]
   ? Res["binding"][]
@@ -48,7 +49,7 @@ export interface ProviderService<
   read?(input: {
     id: string;
     instanceId: string;
-    olds: Props<Res> | undefined;
+    olds: Props<Res>;
     // what is the ARN?
     output: Res["attr"] | undefined; // current state -> synced state
     bindings: BindingData<Res>;

package/src/runtime.ts

@@ -58,8 +58,8 @@ export interface Runtime<
   Type extends string = string,
   Handler = unknown,
   Props = unknown,
-> extends IRuntime<Type, Handler, Props>,
-    Resource<Type, string, Props> {
+>
+  extends IRuntime<Type, Handler, Props>, Resource<Type, string, Props> {
   provider: ResourceTags<this>;
   <
     const ID extends string,

package/src/tags.ts

@@ -37,6 +37,35 @@ export const createTagger = Effect.fn(function* () {
   });
 });
 
+/**
+ * Creates AWS-compatible tag filters for finding resources by alchemy tags.
+ * Use with AWS describe APIs that accept Filter parameters.
+ */
+export const createAlchemyTagFilters = Effect.fn(function* (id: string) {
+  const app = yield* App;
+  return [
+    { Name: "tag:alchemy::app", Values: [app.name] },
+    { Name: "tag:alchemy::stage", Values: [app.stage] },
+    { Name: "tag:alchemy::id", Values: [id] },
+  ];
+});
+
+/**
+ * Checks if a resource has the expected alchemy tags for this app/stage/id.
+ */
+export const hasAlchemyTags = Effect.fn(function* (
+  id: string,
+  tags: Tags | undefined,
+) {
+  const app = yield* App;
+  const expectedTags = {
+    "alchemy::app": app.name,
+    "alchemy::stage": app.stage,
+    "alchemy::id": id,
+  };
+  return hasTags(expectedTags, tags);
+});
+
 export const diffTags = (
   oldTags: Record<string, string>,
   newTags: Record<string, string>,