alchemy-effect 0.5.0 → 0.6.2

package/src/Server/SQSQueueEventSource.ts

@@ -0,0 +1,77 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+
+import { Region } from "@distilled.cloud/aws/Region";
+import * as SQS from "../AWS/SQS/index.ts";
+import { ServerHost } from "./Process.ts";
+
+export const SQSQueueEventSource = Layer.effect(
+  SQS.QueueEventSource,
+  Effect.gen(function* () {
+    const { run } = yield* ServerHost;
+    const region = yield* Region;
+
+    const ReceiveMessage = yield* SQS.ReceiveMessage;
+    const DeleteMessageBatch = yield* SQS.DeleteMessageBatch;
+
+    return Effect.fn(function* <StreamReq = never, Req = never>(
+      queue: SQS.Queue,
+      props: SQS.QueueEventSourceProps,
+      process: (
+        stream: Stream.Stream<SQS.SQSRecord, never, StreamReq>,
+      ) => Effect.Effect<void, never, Req | StreamReq>,
+    ) {
+      const QueueArn = yield* queue.queueArn;
+
+      const receiveMessage = yield* ReceiveMessage(queue);
+      const deleteMessageBatch = yield* DeleteMessageBatch(queue);
+
+      yield* run(
+        Effect.forever(
+          Effect.gen(function* () {
+            const queueArn = yield* QueueArn;
+            const result = yield* receiveMessage({
+              MaxNumberOfMessages: props.batchSize ?? 10,
+              WaitTimeSeconds: props.maximumBatchingWindowInSeconds,
+            });
+
+            const messages = result.Messages ?? [];
+            if (messages.length === 0) return;
+
+            yield* process(
+              Stream.fromArray(
+                messages.map((msg) => ({
+                  messageId: msg.MessageId!,
+                  receiptHandle: msg.ReceiptHandle!,
+                  body: msg.Body!,
+                  attributes: {
+                    ApproximateReceiveCount:
+                      msg.Attributes?.ApproximateReceiveCount!,
+                    SentTimestamp: msg.Attributes?.SentTimestamp!,
+                    SenderId: msg.Attributes?.SenderId!,
+                    ApproximateFirstReceiveTimestamp:
+                      msg.Attributes?.ApproximateFirstReceiveTimestamp!,
+                  },
+                  messageAttributes: {},
+                  md5OfBody: msg.MD5OfBody!,
+                  eventSource: "aws:sqs",
+                  eventSourceARN: queueArn,
+                  awsRegion: region,
+                })),
+              ),
+            ).pipe(Effect.orDie);
+
+            // TODO(sam): only delete messages that were successfully processed
+            yield* deleteMessageBatch({
+              Entries: messages.map((msg, i) => ({
+                Id: msg.MessageId ?? String(i),
+                ReceiptHandle: msg.ReceiptHandle!,
+              })),
+            });
+          }),
+        ).pipe(Effect.orDie),
+      );
+    }) as SQS.QueueEventSourceService;
+  }),
+);

package/src/Server/index.ts

@@ -0,0 +1,3 @@
+export * from "./Process.ts";
+export * from "./S3BucketEventSource.ts";
+export * from "./SQSQueueEventSource.ts";

package/src/Serverless/Function.ts

@@ -0,0 +1,18 @@
+import * as Effect from "effect/Effect";
+import type { BaseExecutionContext } from "../ExecutionContext.ts";
+import type { HttpEffect } from "../Http.ts";
+
+export interface FunctionContext extends BaseExecutionContext {
+  serve<Req = never>(handler: HttpEffect<Req>): Effect.Effect<void, never, Req>;
+  listen<A, Req = never>(
+    handler: FunctionListener<A, Req>,
+  ): Effect.Effect<void, never, Req>;
+  listen<A, Req = never, InitReq = never>(
+    effect: Effect.Effect<FunctionListener<A, Req>, never, InitReq>,
+  ): Effect.Effect<void, never, Req | InitReq>;
+  exports: Effect.Effect<Record<string, any>, never, never>;
+}
+
+export type FunctionListener<A = any, Req = never> = (
+  event: any,
+) => Effect.Effect<A, never, Req> | void;

package/src/Serverless/index.ts

@@ -0,0 +1 @@
+export * from "./Function.ts";

