alchemy-effect 0.2.0 → 0.3.0

package/src/cloudflare/r2/bucket.provider.ts

@@ -1,18 +1,19 @@
 import type { R2 } from "cloudflare/resources";
 import * as Effect from "effect/Effect";
 import { App } from "../../app";
-import { CloudflareAccountId, CloudflareApi } from "../api";
+import { Account } from "../account.ts";
+import { CloudflareApi } from "../api";
 import { Bucket, type BucketAttr, type BucketProps } from "./bucket";
 
 export const bucketProvider = () =>
   Bucket.provider.effect(
     Effect.gen(function* () {
       const api = yield* CloudflareApi;
-      const accountId = yield* CloudflareAccountId;
+      const accountId = yield* Account;
       const app = yield* App;
 
-      const createName = (id: string, props: BucketProps) =>
-        props.name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
+      const createName = (id: string, name: string | undefined) =>
+        name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
 
       const mapResult = <Props extends BucketProps>(
         bucket: R2.Bucket,
@@ -30,7 +31,7 @@ export const bucketProvider = () =>
           Effect.sync(() => {
             if (
               output.accountId !== accountId ||
-              output.name !== createName(id, news) ||
+              output.name !== createName(id, news.name) ||
               output.jurisdiction !== (news.jurisdiction ?? "default") ||
               olds.locationHint !== news.locationHint
             ) {
@@ -44,14 +45,14 @@ export const bucketProvider = () =>
         create: Effect.fnUntraced(function* ({ id, news }) {
           const bucket = yield* api.r2.buckets.create({
             account_id: accountId,
-            name: createName(id, news),
+            name: createName(id, news.name),
             storageClass: news.storageClass,
             jurisdiction: news.jurisdiction,
             locationHint: news.locationHint,
           });
           return mapResult<BucketProps>(bucket);
         }),
-        update: Effect.fnUntraced(function* ({ id, news, output }) {
+        update: Effect.fnUntraced(function* ({ news, output }) {
           const bucket = yield* api.r2.buckets.edit(output.name, {
             account_id: output.accountId,
             storage_class: news.storageClass ?? output.storageClass,
@@ -69,7 +70,7 @@ export const bucketProvider = () =>
         read: Effect.fnUntraced(function* ({ id, output, olds }) {
           const params = {
             account_id: output?.accountId ?? accountId,
-            name: output?.name ?? createName(id, olds ?? {}),
+            name: output?.name ?? createName(id, olds?.name),
           };
           return yield* api.r2.buckets
             .get(params.name, { account_id: params.account_id })

package/src/cloudflare/r2/bucket.ts

@@ -22,12 +22,18 @@ export type BucketAttr<Props extends BucketProps> = {
 export interface Bucket<
   ID extends string = string,
   Props extends BucketProps = BucketProps,
-> extends Resource<"Cloudflare.R2.Bucket", ID, Props, BucketAttr<Props>> {}
+> extends Resource<
+    "Cloudflare.R2.Bucket",
+    ID,
+    Props,
+    BucketAttr<Props>,
+    Bucket
+  > {}
 
 export const Bucket = Resource<{
   <const ID extends string, const Props extends BucketProps>(
     id: ID,
-    props: Props,
+    props?: Props,
   ): Bucket<ID, Props>;
 }>("Cloudflare.R2.Bucket");
 

package/src/cloudflare/worker/assets.fetch.ts

@@ -1,6 +1,8 @@
 import type * as runtime from "@cloudflare/workers-types";
-import { Binding, declare, type Capability } from "alchemy-effect";
 import * as Effect from "effect/Effect";
+import { Binding } from "../../binding.ts";
+import type { Capability } from "../../capability.ts";
+import { declare } from "../../policy.ts";
 import { getCloudflareEnvKey } from "../context.ts";
 import { Worker } from "./worker.ts";
 

package/src/cloudflare/worker/assets.provider.ts

@@ -2,7 +2,7 @@ import { FileSystem, Path } from "@effect/platform";
 import type { PlatformError } from "@effect/platform/Error";
 import { Context, Data, Layer } from "effect";
 import * as Effect from "effect/Effect";
-import type { ScopedPlanStatusSession } from "../../apply.ts";
+import type { ScopedPlanStatusSession } from "../../cli/service.ts";
 import { sha256 } from "../../sha256.ts";
 import { CloudflareApi, CloudflareApiError } from "../api.ts";
 import type { Worker } from "./worker.ts";

package/src/cloudflare/worker/index.ts

@@ -2,5 +2,3 @@ export * from "./assets.fetch.ts";
 export * from "./worker.handler.ts";
 export * from "./worker.serve.ts";
 export * from "./worker.ts";
-
-export type * as Alchemy from "../../index.ts";

package/src/cloudflare/worker/worker.handler.ts

@@ -1,7 +1,7 @@
 import type * as runtime from "@cloudflare/workers-types";
-import type { Capability } from "alchemy-effect";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import type { Capability } from "../../capability.ts";
 import { CloudflareContext } from "../context.ts";
 
 type Handler = (

package/src/cloudflare/worker/worker.provider.ts

@@ -3,11 +3,12 @@ import * as Path from "@effect/platform/Path";
 import type { Workers } from "cloudflare/resources.mjs";
 import * as Effect from "effect/Effect";
 import { App } from "../../app.ts";
-import type { ScopedPlanStatusSession } from "../../apply.ts";
+import type { ScopedPlanStatusSession } from "../../cli/service.ts";
 import { DotAlchemy } from "../../dot-alchemy.ts";
 import { ESBuild } from "../../esbuild.ts";
 import { sha256 } from "../../sha256.ts";
-import { CloudflareAccountId, CloudflareApi } from "../api.ts";
+import { CloudflareApi } from "../api.ts";
+import { Account } from "../account.ts";
 import { Assets } from "./assets.provider.ts";
 import { Worker, type WorkerAttr, type WorkerProps } from "./worker.ts";
 
@@ -16,7 +17,7 @@ export const workerProvider = () =>
     Effect.gen(function* () {
       const app = yield* App;
       const api = yield* CloudflareApi;
-      const accountId = yield* CloudflareAccountId;
+      const accountId = yield* Account;
       const { read, upload } = yield* Assets;
       const { build } = yield* ESBuild;
       const fs = yield* FileSystem.FileSystem;
@@ -46,8 +47,8 @@ export const workerProvider = () =>
         yield* Effect.logDebug("setWorkerSubdomain", subdomain);
       });
 
-      const createWorkerName = (id: string, props: WorkerProps | undefined) =>
-        props?.name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
+      const createWorkerName = (id: string, name: string | undefined) =>
+        name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
 
       const prepareAssets = Effect.fnUntraced(function* (
         assets: WorkerProps["assets"],
@@ -83,7 +84,9 @@ export const workerProvider = () =>
         };
       });
 
-      const prepareMetadata = Effect.fnUntraced(function* (props: WorkerProps) {
+      const prepareMetadata = Effect.fnUntraced(function* (
+        props: WorkerProps<any>,
+      ) {
         const metadata: Workers.ScriptUpdateParams.Metadata = {
           assets: undefined,
           bindings: [],
@@ -113,13 +116,13 @@ export const workerProvider = () =>
 
       const putWorker = Effect.fnUntraced(function* (
         id: string,
-        news: WorkerProps,
+        news: WorkerProps<any>,
         bindings: Worker["binding"][],
-        olds: WorkerProps | undefined,
-        output: WorkerAttr<WorkerProps> | undefined,
+        olds: WorkerProps<any> | undefined,
+        output: WorkerAttr<WorkerProps<any>> | undefined,
         session: ScopedPlanStatusSession,
       ) {
-        const name = createWorkerName(id, news);
+        const name = createWorkerName(id, news.name);
         const [assets, bundle, metadata] = yield* Effect.all([
           prepareAssets(news.assets),
           prepareBundle(id, news.main),
@@ -180,7 +183,7 @@ export const workerProvider = () =>
             assets: assets?.hash,
             bundle: bundle.hash,
           },
-        } as WorkerAttr<WorkerProps>;
+        } as WorkerAttr<WorkerProps<any>>;
       });
 
       return {
@@ -188,7 +191,7 @@ export const workerProvider = () =>
           if (output.accountId !== accountId) {
             return { action: "replace" };
           }
-          const workerName = createWorkerName(id, news);
+          const workerName = createWorkerName(id, news.name);
           if (workerName !== output.name) {
             return { action: "replace" };
           }
@@ -204,7 +207,7 @@ export const workerProvider = () =>
           }
         }),
         create: Effect.fnUntraced(function* ({ id, news, bindings, session }) {
-          const name = createWorkerName(id, news);
+          const name = createWorkerName(id, news.name);
           const existing = yield* api.workers.beta.workers
             .get(name, {
               account_id: accountId,

package/src/cloudflare/worker/worker.serve.ts

@@ -1,7 +1,10 @@
-import type * as types from "@cloudflare/workers-types";
+import type { ExecutionContext } from "@cloudflare/workers-types";
 import * as Effect from "effect/Effect";
 import * as Worker from "./worker.ts";
 
+export type { ExecutionContext };
+export type * from "../../exports.ts";
+
 export const serve =
   <const ID extends string, Req>(
     id: ID,
@@ -11,7 +14,7 @@ export const serve =
       fetch: (
         request: Request,
         env: unknown,
-        ctx: types.ExecutionContext,
+        ctx: ExecutionContext,
       ) => Effect.Effect<Response, never, Req>;
     },
   ) =>

package/src/cloudflare/worker/worker.ts

@@ -29,7 +29,7 @@ export type WorkerProps<Req = any> = RuntimeProps<
         assets: string | Worker.AssetsProps;
       });
 
-export type WorkerAttr<Props extends WorkerProps> = {
+export type WorkerAttr<Props extends WorkerProps<any>> = {
   id: string;
   name: Props["name"] extends string ? Props["name"] : string;
   logpush: Props["logpush"] extends boolean ? Props["logpush"] : boolean;
@@ -48,8 +48,9 @@ export type WorkerAttr<Props extends WorkerProps> = {
 };
 
 export interface Worker extends Runtime<WorkerType> {
-  props: WorkerProps;
-  attr: WorkerAttr<Extract<this["props"], WorkerProps>>;
+  base: Worker;
+  props: WorkerProps<any>;
+  attr: WorkerAttr<Extract<this["props"], WorkerProps<any>>>;
   binding: {
     bindings: Worker.Binding[];
   };

package/src/data.ts

@@ -0,0 +1,18 @@
+export type Primitive =
+  | never
+  | undefined
+  | null
+  | boolean
+  | number
+  | string
+  | bigint
+  | symbol;
+
+export const isPrimitive = (value: any): value is Primitive =>
+  value === undefined ||
+  value === null ||
+  typeof value === "boolean" ||
+  typeof value === "number" ||
+  typeof value === "string" ||
+  typeof value === "symbol" ||
+  typeof value === "bigint";

package/src/destroy.ts

@@ -1,7 +1,3 @@
 import { apply } from "./apply.ts";
 
-export const destroy = () =>
-  apply({
-    phase: "destroy",
-    resources: [],
-  });
+export const destroy = () => apply();

package/src/diff.ts

@@ -0,0 +1,30 @@
+export type Diff =
+  | {
+      action: "noop";
+      deleteFirst?: undefined;
+      stables?: undefined;
+    }
+  | {
+      action: "update";
+      deleteFirst?: undefined;
+      /** properties that won't change as part of this update */
+      stables?: string[];
+    }
+  | {
+      action: "replace";
+      deleteFirst?: boolean;
+      stables?: undefined;
+    };
+
+export const somePropsAreDifferent = <Props extends Record<string, any>>(
+  olds: Props,
+  news: Props,
+  props: (keyof Props)[],
+) => {
+  for (const prop of props) {
+    if (olds[prop] !== news[prop]) {
+      return true;
+    }
+  }
+  return false;
+};

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/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,22 +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 * 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;