alchemy-effect 0.6.0 → 0.6.2

package/src/service.ts

@@ -1,59 +0,0 @@
-import type { Effect } from "effect/Effect";
-import type { Capability } from "./capability.ts";
-import type { IResource } from "./resource.ts";
-import type { IRuntime, RuntimeHandler, RuntimeProps } from "./runtime.ts";
-
-export interface IService<
-  ID extends string = string,
-  F extends IRuntime = IRuntime,
-  Handler extends RuntimeHandler = RuntimeHandler,
-  Props extends RuntimeProps<F, any> = RuntimeProps<F, any>,
-  Attr = (F & { props: Props })["attr"],
-  Base = unknown,
-> extends IResource<F["type"], ID, Props, Attr, F> {
-  kind: "Service";
-  type: F["type"];
-  id: ID;
-  runtime: F;
-  /**
-   * The raw handler function as passed in to the Runtime.
-   *
-   * @internal phantom type
-   */
-  impl: Handler;
-  /**
-   * An Effect that produces a handler stripped of its Infrastructure-time-only Capabilities.
-   */
-  handler: Effect<
-    (
-      ...inputs: Parameters<Handler>
-    ) => Effect<
-      Effect.Success<ReturnType<Handler>>,
-      Effect.Error<ReturnType<Handler>>,
-      never
-    >,
-    never,
-    Exclude<Effect.Context<ReturnType<Handler>>, Capability>
-  >;
-  props: Props;
-  /** @internal phantom type of this resource's output attributes */
-  attr: Attr;
-  /** @internal phantom type of this resource's parent */
-  parent: unknown;
-  new (): Service<ID, F, Handler, Props, Attr, Base>;
-}
-
-export interface AnyService extends IService {}
-
-export interface Service<
-  ID extends string = string,
-  F extends IRuntime = IRuntime,
-  Handler extends RuntimeHandler = RuntimeHandler,
-  Props extends RuntimeProps<F, any> = RuntimeProps<F, any>,
-  Attr = (F & { props: Props })["attr"],
-  Base = unknown,
-> extends IService<ID, F, Handler, Props, Attr, Base> {}
-
-export const isService = (resource: any): resource is IService => {
-  return resource && resource.kind === "Service";
-};

package/src/sha256.ts

@@ -1,23 +0,0 @@
-import * as Effect from "effect/Effect";
-
-type Input = ArrayBuffer | Uint8Array | string;
-
-export const sha256 = (input: Input) =>
-  Effect.promise(async () => {
-    const digest = await crypto.subtle.digest("SHA-256", toArrayBuffer(input));
-    const hashArray = Array.from(new Uint8Array(digest));
-    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  });
-
-const toArrayBuffer = (input: Input) => {
-  if (input instanceof ArrayBuffer) {
-    return input;
-  }
-  if (typeof input === "string") {
-    return new TextEncoder().encode(input);
-  }
-  return input.buffer.slice(
-    input.byteOffset,
-    input.byteOffset + input.byteLength,
-  ) as ArrayBuffer;
-};

package/src/stack.ts