package/src/Spawn.ts

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+import { Daemon } from "./Daemon/Client.ts";
+
+export const spawn = Effect.fnUntraced(function* (
+  id: string,
+  command: string,
+  args?: string[],
+  options?: { cwd?: string; env?: Record<string, string> },
+) {
+  const daemon = yield* Daemon;
+  const handle = yield* daemon.spawn({
+    id,
+    command,
+    args: args ?? [],
+    ...options,
+  });
+
+  daemon.watch({
+    clientId: "my",
+    id,
+  });
+  return handle;
+});

package/src/Stack.ts

@@ -0,0 +1,84 @@
+import * as Effect from "effect/Effect";
+import { FileSystem } from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { Path } from "effect/Path";
+import type { Scope } from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { DotAlchemy } from "./Config.ts";
+import type { ResourceBinding, ResourceLike } from "./Resource.ts";
+import { Stage } from "./Stage.ts";
+
+export type StackServices =
+  | Stack
+  | Stage
+  | Scope
+  | FileSystem
+  | Path
+  | DotAlchemy
+  | HttpClient
+  | ChildProcessSpawner;
+
+export class Stack extends ServiceMap.Service<
+  Stack,
+  Omit<StackSpec, "output">
+>()("Stack") {}
+
+export interface StackSpec<Output = any> {
+  name: string;
+  stage: string;
+  // @internal
+  resources: {
+    [logicalId: string]: ResourceLike;
+  };
+  bindings: {
+    [logicalId: string]: ResourceBinding[];
+  };
+  output: Output;
+}
+
+export const StackName = Stack.use((stack) => Effect.succeed(stack.name));
+
+export const make =
+  <const Name extends string, ROut = never>(
+    name: Name,
+    providers: Layer.Layer<ROut, never, StackServices>,
+    /** @internal */
+    stack?: StackSpec,
+  ) =>
+  <A, Err = never, Req extends ROut | StackServices = never>(
+    effect: Effect.Effect<A, Err, Req>,
+  ) =>
+    Effect.all([
+      effect,
+      Stack.asEffect(),
+      Effect.services<ROut | StackServices>(),
+    ]).pipe(
+      Effect.map(([output, stack, services]) => ({
+        output,
+        services,
+        ...stack,
+      })),
+      Effect.provide(providers),
+      Effect.provideServiceEffect(
+        Stack,
+        Stage.asEffect().pipe(
+          Effect.map(
+            (stage) =>
+              (stack ?? {
+                name,
+                stage,
+                resources: {},
+                bindings: {},
+              }) satisfies Stack["Service"],
+          ),
+          Effect.tap(Effect.logInfo),
+        ),
+      ),
+    );
+
+export const CurrentStack = Effect.serviceOption(Stack)
+  .asEffect()
+  .pipe(Effect.map(Option.getOrUndefined));

package/src/Stage.ts

@@ -0,0 +1,3 @@
+import * as ServiceMap from "effect/ServiceMap";
+
+export class Stage extends ServiceMap.Service<Stage, string>()("Stage") {}

package/src/State/InMemoryState.ts

@@ -0,0 +1,86 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { ResourceState } from "./ResourceState.ts";
+import { State, type StateService } from "./State.ts";
+
+type StackId = string;
+type StageId = string;
+type Fqn = string;
+
+export const InMemory = (
+  initialState: Record<
+    StackId,
+    Record<StageId, Record<Fqn, ResourceState>>
+  > = {},
+) =>
+  Layer.succeed(State, InMemoryService(initialState)) as Layer.Layer<
+    State,
+    never,
+    never
+  >;
+
+export const InMemoryService = (
+  initialState: Record<
+    StackId,
+    Record<StageId, Record<Fqn, ResourceState>>
+  > = {},
+) => {
+  const state = initialState;
+  return {
+    listStacks: () => Effect.succeed(Array.from(Object.keys(state))),
+    listStages: (stack: string) =>
+      Effect.succeed(
+        Array.from(stack in state ? Object.keys(state[stack]) : []),
+      ),
+    get: ({
+      stack,
+      stage,
+      fqn,
+    }: {
+      stack: string;
+      stage: string;
+      fqn: string;
+    }) => Effect.succeed(state[stack]?.[stage]?.[fqn]),
+    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,
+      fqn,
+      value,
+    }: {
+      stack: string;
+      stage: string;
+      fqn: string;
+      value: V;
+    }) => {
+      const stackState = (state[stack] ??= {});
+      const stageState = (stackState[stage] ??= {});
+      stageState[fqn] = value;
+      return Effect.succeed(value);
+    },
+    delete: ({
+      stack,
+      stage,
+      fqn,
+    }: {
+      stack: string;
+      stage: string;
+      fqn: string;
+    }) => Effect.succeed(delete state[stack]?.[stage]?.[fqn]),
+    list: ({ stack, stage }: { stack: string; stage: string }) =>
+      Effect.succeed(
+        Array.from(Object.keys(state[stack]?.[stage] ?? {}) ?? []),
+      ),
+  } satisfies StateService;
+};

