alchemy-effect 0.1.0 → 0.3.0

package/src/dot-alchemy.ts

@@ -1,8 +1,8 @@
-import { FileSystem } from "@effect/platform";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import path from "node:path";
 
 export class DotAlchemy extends Context.Tag(".alchemy")<DotAlchemy, string>() {}
 
@@ -10,6 +10,7 @@ export const dotAlchemy = Layer.effect(
   DotAlchemy,
   Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
     const dir = path.join(process.cwd(), ".alchemy");
     yield* fs.makeDirectory(dir, { recursive: true });
     return dir;

package/src/env.ts

@@ -1,9 +1,28 @@
+let _env;
+try {
+  // @ts-expect-error
+  const { env } = await import("cloudflare:workers");
+  _env = env;
+} catch {
+  if (typeof process !== "undefined") {
+    _env = process.env;
+  } else {
+    _env = import.meta.env;
+  }
+}
+
+export interface Env {
+  [key: string]: string | undefined;
+}
+
+export const env: Env = _env;
+
 export const toEnvKey = <const ID extends string, const Suffix extends string>(
   id: ID,
   suffix: Suffix,
 ) => `${replace(toUpper(id))}_${replace(toUpper(suffix))}` as const;
 
-const toUpper = <const S extends string>(str: S) =>
+export const toUpper = <const S extends string>(str: S) =>
   str.toUpperCase() as string extends S ? S : Uppercase<S>;
 
 const replace = <const S extends string>(str: S) =>
@@ -18,34 +37,3 @@ type Replace<S extends string, Accum extends string = ""> = string extends S
         ? Replace<Rest, `${Accum}_`>
         : Replace<Rest, `${Accum}${S}`>
       : Accum;
-
-function _test_both_literals() {
-  const key = toEnvKey("my-id", "my-suffix");
-  const _: typeof key = "MY_ID_MY_SUFFIX";
-  // @ts-expect-error
-  const _err: typeof key = "MY_ID_MY_SUFFIX2";
-}
-function _test_replace_wide_string() {
-  const ___ = toUpper(undefined! as string);
-  const id: string = "my-id";
-  const key = toEnvKey(id, "my-suffix");
-  const _: typeof key = "MY_ID_MY_SUFFIX";
-  const _2: typeof key = `${id}_MY_SUFFIX` as const;
-  // @ts-expect-error
-  const _err: typeof key = "MY_ID_MY_SUFFIX2";
-  // @ts-expect-error
-  const _err2: typeof key = `${id}_MY_SUFFIX2` as const;
-}
-
-function _test_replace_wide_suffix() {
-  const ___ = toUpper(undefined! as string);
-  const id = "my-id";
-  const suffix = "my-suffix" as string;
-  const key = toEnvKey(id, suffix);
-  const _: typeof key = "MY_ID_MY_SUFFIX";
-  const _2: typeof key = `MY_ID_${suffix}` as const;
-  // @ts-expect-error
-  const _err: typeof key = "WRONG_PREFIX_MY_SUFFIX";
-  // @ts-expect-error
-  const _err2: typeof key = `WRONG_PREFIX_${suffix}`;
-}

package/src/esbuild.ts

@@ -0,0 +1,98 @@
+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 * as Queue from "effect/Queue";
+import type * as Scope from "effect/Scope";
+import type esbuild from "esbuild";
+
+export class ESBuild extends Context.Tag("ESBuild")<
+  ESBuild,
+  {
+    readonly build: <T extends esbuild.BuildOptions>(
+      options: esbuild.SameShape<esbuild.BuildOptions, T>,
+    ) => Effect.Effect<esbuild.BuildResult<T>, ESBuildError>;
+    readonly context: <T extends esbuild.BuildOptions>(
+      options: esbuild.SameShape<esbuild.BuildOptions, T>,
+    ) => Effect.Effect<
+      {
+        queue: Queue.Queue<esbuild.BuildResult<T>>;
+        rebuild: () => Effect.Effect<
+          esbuild.BuildResult<T>,
+          ESBuildError,
+          never
+        >;
+      },
+      ESBuildError,
+      Scope.Scope
+    >;
+  }
+>() {}
+
+export const layer = () =>
+  Layer.effect(
+    ESBuild,
+    Effect.gen(function* () {
+      const esbuild = yield* Effect.promise(() => import("esbuild"));
+      return ESBuild.of({
+        build: Effect.fnUntraced(function* (options) {
+          return yield* Effect.tryPromise({
+            try: () => esbuild.build(options),
+            catch: ESBuildError.map,
+          });
+        }),
+        context: Effect.fnUntraced(function* (options) {
+          const queue = yield* Queue.unbounded<esbuild.BuildResult>();
+          const context = yield* Effect.tryPromise({
+            try: async () =>
+              esbuild.context({
+                ...options,
+                plugins: [
+                  ...(options.plugins ?? []),
+                  {
+                    name: "queue",
+                    setup: (build) => {
+                      build.onEnd((result) => {
+                        Queue.unsafeOffer(queue, result as esbuild.BuildResult);
+                      });
+                    },
+                  },
+                ],
+              }),
+            catch: ESBuildError.map,
+          });
+          yield* Effect.addFinalizer(() =>
+            Effect.promise(() => context.dispose()),
+          );
+          yield* Effect.tryPromise({
+            try: () => context.watch(),
+            catch: ESBuildError.map,
+          });
+          return {
+            queue,
+            rebuild: Effect.fnUntraced(function* () {
+              return yield* Effect.tryPromise({
+                try: (): Promise<esbuild.BuildResult> => context.rebuild(),
+                catch: ESBuildError.map,
+              });
+            }),
+          };
+        }),
+      });
+    }),
+  );
+
+export class ESBuildError extends Data.TaggedError("ESBuildError")<{
+  message: string;
+  errors: esbuild.Message[];
+  messages: esbuild.Message[];
+}> {
+  static map(error: unknown): ESBuildError {
+    const cause = error as esbuild.BuildFailure;
+    return new ESBuildError({
+      message: cause.message,
+      errors: cause.errors,
+      messages: cause.warnings,
+    });
+  }
+}

package/src/exports.ts

@@ -0,0 +1,21 @@
+/*
+This file is used to provide a minimal set of exported types required to solve portability
+issues in sub-modules (e.g. cloudflare/worker).
+
+Sub-modules are expected to `export type * from "../../exports.ts";` to ensure that the minimal set of types are exported.
+
+This is instead of:
+1. `export type * from "../../index.ts";` which would export too many types
+2. `export type * as Alchemy from "../../index.ts";` which creates very long, confusing types.
+
+TODO(sam): figure out a way to avoid this entirely
+*/
+
+export type * from "./$.ts";
+export type * from "./binding.ts";
+export type * from "./capability.ts";
+export type * from "./policy.ts";
+export type * from "./provider.ts";
+export type * from "./resource.ts";
+export type * from "./runtime.ts";
+export type * from "./service.ts";

package/src/index.ts

@@ -1,21 +1,27 @@
+export * from "./$.ts";
 export * from "./app.ts";
 export * from "./apply.ts";
-export * from "./approve.ts";
 export * from "./binding.ts";
 export * from "./capability.ts";
 export * from "./destroy.ts";
 export * from "./dot-alchemy.ts";
-export * from "./env.ts";
+export { env, toEnvKey, type Env } from "./env.ts";
 export * from "./event.ts";
+export * from "./input.ts";
+export * as Output from "./output.ts";
 export * from "./phase.ts";
 export * from "./plan.ts";
 export * from "./policy.ts";
 export * from "./provider.ts";
 export * from "./resource.ts";
 export * from "./runtime.ts";
+export * from "./ref.ts";
 export * from "./service.ts";
-export * as State from "./state.ts";
+export * from "./stack.ts";
+export * from "./type.ts";
+export * from "./unknown.ts";
+export * from "./stage.ts";
+export * from "./user.ts";
+export { assertDefined } from "./util.ts";
 
-export * as AWS from "./aws/index.ts";
-export * as CLI from "./cli/index.ts";
-export * as Cloudflare from "./cloudflare/index.ts";
+export * as State from "./state.ts";

package/src/input.ts

@@ -0,0 +1,81 @@
+import type * as S from "effect/Schema";
+import type { Primitive } from "./data.ts";
+import type { Output } from "./output.ts";
+
+export type Function = (...args: any[]) => any;
+export type Constructor = new (...args: any[]) => any;
+export type PolicyLike = { kind: "alchemy/Policy" };
+
+export type Input<T> =
+  | T
+  | (T extends S.Schema<any>
+      ? never
+      :
+          | Output<T, any, any>
+          | (T extends Primitive
+              ? never
+              : T extends any[]
+                ? number extends T["length"]
+                  ? Input<T[number]>[]
+                  : Inputs<T>
+                : T extends object
+                  ? { [K in keyof T]: Input<T[K]> }
+                  : never));
+
+export type InputProps<
+  T extends Record<string, any>,
+  Static extends keyof T = never,
+> = {
+  [K in keyof T]: K extends Static ? T[K] : Input<T[K]>;
+};
+
+export declare namespace Input {
+  export type Resolve<T> =
+    T extends Output<infer U>
+      ? U
+      : T extends
+            | Primitive
+            | Constructor
+            | Function
+            | S.Schema<any>
+            | PolicyLike
+        ? T
+        : T extends any[]
+          ? ResolveArray<T>
+          : T extends Record<string, any>
+            ? {
+                [k in keyof T]: Input.Resolve<T[k]>;
+              }
+            : never;
+
+  export type ResolveArray<T extends any[]> = number extends T["length"]
+    ? Resolve<T[number]>[]
+    : ResolveTuple<T>;
+
+  export type ResolveTuple<
+    T extends any[],
+    // TODO(sam): I added the accumulator because it resolved infinite type instantiation
+    Accum extends any[] = [],
+  > = T extends [infer H, ...infer Tail]
+    ? ResolveTuple<Tail, [...Accum, Input.Resolve<H>]>
+    : Accum;
+
+  export type ResolveProps<Props extends Record<string, any>> = {
+    [k in keyof Props]: Input.Resolve<Props[k]>;
+  };
+
+  export type ResolveOpaque<T> =
+    // use true extends IsOut to avoid distribution in the case where we have an Out<T>
+    // because T is a clean type, e.g. Input<SubnetProps> should just be SubnetProps (don't bother resolving the recursive input type variants)
+    true extends IsOut<T> ? ResolveOut<T> : Resolve<T>;
+  export type IsOut<T> = T extends Output<infer U> ? true : never;
+
+  export type ResolveOut<T> = T extends Output<infer U> ? U : never;
+}
+
+export type Inputs<T extends any[], Out extends any[] = []> = T extends [
+  infer H,
+  ...infer T,
+]
+  ? Inputs<T, [...Out, Input<H>]>
+  : Out;