@@ -1,116 +0,0 @@
-import type { HttpClient } from "@effect/platform/HttpClient";
-import { FileSystem } from "@effect/platform/FileSystem";
-import { Path } from "@effect/platform/Path";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as App from "./app.ts";
-import { type AppliedPlan } from "./apply.ts";
-import { DotAlchemy } from "./dot-alchemy.ts";
-import type { DerivePlan, Providers, TraverseResources } from "./plan.ts";
-import type { Instance } from "./policy.ts";
-import type { AnyResource } from "./resource.ts";
-import type { AnyService } from "./service.ts";
-import { type StageConfig, type Stages } from "./stage.ts";
-import * as State from "./state.ts";
-import type { Ref } from "./ref.ts";
-import type { CLI } from "./cli/service.ts";
-
-export const defineStack = <
-  const Name extends string,
-  Resources extends (AnyResource | AnyService)[],
-  Req = never,
-  Err = never,
->(
-  stack: StackConfig<Name, Resources, Req, Err>,
-): Stack<Name, Instance<Resources[number]>, Req, Err> => stack as any;
-
-export type StackConfig<
-  Name extends string,
-  Resources extends (AnyResource | AnyService)[] = (AnyResource | AnyService)[],
-  StagesReq = never,
-  StagesErr = never,
-  TapReq = never,
-  TapErr = never,
-> = {
-  name: Name;
-  stages: Stages<StagesReq, StagesErr>;
-  resources: Resources;
-  providers: Layer.Layer<
-    Providers<Instance<Resources[number]>>,
-    any,
-    App.App | FileSystem | Path | DotAlchemy | HttpClient
-  >;
-  state?: Layer.Layer<State.State>;
-  tap?: (
-    output: StackOutput<Instance<Resources[number]>>,
-  ) => Effect.Effect<any, TapErr, TapReq>;
-} & (Exclude<NoInfer<StagesReq | TapReq>, BuiltInServices> extends never
-  ? {
-      layers?: never;
-    }
-  : {
-      layers: Layer.Layer<
-        Exclude<StagesReq | TapReq, BuiltInServices>,
-        never,
-        never
-      >;
-    });
-
-export type StackOutput<Resources extends AnyResource | AnyService> =
-  AppliedPlan<DerivePlan<Resources>>;
-
-export type Stack<
-  Name extends string = string,
-  Resources extends AnyResource | AnyService = any,
-  StagesReq = any,
-  StagesErr = any,
-  TapReq = any,
-  TapErr = any,
-> = {
-  name: Name;
-  stages: Stages<StagesReq, StagesErr>;
-  resources: Resources[];
-  providers: Layer.Layer<Providers<Resources>, any, BuiltInServices>;
-  state?: Layer.Layer<State.State>;
-  cli?: Layer.Layer<CLI>;
-  tap?: (output: StackOutput<Resources>) => Effect.Effect<void, TapErr, TapReq>;
-} & (Exclude<StagesReq | TapReq, BuiltInServices> extends never
-  ? {
-      layers?: never;
-    }
-  : {
-      layers: Layer.Layer<
-        Exclude<StagesReq | TapReq, BuiltInServices>,
-        never,
-        never
-      >;
-    });
-
-export type StackName<S extends Stack> =
-  S extends Stack<infer Name, infer _> ? Name : never;
-
-export type StackResources<S extends Stack> =
-  S extends Stack<infer _, infer Resources> ? Resources : never;
-
-export type BuiltInServices =
-  | App.App
-  | FileSystem
-  | Path
-  | DotAlchemy
-  | HttpClient;
-
-export interface StackRefConfig<S extends Stack> extends StageConfig {
-  stack: S extends Stack<infer Name, any> ? Name : never;
-  stage?: string;
-}
-
-export type StackRef<Resources extends AnyResource | AnyService> = {
-  [Id in keyof AsRecord<Resources>]: Ref<AsRecord<Resources>[Id]>;
-};
-
-type AsRecord<Resources extends AnyResource | AnyService> = {
-  [Id in TraverseResources<Resources>["id"]]: Extract<
-    TraverseResources<Resources>,
-    { id: Id }
-  >;
-};

package/src/stage.ts

@@ -1,85 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import type { StackName, StackRef, Stack, StackResources } from "./stack.ts";
-import { ref } from "./ref.ts";
-
-export interface StageConfig {
-  /**
-   * Whether to retain the stage when destroying the stack.
-   *
-   * @default - true if the current stage starts with "prod"
-   */
-  retain?: boolean;
-
-  /**
-   * Whether to adopt resources that already exist during the created phase.
-   *
-   * @default false
-   */
-  adopt?: boolean;
-}
-
-export class Stage extends Context.Tag("Stage")<Stage, string>() {}
-
-export type Stages<Req = never, Err = never> = {
-  config: (stage: string) => StageConfig | Effect.Effect<StageConfig, Err, Req>;
-  ref<S extends Stack>(name: StackName<S>): StackRefs<S>;
-};
-
-export const defineStages = <Req = never, Err = never>(
-  config: (stage: string) => StageConfig | Effect.Effect<StageConfig, Err, Req>,
-): Stages<Req, Err> => ({
-  config,
-  ref: <S extends Stack>(stack: StackName<NoInfer<S>>): StackRefs<S> => {
-    const proxy = (get: (id: string) => any) =>
-      new Proxy({}, { get: (_, id: string) => get(id) });
-    const proxyStage = (stage: string) =>
-      proxy((resourceId: string) =>
-        ref({
-          stack,
-          stage,
-          resourceId,
-        }),
-      );
-    return proxy((stage) =>
-      stage == "as"
-        ? (builders: StackRefBuilders) =>
-            proxy((stage: string) => {
-              if (stage in builders) {
-                const builder = builders[stage as keyof typeof builders];
-                return typeof builder === "string"
-                  ? proxyStage(stage)
-                  : (...args: any[]) => proxyStage(builder(...args));
-              }
-              return proxyStage(stage);
-            })
-        : proxy((resourceId: string) =>
-            ref({
-              stack,
-              stage,
-              resourceId,
-            }),
-          ),
-    ) as StackRefs<S>;
-  },
-});
-
-export interface StackRefBuilders {
-  [stage: string]: string | ((...args: any[]) => string);
-}
-
-export type StackRefs<S extends Stack> = {
-  [stage in string]: StackRef<StackResources<S>>;
-} & {
-  as<Builders extends StackRefBuilders>(
-    stages?: Builders,
-  ): {
-    [stage in Exclude<string, keyof Builders>]: StackRef<StackResources<S>>;
-  } & {
-    [builder in keyof Builders]: Builders[builder] extends string
-      ? StackRef<StackResources<S>>
-      : Builders[builder] extends (...args: infer Args) => any
-        ? (...args: Args) => StackRef<StackResources<S>>
-        : never;
-  };
-};