package/src/State/LocalState.ts

@@ -0,0 +1,120 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import type { PlatformError } from "effect/PlatformError";
+import { decodeFqn, encodeFqn } from "../FQN.ts";
+import { isResource } from "../Resource.ts";
+import { State, StateStoreError, type StateService } from "./State.ts";
+
+export const LocalState = Layer.effect(
+  State,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const dotAlchemy = path.join(process.cwd(), ".alchemy");
+    const stateDir = path.join(dotAlchemy, "state");
+
+    const fail = (err: PlatformError) =>
+      Effect.fail(
+        new StateStoreError({
+          message: err.message,
+          cause: err,
+        }),
+      );
+
+    const recover = <T>(effect: Effect.Effect<T, PlatformError, never>) =>
+      effect.pipe(
+        Effect.catchTag("PlatformError", (e) =>
+          e.reason._tag === "NotFound" ? Effect.void : fail(e),
+        ),
+      );
+
+    const stageDir = ({ stack, stage }: { stack: string; stage: string }) =>
+      path.join(stateDir, stack, stage);
+
+    const resource = ({
+      stack,
+      stage,
+      fqn,
+    }: {
+      stack: string;
+      stage: string;
+      fqn: string;
+    }) => path.join(stateDir, stack, stage, `${encodeFqn(fqn)}.json`);
+
+    const created = new Set<string>();
+
+    const ensure = (dir: string) =>
+      created.has(dir)
+        ? Effect.succeed(void 0)
+        : fs
+            .makeDirectory(dir, { recursive: true })
+            .pipe(Effect.tap(() => Effect.sync(() => created.add(dir))));
+
+    const state: StateService = {
+      listStacks: () =>
+        fs.readDirectory(stateDir).pipe(
+          recover,
+          Effect.map((files) => files ?? []),
+        ),
+      listStages: (stack: string) =>
+        fs.readDirectory(path.join(stateDir, stack)).pipe(
+          recover,
+          Effect.map((files) => files ?? []),
+        ),
+      get: (request) =>
+        fs.readFile(resource(request)).pipe(
+          Effect.map((file) => JSON.parse(file.toString())),
+          recover,
+        ),
+      getReplacedResources: Effect.fnUntraced(function* (request) {
+        return (yield* Effect.all(
+          (yield* state.list(request)).map((fqn) =>
+            state.get({
+              stack: request.stack,
+              stage: request.stage,
+              fqn,
+            }),
+          ),
+        )).filter((r) => r?.status === "replaced");
+      }),
+      set: (request) =>
+        ensure(stageDir(request)).pipe(
+          Effect.flatMap(() =>
+            fs.writeFileString(
+              resource(request),
+              JSON.stringify(
+                request.value,
+                (k, v) => {
+                  if (isResource(v)) {
+                    return {
+                      id: v.LogicalId,
+                      type: v.Type,
+                      props: v.Props,
+                      attr: v.Attributes,
+                    };
+                  }
+                  return v;
+                },
+                2,
+              ),
+            ),
+          ),
+          recover,
+          Effect.map(() => request.value),
+        ),
+      delete: (request) => fs.remove(resource(request)).pipe(recover),
+      list: (request) =>
+        fs.readDirectory(stageDir(request)).pipe(
+          recover,
+          Effect.map(
+            (files) =>
+              files?.map((file) => decodeFqn(file.replace(/\.json$/, ""))) ??
+              [],
+          ),
+        ),
+    };
+    return state;
+  }),
+);

package/src/State/ResourceState.ts

