alchemy-effect 0.3.0 → 0.4.0

package/src/provider.ts

@@ -1,11 +1,11 @@
 import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
+import * as Effect from "effect/Effect";
+import type { ScopedPlanStatusSession } from "./cli/service.ts";
 import type { Diff } from "./diff.ts";
 import type { Input } from "./input.ts";
 import type { Resource } from "./resource.ts";
 import type { Runtime } from "./runtime.ts";
 import type { Service } from "./service.ts";
-import type { ScopedPlanStatusSession } from "./cli/service.ts";
 
 export interface Provider<R extends Resource | Service>
   extends Context.TagClass<
@@ -25,7 +25,21 @@ type BindingData<Res extends Resource> = [Res] extends [Runtime]
 
 type Props<Res extends Resource> = Input.ResolveOpaque<Res["props"]>;
 
-export interface ProviderService<Res extends Resource = Resource> {
+export interface ProviderService<
+  Res extends Resource = Resource,
+  ReadReq = never,
+  DiffReq = never,
+  PrecreateReq = never,
+  CreateReq = never,
+  UpdateReq = never,
+  DeleteReq = never,
+> {
+  /**
+   * The version of the provider.
+   *
+   * @default 0
+   */
+  version?: number;
   // tail();
   // watch();
   // replace(): Effect.Effect<void, never, never>;
@@ -33,44 +47,67 @@ export interface ProviderService<Res extends Resource = Resource> {
   // run?() {}
   read?(input: {
     id: string;
+    instanceId: string;
     olds: Props<Res> | undefined;
     // what is the ARN?
     output: Res["attr"] | undefined; // current state -> synced state
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect.Effect<Res["attr"] | undefined, any, never>;
+  }): Effect.Effect<Res["attr"] | undefined, any, ReadReq>;
+  /**
+   * Properties that are always stable across any update.
+   */
+  stables?: Extract<keyof Res["attr"], string>[];
   diff?(input: {
     id: string;
     olds: Props<Res>;
+    instanceId: string;
     // Note: we do not resolve (Props<Res>) here because diff runs during plan
     // -> we need a way for the diff handlers to work with Outputs
     news: Res["props"];
     output: Res["attr"];
-  }): Effect.Effect<Diff | void, never, never>;
+  }): Effect.Effect<Diff | void, never, DiffReq>;
   precreate?(input: {
     id: string;
     news: Props<Res>;
+    instanceId: string;
     session: ScopedPlanStatusSession;
-  }): Effect.Effect<Res["attr"], any, never>;
+  }): Effect.Effect<Res["attr"], any, PrecreateReq>;
   create(input: {
     id: string;
+    instanceId: string;
     news: Props<Res>;
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect.Effect<Res["attr"], any, never>;
+  }): Effect.Effect<Res["attr"], any, CreateReq>;
   update(input: {
     id: string;
+    instanceId: string;
     news: Props<Res>;
     olds: Props<Res>;
     output: Res["attr"];
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect.Effect<Res["attr"], any, never>;
+  }): Effect.Effect<Res["attr"], any, UpdateReq>;
   delete(input: {
     id: string;
+    instanceId: string;
     olds: Props<Res>;
     output: Res["attr"];
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect.Effect<void, any, never>;
+  }): Effect.Effect<void, any, DeleteReq>;
 }
+
+export const getProviderByType = Effect.fnUntraced(function* (
+  resourceType: string,
+) {
+  const context = yield* Effect.context<never>();
+  const provider: ProviderService = context.unsafeMap.get(resourceType);
+  if (!provider) {
+    return yield* Effect.die(
+      new Error(`Provider not found for ${resourceType}`),
+    );
+  }
+  return provider;
+});

package/src/resource.ts