package/src/state.ts

@@ -1,390 +0,0 @@
-import type { PlatformError } from "@effect/platform/Error";
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as Path from "@effect/platform/Path";
-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 type { BindNode } from "./plan.ts";
-import { isResource } from "./resource.ts";
-
-// SQL only?? no
-// DynamoDB is faster but bounded to 400KB (<10ms minimum latency)
-// S3 is slower but unbounded in size (200ms minimum latency)
-// -> dual purpose for assets
-// -> batching? or one file? -> Pipeline to one file. Versioned S3 Object for logs.
-// -> concern with one file is size: some of our resources have like the whole fucking lambda
-//    -> hash them? or etag. etag is md5
-//    -> there are more large data that aren't files?
-//       -> e.g. asset manifest
-//       -> pointer to one file? too clever?
-// -> sqlite on S3?
-// SQlite on EFS. But needs a VPN.
-// Roll back just from the state store??? -> needs to be fast and "build-less"
-// JSON or Message Pack? I vote JSON (easy to read)
-
-// Artifact -> stored hash only, compared on hash, not available during DELETE
-// -> can't rollback just from state
-// -> store it as a separate file, avoid re-writes, etc.
-
-// SQLite in S3
-// -> download, do all updates locally, upload?
-// -> stream uploads
-// -> not durable, but we accept that we CANT be durable
-// -> it's also fast if you don't upload often
-
-// S3 would still be fast because we sync locally
-
-// ## Encryption
-// ALCHEMY_PASSWORD suck
-// ALCHEMY_STATE_TOKEN suck
-// We are flattening (no more nested any state)
-
-// in AWS this is easy - SSE (SSE + KMS)
-// -> some companies would prefer CSE
-
-// Library level encryption (SDK) -> default to no-op, favor SSE on AWS S3
-// On AWS it would be KMS (we can just use IAM Role)
-// On CF -> generate a Token and store in Secrets Manager?
-//   -> Store it in R2 because we can't get it out?
-//   -> Or build KMS on top of Workers+DO?
-//   -> R2 lets us use OAuth to gain access to the encryption token
-
-// Scrap the "key-value" store on State/Scope
-
-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;
-  /** 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 {
-  listStacks(): Effect.Effect<string[], StateStoreError, never>;
-  listStages(stack: string): Effect.Effect<string[], StateStoreError, never>;
-  // stub
-  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")<
-  State,
-  StateService
->() {}
-
-// TODO(sam): implement with SQLite3
-export const localFs = 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.description ?? err.message,
-        }),
-      );
-
-    const recover = <T>(effect: Effect.Effect<T, PlatformError, never>) =>
-      effect.pipe(
-        Effect.catchTag("SystemError", (e) =>
-          e.reason === "NotFound" ? Effect.succeed(undefined) : fail(e),
-        ),
-        Effect.catchTag("BadArgument", (e) => fail(e)),
-      );
-
-    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`);
-
-    const ensure = yield* Effect.cachedFunction((dir: string) =>
-      fs.makeDirectory(dir, { recursive: true }),
-    );
-
-    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((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,
-              ),
-            ),
-          ),
-          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;
-  }),
-);
-
-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: (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: ({
-      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;
-};