alchemy-effect 0.2.0 → 0.4.0

package/src/state.ts

@@ -5,7 +5,6 @@ import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { App } from "./app.ts";
 import type { BindNode } from "./plan.ts";
 import { isResource } from "./resource.ts";
 
@@ -53,40 +52,147 @@ 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;
 }> {}
 
 export interface StateService {
-  listApps(): Effect.Effect<string[], StateStoreError, never>;
-  listStages(appName?: string): Effect.Effect<string[], StateStoreError, never>;
+  listStacks(): Effect.Effect<string[], StateStoreError, never>;
+  listStages(stack: string): Effect.Effect<string[], StateStoreError, never>;
   // stub
-  get(
-    id: string,
-  ): Effect.Effect<ResourceState | undefined, StateStoreError, never>;
-  set<V extends ResourceState>(
-    id: string,
-    value: V,
-  ): Effect.Effect<V, StateStoreError, never>;
-  delete(id: string): Effect.Effect<void, StateStoreError, never>;
-  list(): Effect.Effect<string[], StateStoreError, never>;
+  get(request: {
+    stack: string;
+    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;
+    resourceId: string;
+    value: V;
+  }): Effect.Effect<V, StateStoreError, never>;
+  delete(request: {
+    stack: string;
+    stage: string;
+    resourceId: string;
+  }): Effect.Effect<void, StateStoreError, never>;
+  list(request: {
+    stack: string;
+    stage: string;
+  }): Effect.Effect<string[], StateStoreError, never>;
 }
 
 export class State extends Context.Tag("AWS::Lambda::State")<