@@ -40,10 +40,56 @@ export interface Resource<
 export interface ResourceTags<R extends Resource<string, string, any, any>> {
   of<S extends ProviderService<R>>(service: S): S;
   tag: Provider<R>;
-  effect<Err, Req>(
-    eff: Effect<ProviderService<R>, Err, Req>,
-  ): Layer.Layer<Provider<R>, Err, Req>;
-  succeed(service: ProviderService<R>): Layer.Layer<Provider<R>>;
+  effect<
+    Err,
+    Req,
+    ReadReq = never,
+    DiffReq = never,
+    PrecreateReq = never,
+    CreateReq = never,
+    UpdateReq = never,
+    DeleteReq = never,
+  >(
+    eff: Effect<
+      ProviderService<
+        R,
+        ReadReq,
+        DiffReq,
+        PrecreateReq,
+        CreateReq,
+        UpdateReq,
+        DeleteReq
+      >,
+      Err,
+      Req
+    >,
+  ): Layer.Layer<
+    Provider<R>,
+    Err,
+    Req | ReadReq | DiffReq | PrecreateReq | CreateReq | UpdateReq | DeleteReq
+  >;
+  succeed<
+    ReadReq = never,
+    DiffReq = never,
+    PrecreateReq = never,
+    CreateReq = never,
+    UpdateReq = never,
+    DeleteReq = never,
+  >(
+    service: ProviderService<
+      R,
+      ReadReq,
+      DiffReq,
+      PrecreateReq,
+      CreateReq,
+      UpdateReq,
+      DeleteReq
+    >,
+  ): Layer.Layer<
+    Provider<R>,
+    never,
+    ReadReq | DiffReq | PrecreateReq | CreateReq | UpdateReq | DeleteReq
+  >;
 }
 
 export const Resource = <Ctor extends (id: string, props: any) => Resource>(

package/src/state.ts

@@ -52,22 +52,114 @@ import { isResource } from "./resource.ts";
 
 // Scrap the "key-value" store on State/Scope
 
-export type ResourceStatus =
-  | "creating"
-  | "created"
-  | "updating"
-  | "updated"
-  | "deleting"
-  | "deleted";
-
-export type ResourceState = {
-  type: string;
-  id: string;
+export type Props = Record<string, any>;
+export type Attr = Record<string, any>;
+
+export type ResourceStatus = ResourceState["status"];
+
+interface BaseResourceState {
+  resourceType: string;
+  /** Logical ID of the Resource (stable across creates, updates, deletes and replaces) */
+  logicalId: string;
+  /** A unique randomly generated token used to seed ID generation (only changes when replaced) */
+  instanceId: string;
+  /** The version of the provider that was used to create/update the resource. */
+  providerVersion: number;
+  /** Current status of the logical Resource */
   status: ResourceStatus;
-  props: any;
-  output: any;
+  /** List of logical IDs of resources that depend on this resource */
+  downstream: string[];
+  /** List of Bindings attached to this Resource */
   bindings?: BindNode[];
-};
+  /** Desired state (input props) of this Resource */
+  props?: Props;
+  /** The output attributes of this Resource (if it has been created) */
+  attr?: Attr;
+}
+
+export interface CreatingResourceState extends BaseResourceState {
+  status: "creating";
+  /** The new resource properties that are being (or have been) applied. */
+  props: Props;
+}
+
+export interface CreatedResourceState extends BaseResourceState {
+  status: "created";
+  /** The new resource properties that have been applied. */
+  props: Props;
+  /** The output attributes of the created resource */
+  attr: Attr;
+}
+
+export interface UpdatingReourceState extends BaseResourceState {
+  status: "updating";
+  /** The new resource properties that are being (or have been) applied. */
+  props: Props;
+  old: {
+    /** The old resource properties that have been successfully applied. */
+    props: Props;
+    /** The old output properties that have been successfully applied. */
+    attr: Attr;
+    // TODO(sam): do I need to track the old downstream edges?
+    // downstream: string[];
+  };
+}
+
+export interface UpdatedResourceState extends BaseResourceState {
+  status: "updated";
+  /** The new resource properties that are being (or have been) applied. */
+  props: Props;
+  /** The output attributes of the created resource */
+  attr: Attr;
+}
+
+export interface DeletingResourceState extends BaseResourceState {
+  status: "deleting";
+  /** Attributes of the resource being deleted */
+  attr: Attr | undefined;
+}
+
+export interface ReplacingResourceState extends BaseResourceState {
+  status: "replacing";
+  /** Desired properties of the new resource (the replacement) */
+  props: Props;
+  /** Reference to the state of the old resource (the one being replaced) */
+  old:
+    | CreatedResourceState
+    | UpdatedResourceState
+    | CreatingResourceState
+    | UpdatingReourceState
+    | DeletingResourceState;
+  /** Whether the resource should be deleted before or after replacements */
+  deleteFirst: boolean;
+}
+
+export interface ReplacedResourceState extends BaseResourceState {
+  status: "replaced";
+  /** Desired properties of the new resource (the replacement) */
+  props: Props;
+  /** Output attributes of the new resource (the replacement) */
+  attr: Attr;
+  /** Reference to the state of the old resource (the one being replaced) */
+  old:
+    | CreatingResourceState
+    | CreatedResourceState
+    | UpdatingReourceState
+    | UpdatedResourceState
+    | DeletingResourceState;
+  /** Whether the resource should be deleted before or after replacements */
+  deleteFirst: boolean;
+  // .. will (finally) transition to `CreatedResourceState` after finalizing
+}
+
+export type ResourceState =
+  | CreatingResourceState
+  | CreatedResourceState
+  | UpdatingReourceState
+  | UpdatedResourceState
+  | DeletingResourceState
+  | ReplacingResourceState
+  | ReplacedResourceState;
 
 export class StateStoreError extends Data.TaggedError("StateStoreError")<{
   message: string;
@@ -82,6 +174,10 @@ export interface StateService {
     stage: string;
     resourceId: string;
   }): Effect.Effect<ResourceState | undefined, StateStoreError, never>;
+  getReplacedResources(request: {
+    stack: string;
+    stage: string;
+  }): Effect.Effect<ReplacedResourceState[], StateStoreError, never>;
   set<V extends ResourceState>(request: {
     stack: string;
     stage: string;
@@ -107,7 +203,6 @@ export class State extends Context.Tag("AWS::Lambda::State")<
 // TODO(sam): implement with SQLite3
 export const localFs = Layer.effect(
   State,
-  // @ts-expect-error -
   Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
@@ -146,8 +241,8 @@ export const localFs = Layer.effect(
       fs.makeDirectory(dir, { recursive: true }),
     );
 
-    return {
-      listApps: () =>
+    const state: StateService = {
+      listStacks: () =>
         fs.readDirectory(stateDir).pipe(
           recover,
           Effect.map((files) => files ?? []),
@@ -162,6 +257,17 @@ export const localFs = Layer.effect(
           Effect.map((file) => JSON.parse(file.toString())),
           recover,
         ),
+      getReplacedResources: Effect.fnUntraced(function* (request) {
+        return (yield* Effect.all(
+          (yield* state.list(request)).map((resourceId) =>
+            state.get({
+              stack: request.stack,
+              stage: request.stage,
+              resourceId,
+            }),
+          ),
+        )).filter((r) => r?.status === "replaced");
+      }),
       set: (request) =>
         ensure(stage(request)).pipe(
           Effect.flatMap(() =>
@@ -196,6 +302,7 @@ export const localFs = Layer.effect(
           ),
         ),
     };
+    return state;
   }),
 );
 
@@ -221,22 +328,14 @@ export const inMemoryService = (
     Record<StageId, Record<ResourceId, ResourceState>>
   > = {},
 ) => {
-  const state = new Map<StackId, Map<StageId, Map<ResourceId, ResourceState>>>(
-    Object.entries(initialState).map(([stack, stages]) => [
-      stack,
-      new Map(
-        Object.entries(stages).map(([stage, resources]) => [
-          stage,
-          new Map(Object.entries(resources)),
-        ]),
-      ),
-    ]),
-  );
+  const state = initialState;
   return {
-    listStacks: () => Effect.succeed(Array.from(state.keys())),
+    listStacks: () => Effect.succeed(Array.from(Object.keys(state))),
     // oxlint-disable-next-line require-yield
     listStages: (stack: string) =>
-      Effect.succeed(Array.from(state.get(stack)?.keys() ?? [])),
+      Effect.succeed(
+        Array.from(stack in state ? Object.keys(state[stack]) : []),
+      ),
     get: ({
       stack,
       stage,
@@ -245,7 +344,19 @@ export const inMemoryService = (
       stack: string;
       stage: string;
       resourceId: string;
-    }) => Effect.succeed(state.get(stack)?.get(stage)?.get(resourceId)),
+    }) => Effect.succeed(state[stack]?.[stage]?.[resourceId]),
+    getReplacedResources: ({
+      stack,
+      stage,
+    }: {
+      stack: string;
+      stage: string;
+    }) =>
+      Effect.succeed(
+        Array.from(Object.values(state[stack]?.[stage] ?? {}) ?? []).filter(
+          (s) => s.status === "replaced",
+        ),
+      ),
     set: <V extends ResourceState>({
       stack,
       stage,
@@ -257,7 +368,9 @@ export const inMemoryService = (
       resourceId: string;
       value: V;
     }) => {
-      state.get(stack)?.get(stage)?.set(resourceId, value);
+      const stackState = (state[stack] ??= {});
+      const stageState = (stackState[stage] ??= {});
+      stageState[resourceId] = value;
       return Effect.succeed(value);
     },
     delete: ({
@@ -268,8 +381,10 @@ export const inMemoryService = (
       stack: string;
       stage: string;
       resourceId: string;
-    }) => Effect.succeed(state.get(stack)?.get(stage)?.delete(resourceId)),
+    }) => Effect.succeed(delete state[stack]?.[stage]?.[resourceId]),
     list: ({ stack, stage }: { stack: string; stage: string }) =>
-      Effect.succeed(Array.from(state.get(stack)?.get(stage)?.keys() ?? [])),
-  };
+      Effect.succeed(
+        Array.from(Object.keys(state[stack]?.[stage] ?? {}) ?? []),
+      ),
+  } satisfies StateService;
 };

package/src/tags.ts

@@ -36,3 +36,34 @@ export const createTagger = Effect.fn(function* () {
     "alchemy::id": id,
   });
 });