@@ -0,0 +1,121 @@
+import type { NamespaceNode } from "../Namespace.ts";
+import type { RemovalPolicy } from "../RemovalPolicy.ts";
+import type { ResourceBinding } from "../Resource.ts";
+
+export type ResourceState =
+  | CreatingResourceState
+  | CreatedResourceState
+  | UpdatingReourceState
+  | UpdatedResourceState
+  | DeletingResourceState
+  | ReplacingResourceState
+  | ReplacedResourceState;
+
+export type Props = Record<string, any>;
+export type Attr = Record<string, any>;
+
+export type ResourceStatus = ResourceState["status"];
+export type ReplacementResourceState =
+  | ReplacingResourceState
+  | ReplacedResourceState;
+export type ReplacementOldResourceState =
+  | CreatingResourceState
+  | CreatedResourceState
+  | UpdatingReourceState
+  | UpdatedResourceState
+  | DeletingResourceState
+  | ReplacementResourceState;
+
+interface BaseResourceState {
+  /** Type of the Resource (e.g. AWS.Lambda.Function) */
+  resourceType: string;
+  /** Namespace of the Resource */
+  namespace: NamespaceNode | undefined;
+  /** Fully Qualified Name (namespace path + logical ID) */
+  fqn: 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;
+  /** List of FQNs of resources that depend on this resource */
+  downstream: string[];
+  /** List of Bindings attached to this Resource */
+  bindings: ResourceBinding[];
+  /** Desired state (input props) of this Resource */
+  props?: Props;
+  /** The output attributes of this Resource (if it has been created) */
+  attr?: Attr;
+  /** The removal policy of the resource */
+  removalPolicy?: RemovalPolicy["Service"];
+}
+
+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;
+    /** List of Bindings attached to this Resource */
+    bindings: any[];
+    /** 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: ReplacementOldResourceState;
+  /** 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: ReplacementOldResourceState;
+  /** Whether the resource should be deleted before or after replacements */
+  deleteFirst: boolean;
+  // .. will (finally) transition to `CreatedResourceState` after finalizing
+}

package/src/State/State.ts

@@ -0,0 +1,72 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as ServiceMap from "effect/ServiceMap";
+import type { ReplacedResourceState, ResourceState } from "./ResourceState.ts";
+
+export class StateStoreError extends Data.TaggedError("StateStoreError")<{
+  message: string;
+  cause?: Error;
+}> {}
+
+export class State extends ServiceMap.Service<State, StateService>()(
+  "AWS::Lambda::State",
+) {}
+
+/**
+ * State service interface.
+ *
+ * Resources are keyed by FQN (namespace-qualified key) which includes
+ * the full namespace path plus the logical ID. The FQN is used as the
+ * storage key while logicalId remains available in the persisted state
+ * for provider operations.
+ */
+export interface StateService {
+  listStacks(): Effect.Effect<string[], StateStoreError, never>;
+  listStages(stack: string): Effect.Effect<string[], StateStoreError, never>;
+  /**
+   * Get a resource by its FQN (namespace-qualified key).
+   */
+  get(request: {
+    stack: string;
+    stage: string;
+    fqn: string;
+  }): Effect.Effect<ResourceState | undefined, StateStoreError, never>;
+  /**
+   * List top-level resources that are still in replacement cleanup.
+   *
+   * Any additional backlog from repeated replacements is stored recursively
+   * in the returned state's `old` chain.
+   */
+  getReplacedResources(request: {
+    stack: string;
+    stage: string;
+  }): Effect.Effect<
+    ReadonlyArray<ReplacedResourceState>,
+    StateStoreError,
+    never
+  >;
+  /**
+   * Set a resource by its FQN (namespace-qualified key).
+   */
+  set<V extends ResourceState>(request: {
+    stack: string;
+    stage: string;
+    fqn: string;
+    value: V;
+  }): Effect.Effect<V, StateStoreError, never>;
+  /**
+   * Delete a resource by its FQN (namespace-qualified key).
+   */
+  delete(request: {
+    stack: string;
+    stage: string;
+    fqn: string;
+  }): Effect.Effect<void, StateStoreError, never>;
+  /**
+   * List all resource FQNs in a stack/stage.
+   */
+  list(request: {
+    stack: string;
+    stage: string;
+  }): Effect.Effect<string[], StateStoreError, never>;
+}

package/src/State/index.ts

@@ -0,0 +1,4 @@
+export * from "./InMemoryState.ts";
+export * from "./LocalState.ts";
+export * from "./ResourceState.ts";
+export * from "./State.ts";