@@ -98,13 +204,10 @@ export class State extends Context.Tag("AWS::Lambda::State")<
 export const localFs = Layer.effect(
   State,
   Effect.gen(function* () {
-    const app = yield* App;
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const dotAlchemy = path.join(process.cwd(), ".alchemy");
     const stateDir = path.join(dotAlchemy, "state");
-    const appDir = path.join(stateDir, app.name);
-    const stageDir = path.join(appDir, app.stage);
 
     const fail = (err: PlatformError) =>
       Effect.fail(
@@ -121,77 +224,167 @@ export const localFs = Layer.effect(
         Effect.catchTag("BadArgument", (e) => fail(e)),
       );
 
-    const resourceFile = (id: string) => path.join(stageDir, `${id}.json`);
+    const stage = ({ stack, stage }: { stack: string; stage: string }) =>
+      path.join(stateDir, stack, stage);
+
+    const resource = ({
+      stack,
+      stage,
+      resourceId,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+    }) => path.join(stateDir, stack, stage, `${resourceId}.json`);
 
-    yield* fs.makeDirectory(stageDir, { recursive: true });
+    const ensure = yield* Effect.cachedFunction((dir: string) =>
+      fs.makeDirectory(dir, { recursive: true }),
+    );
 
-    return {
-      listApps: () =>
+    const state: StateService = {
+      listStacks: () =>
         fs.readDirectory(stateDir).pipe(
           recover,
           Effect.map((files) => files ?? []),
         ),
-      listStages: (appName: string = app.name) =>
-        fs.readDirectory(path.join(stateDir, appName)).pipe(
+      listStages: (stack: string) =>
+        fs.readDirectory(path.join(stateDir, stack)).pipe(
           recover,
           Effect.map((files) => files ?? []),
         ),
-      get: (id) =>
-        fs.readFile(resourceFile(id)).pipe(
+      get: (request) =>
+        fs.readFile(resource(request)).pipe(
           Effect.map((file) => JSON.parse(file.toString())),
           recover,
         ),
-      set: <V extends ResourceState>(id: string, value: V) =>
-        fs
-          .writeFileString(
-            resourceFile(id),
-            JSON.stringify(
-              value,
-              (k, v) => {
-                if (isResource(v)) {
-                  return {
-                    id: v.id,
-                    type: v.type,
-                    props: v.props,
-                    attr: v.attr,
-                  };
-                }
-                return v;
-              },
-              2,
+      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(() =>
+            fs.writeFileString(
+              resource(request),
+              JSON.stringify(
+                request.value,
+                (k, v) => {
+                  if (isResource(v)) {
+                    return {
+                      id: v.id,
+                      type: v.type,
+                      props: v.props,
+                      attr: v.attr,
+                    };
+                  }
+                  return v;
+                },
+                2,
+              ),
             ),
-          )
-          .pipe(
-            recover,
-            Effect.map(() => value),
           ),
-      delete: (id) => fs.remove(resourceFile(id)).pipe(recover),
-      list: () =>
-        fs.readDirectory(stageDir).pipe(
+          recover,
+          Effect.map(() => request.value),
+        ),
+      delete: (request) => fs.remove(resource(request)).pipe(recover),
+      list: (request) =>
+        fs.readDirectory(stage(request)).pipe(
           recover,
           Effect.map(
             (files) => files?.map((file) => file.replace(/\.json$/, "")) ?? [],
           ),
         ),
     };
+    return state;
   }),
 );
 
-export const inMemory = () => {
-  const state = new Map<string, any>();
-  return Layer.succeed(State, {
-    listApps: () => Effect.succeed([]),
+type StackId = string;
+type StageId = string;
+type ResourceId = string;
+
+export const inMemory = (
+  initialState: Record<
+    StackId,
+    Record<StageId, Record<ResourceId, ResourceState>>
+  > = {},
+) =>
+  Layer.succeed(State, inMemoryService(initialState)) as Layer.Layer<
+    State,
+    never,
+    never
+  >;
+
+export const inMemoryService = (
+  initialState: Record<
+    StackId,
+    Record<StageId, Record<ResourceId, ResourceState>>
+  > = {},
+) => {
+  const state = initialState;
+  return {
+    listStacks: () => Effect.succeed(Array.from(Object.keys(state))),
     // oxlint-disable-next-line require-yield
-    listStages: (_appName?: string) => Effect.succeed([]),
-    get: (id: string) => Effect.succeed(state.get(id)),
-    set: <V>(id: string, value: V) => {
-      state.set(id, value);
+    listStages: (stack: string) =>
+      Effect.succeed(
+        Array.from(stack in state ? Object.keys(state[stack]) : []),
+      ),
+    get: ({
+      stack,
+      stage,
+      resourceId,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+    }) => 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,
+      resourceId,
+      value,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+      value: V;
+    }) => {
+      const stackState = (state[stack] ??= {});
+      const stageState = (stackState[stage] ??= {});
+      stageState[resourceId] = value;
       return Effect.succeed(value);
     },
-    delete: (id: string) => {
-      state.delete(id);
-      return Effect.succeed(undefined);
-    },
-    list: () => Effect.succeed(Array.from(state.keys())),
-  });
+    delete: ({
+      stack,
+      stage,
+      resourceId,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+    }) => Effect.succeed(delete state[stack]?.[stage]?.[resourceId]),
+    list: ({ stack, stage }: { stack: string; stage: string }) =>
+      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,17 +1,42 @@
 import { FetchHttpClient, FileSystem, HttpClient } from "@effect/platform";
 import { NodeContext } from "@effect/platform-node";
-import type * as Path from "@effect/platform/Path";
-import { it } from "@effect/vitest";
-import { LogLevel } from "effect";
+import * as Path from "@effect/platform/Path";
+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 { PlanStatusReporter } from "./apply.ts";
+import { CLI } from "./cli/service.ts";
 import { DotAlchemy, dotAlchemy } from "./dot-alchemy.ts";
+import type { Resource } from "./resource.ts";
 import * as State from "./state.ts";
 
+declare module "@effect/vitest" {
+  interface ExpectStatic {
+    emptyObject(): any;
+    propExpr(identifier: string, src: Resource): any;
+  }
+}
+
+expect.emptyObject = () =>
+  expect.toSatisfy(
+    (deletions) => Object.keys(deletions).length === 0,
+    "empty object",
+  );
+
+expect.propExpr = (identifier: string, src: Resource) =>
+  expect.objectContaining({
+    kind: "PropExpr",
+    identifier,
+    expr: expect.objectContaining({
+      kind: "ResourceExpr",
+      src,
+    }),
+  });
+
 type Provided =
   | Scope.Scope
   | App.App
@@ -21,11 +46,34 @@ type Provided =
   | FileSystem.FileSystem
   | Path.Path;
 
+export function test(
+  name: string,
+  options: {
+    timeout?: number;
+    state?: Layer.Layer<State.State, never, App.App>;
+  },
+  testCase: Effect.Effect<void, any, Provided>,
+): void;
+
 export function test(
   name: string,
   testCase: Effect.Effect<void, any, Provided>,
-  timeout: number = 120_000,
+): void;
+
+export function test(
+  name: string,
+  ...args:
+    | [
+        {
+          timeout?: number;
+          state?: Layer.Layer<State.State, never, App.App>;
+        },
+        Effect.Effect<void, any, Provided>,
+      ]
+    | [Effect.Effect<void, any, Provided>]
 ) {
+  const [options = {}, testCase] =
+    args.length === 1 ? [undefined, args[0]] : args;
   const platform = Layer.mergeAll(
     NodeContext.layer,
     FetchHttpClient.layer,
@@ -33,9 +81,18 @@ export function test(
   );
 
   const alchemy = Layer.provideMerge(
-    Layer.mergeAll(State.localFs, report),
+    Layer.mergeAll(options.state ?? State.localFs, testCLI),
     Layer.mergeAll(
-      App.make({ name: name.replaceAll(/[^a-zA-Z0-9_]/g, "-"), stage: "test" }),
+      App.make({
+        name: name.replaceAll(/[^a-zA-Z0-9_]/g, "-"),
+        stage: "test",
+        config: {
+          adopt: true,
+          aws: {
+            profile: "default",
+          },
+        },
+      }),
       dotAlchemy,
     ),
   );
@@ -43,29 +100,73 @@ export function test(
   return it.scopedLive(
     name,
     () =>
-      testCase.pipe(
+      Effect.gen(function* () {
+        const configProvider = ConfigProvider.orElse(
+          yield* PlatformConfigProvider.fromDotEnv(".env"),
+          ConfigProvider.fromEnv,
+        );
+        return yield* testCase.pipe(Effect.withConfigProvider(configProvider));
+      }).pipe(
         Effect.provide(Layer.provideMerge(alchemy, platform)),
         Logger.withMinimumLogLevel(
           process.env.DEBUG ? LogLevel.Debug : LogLevel.Info,
         ),
+        Effect.provide(NodeContext.layer),
+        Effect.provide(NodeContext.layer),
       ),
-    timeout,
+    options.timeout,
   );
 }
 
-export const report = Layer.succeed(
-  PlanStatusReporter,
-  PlanStatusReporter.of({
-    start: Effect.fn(function* (plan) {
-      return {
+export namespace test {
+  export const state = (resources: Record<string, State.ResourceState> = {}) =>
+    Layer.effect(
+      State.State,
+      Effect.gen(function* () {
+        const app = yield* App.App;
+        return State.inMemoryService({
+          [app.name]: {
+            [app.stage]: resources,
+          },
+        });
+      }),
+    );
+
+  export const defaultState = (
+    resources: Record<string, State.ResourceState> = {},
+    other?: {
+      [stack: string]: {
+        [stage: string]: {
+          [resourceId: string]: State.ResourceState;
+        };
+      };
+    },
+  ) =>
+    Layer.succeed(
+      State.State,
+      State.inMemoryService({
+        ["test-app"]: {
+          ["test-stage"]: resources,
+        },
+        ...other,
+      }),
+    );
+}
+
+export const testCLI = Layer.succeed(
+  CLI,
+  CLI.of({
+    approvePlan: () => Effect.succeed(true),
+    displayPlan: () => Effect.void,
+    startApplySession: () =>
+      Effect.succeed({
         done: () => Effect.void,
         emit: (event) =>
           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`);

package/src/type.ts

@@ -1,2 +1,6 @@
 export type type<T> = new () => T;
 export const type = class {} as new <T>() => T;
+
+export declare namespace type {
+  export type of<T extends type<any>> = InstanceType<T>;
+}

package/src/unknown.ts

@@ -0,0 +1,6 @@
+import { type Output, isOutput } from "./output.ts";
+import type { Input } from "./input.ts";
+
+// @ts-expect-error - we want to allow any value to be checked for unknown
+export const isUnknown = <V>(value: V): value is Output<Input.Resolve<V>> =>
+  isOutput(value);

package/src/user.ts

@@ -0,0 +1,4 @@
+import { env } from "./env.ts";
+
+export type USER = typeof USER;
+export const USER = env.USER ?? env.USERNAME ?? "unknown";

package/src/util.ts

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+
+export type UnionToIntersection<U> = (
+  U extends any ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never;
+
+export const assertDefined = <T>(value: T | undefined, message: string): T => {
+  if (!value) {
+    throw new Error(message);
+  }
+  return value;
+};
+
+export const asEffect = <T, Err = never, Req = never>(
+  effect: T | Effect.Effect<T, Err, Req>,
+): Effect.Effect<T, Err, Req> =>
+  Effect.isEffect(effect) ? effect : Effect.succeed(effect);