+
+export const diffTags = (
+  oldTags: Record<string, string>,
+  newTags: Record<string, string>,
+) => {
+  const removed: string[] = [];
+  const updated: { Key: string; Value: string }[] = [];
+  const added: { Key: string; Value: string }[] = [];
+  for (const key in oldTags) {
+    if (!(key in newTags)) {
+      removed.push(key);
+    } else if (oldTags[key] !== newTags[key]) {
+      updated.push({ Key: key, Value: newTags[key] });
+    }
+  }
+  for (const key in newTags) {
+    if (!(key in oldTags)) {
+      added.push({ Key: key, Value: newTags[key] });
+    } else if (oldTags[key] !== newTags[key]) {
+      updated.push({ Key: key, Value: newTags[key] });
+    }
+  }
+  return {
+    added,
+    removed,
+    updated,
+    upsert: [...added, ...updated].filter(
+      (tag, index, self) => self.findIndex((t) => t.Key === tag.Key) === index,
+    ),
+  };
+};

package/src/test.ts

@@ -1,18 +1,18 @@
 import { FetchHttpClient, FileSystem, HttpClient } from "@effect/platform";
-import * as PlatformConfigProvider from "@effect/platform/PlatformConfigProvider";
 import { NodeContext } from "@effect/platform-node";
 import * as Path from "@effect/platform/Path";
-import { it, expect } from "@effect/vitest";
+import * as PlatformConfigProvider from "@effect/platform/PlatformConfigProvider";
+import { expect, it } from "@effect/vitest";
 import { ConfigProvider, LogLevel } from "effect";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
 import * as Scope from "effect/Scope";
 import * as App from "./app.ts";
+import { CLI } from "./cli/service.ts";
 import { DotAlchemy, dotAlchemy } from "./dot-alchemy.ts";
-import * as State from "./state.ts";
 import type { Resource } from "./resource.ts";
-import { CLI } from "./cli/service.ts";
+import * as State from "./state.ts";
 
 declare module "@effect/vitest" {
   interface ExpectStatic {
@@ -165,7 +165,7 @@ export const testCLI = Layer.succeed(
           Effect.log(
             event.kind === "status-change"
               ? `${event.status} ${event.id}(${event.type})`
-              : event.message,
+              : `${event.id}: ${event.message}`,
           ),
       }),
   }),

package/src/todo.ts

@@ -0,0 +1,4 @@
+import * as Effect from "effect/Effect";
+
+export const todo = (message?: string) =>
+  Effect.dieMessage(message ?? `Not implemented`);