alchemy 2.0.0-beta.45 → 2.0.0-beta.47

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -232,7 +232,19 @@ export const LocalWorkerProvider = () =>
       }) {
         const name = yield* createWorkerName(id, props.name);
         const compatibility = getCompatibility(props);
-        const workerBindings: BindingHook<BindingServices>[] = [];
+        const workerBindings: BindingHook<BindingServices>[] = [
+          Text.local("ALCHEMY_PHASE", "runtime"),
+          Text.local("ALCHEMY_STACK_NAME", stack.name),
+          Text.local("ALCHEMY_STAGE", stack.stage),
+          ...Object.entries(props.env ?? {}).map(([key, value]) => {
+            const unredacted = Redacted.isRedacted(value)
+              ? Redacted.value(value)
+              : value;
+            return typeof unredacted === "string"
+              ? Text.local(key, unredacted)
+              : Json.local(key, unredacted);
+          }),
+        ];
         const durableObjectNamespaces: Record<string, string> = {};
         const hyperdrives: Record<string, Required<HyperdriveOrigin>> = {};
         for (const { data } of bindings) {

package/src/Cloudflare/Workers/Rpc.ts

@@ -223,19 +223,48 @@ export const makeRpcStub = <Shape>(
         return target[prop];
       }
       return (...args: any[]) =>
-        Effect.gen(function* () {
-          const stub = isLazy
-            ? yield* stubSource as Effect.Effect<any>
-            : stubSource;
-          return yield* Effect.tryPromise({
-            try: () => (stub as any)[prop](...args),
-            catch: (cause) => new RpcCallError({ method: String(prop), cause }),
-          }).pipe(Effect.flatMap(decodeRpcResult));
-        });
+        asEffectOrStream(
+          Effect.gen(function* () {
+            const stub = isLazy
+              ? yield* stubSource as Effect.Effect<any>
+              : stubSource;
+            return yield* Effect.tryPromise({
+              try: () => (stub as any)[prop](...args),
+              catch: (cause) =>
+                new RpcCallError({ method: String(prop), cause }),
+            }).pipe(Effect.flatMap(decodeRpcResult));
+          }),
+        );
     },
   }) as Shape;
 };
 
+// Effect's internal Stream brand. `Stream.isStream` recognises a value by
+// this property and reads its `channel`. A `makeRpcStub` method can't know
+// synchronously whether the remote method returns a value or a `Stream`
+// (the call is async), yet its declared type mirrors the DO `Shape`
+// verbatim — value methods are typed `Effect<A>`, streaming methods `Stream<A>`.
+// We satisfy BOTH by handing back the call `Effect` augmented with the Stream
+// brand + channel, so the single return value can be `yield*`-ed / `.pipe`d as
+// an Effect (value methods, e.g. `stub.put(k, v).pipe(Effect.orDie)`) AND piped
+// through `Stream.*` combinators (streaming methods, e.g.
+// `stub.tick(n).pipe(Stream.map(...))`).
+const StreamTypeId = "~effect/Stream";
+
+const asEffectOrStream = (
+  call: Effect.Effect<unknown, unknown>,
+): Effect.Effect<unknown, unknown> => {
+  const streamForm = Stream.unwrap(
+    Effect.map(call, (value) =>
+      Stream.isStream(value) ? value : Stream.succeed(value),
+    ),
+  );
+  return Object.assign(call, {
+    [StreamTypeId]: streamForm[StreamTypeId],
+    channel: streamForm.channel,
+  });
+};
+
 export const toRpcStream = (stream: Stream.Stream<any, any, any>) =>
   Effect.scoped(
     Effect.gen(function* () {

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -19,6 +19,7 @@ import { isImages } from "../Images/Images.ts";
 import { isKVNamespace } from "../KV/KVNamespace.ts";
 import { isQueue } from "../Queue/Queue.ts";
 import { isR2Bucket } from "../R2/R2Bucket.ts";
+import { isVectorizeIndex } from "../Vectorize/VectorizeIndex.ts";
 import { isAssets } from "./Assets.ts";
 import { isDurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
 import type { WorkerBindingProps } from "./Worker.ts";
@@ -190,6 +191,12 @@ const toBinding = (
       name: bindingName,
       service: binding.workerName,
     };
+  } else if (isVectorizeIndex(binding)) {
+    return {
+      type: "vectorize",
+      name: bindingName,
+      indexName: binding.indexName,
+    };
   } else {
     return {
       type: "json",

package/src/Cloudflare/Workers/WorkerBinding.ts

@@ -17,6 +17,7 @@ import { Images } from "../Images/Images.ts";
 import type { KVNamespace } from "../KV/KVNamespace.ts";
 import type { Queue } from "../Queue/Queue.ts";
 import type { R2Bucket } from "../R2/R2Bucket.ts";
+import type { VectorizeIndex } from "../Vectorize/VectorizeIndex.ts";
 import type { Assets } from "./Assets.ts";
 import type { DurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
 import { makeRpcStub } from "./Rpc.ts";
@@ -50,6 +51,7 @@ export type WorkerBindingResource =
   | BrowserRendering
   | Images
   | Hyperdrive
+  | VectorizeIndex
   | Worker
   | DurableObjectNamespaceLike<any>;
 

package/src/Cloudflare/Workers/WorkerBridge.ts

@@ -141,8 +141,17 @@ export const makeWorkerBridge = (
                       ),
                     );
                   }
+                  const result = dispatcher(...args);
+                  // A streaming RPC method returns a `Stream` directly rather
+                  // than an `Effect`. Lift it into the success channel so the
+                  // inner effect resolves to the `Stream` and `handleRpcExit`
+                  // can encode it as a stream envelope. Anything else is the
+                  // `Effect` it claims to be (its resolved value may itself be
+                  // a `Stream`, which `handleRpcExit` also handles).
                   return Effect.succeed([
-                    dispatcher(...args) as Effect.Effect<any>,
+                    Stream.isStream(result)
+                      ? Effect.succeed(result)
+                      : (result as Effect.Effect<any>),
                     Context.empty(),
                   ] as const);
                 }),
@@ -274,7 +283,16 @@ export const makeRpcProxy = (
                   ),
                 );
               }
-              return dispatcher(...args) as Effect.Effect<any>;
+              const result = dispatcher(...args);
+              // A streaming RPC method returns a `Stream` directly rather than
+              // an `Effect`. Lift it into the success channel so the resulting
+              // `Exit.value` is the `Stream` and `handleRpcExit` can encode it
+              // as a stream envelope. Anything else is the `Effect` it claims
+              // to be and is run normally (its resolved value may itself be a
+              // `Stream`, which `handleRpcExit` also handles).
+              return Stream.isStream(result)
+                ? Effect.succeed(result)
+                : (result as Effect.Effect<any>);
             }),
             processEvent,
           )

package/src/Cloudflare/index.ts

@@ -18,6 +18,7 @@ export * from "./R2/index.ts";
 export * from "./SecretsStore/index.ts";
 export * from "./StateStore/index.ts";
 export * from "./Tunnel/index.ts";
+export * from "./Vectorize/index.ts";
 export * from "./VpcService/index.ts";
 export * from "./Website/index.ts";
 export * from "./Workers/index.ts";

package/src/Output.ts

@@ -549,7 +549,7 @@ export const evaluate: <A, Req = never>(
       } else if (isNamedExpr(expr)) {
         return yield* evaluate(expr.expr, upstream);
       } else if (isRefExpr(expr)) {
-        const state = yield* State.State;
+        const state = yield* yield* State.State;
         const stack = expr.stack ?? (yield* Stack).name;
         const stage = expr.stage ?? (yield* Stage);
         const resource = yield* state.get({
@@ -572,7 +572,7 @@ export const evaluate: <A, Req = never>(
         // task's output value, otherwise undefined.
         return (resource as any).attr ?? (resource as any).output;
       } else if (isStackRefExpr(expr)) {
-        const state = yield* State.State;
+        const state = yield* yield* State.State;
         const stack = expr.stack;
         const stage = expr.stage ?? (yield* Stage);
         const output = yield* state.getOutput({ stack, stage });

package/src/Plan.ts

@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import { asEffect } from ".//Util/types.ts";
+import { isAction, type ActionLike } from "./Action.ts";
 import {
   AdoptPolicy,
   OwnedBySomeoneElse,
@@ -41,19 +42,18 @@ import {
 } from "./Resource.ts";
 import { type StackSpec } from "./Stack.ts";
 import {
+  isActionState,
   State,
+  type ActionState,
   type CreatedResourceState,
   type CreatingResourceState,
-  isActionState,
   type RanActionState,
   type ReplacedResourceState,
   type ReplacingResourceState,
   type ResourceState,
-  type ActionState,
   type UpdatedResourceState,
   type UpdatingReourceState,
 } from "./State/index.ts";
-import { isAction, type ActionLike } from "./Action.ts";
 import { hashInput } from "./Util/hash.ts";
 import { findCycleMembers } from "./Util/scc.ts";
 
@@ -236,7 +236,7 @@ export const make = <A>(
 ): Effect.Effect<Plan<A>, never, State> =>
   // @ts-expect-error
   Effect.gen(function* () {
-    const state = yield* State;
+    const state = yield* yield* State;
 
     const resources = Object.values(stack.resources);
     const actions = Object.values(stack.actions ?? {});

package/src/Stack.ts

@@ -125,7 +125,10 @@ export const Stack: Context.ServiceClass<
             // by default, reference the stack at the "current" stage of the importer
             Output.stackRef<A>(stackName).pipe(effectClass),
             {
+              stackName,
               stage: createStageProxy(stackName),
+              state: options?.state,
+              providers: options?.providers,
               make: <Req = never>(
                 options: StackProps<NoInfer<Req>>,
                 eff: Effect.Effect<A, never, Req>,
@@ -140,7 +143,10 @@ export const Stack: Context.ServiceClass<
         }),
         (eff) =>
           Object.assign(eff, {
+            stackName,
             stage: createStageProxy(stackName),
+            state: options?.state,
+            providers: options?.providers,
           }),
       );
     },

package/src/State/HttpStateStore.ts

@@ -39,6 +39,34 @@ export interface HttpStateStoreProps extends HttpStateStoreCredentials {
   ) => HttpClientRequest.HttpClientRequest;
 }
 
+export const checkHttpStateStoreAuth = ({
+  url,
+  authToken,
+}: {
+  url: string;
+  authToken: string;
+}) =>
+  Effect.gen(function* () {
+    const apiClient = yield* HttpApiClient.make(StateApi, {
+      baseUrl: url,
+      transformClient: HttpClient.mapRequest((req) =>
+        req.pipe(HttpClientRequest.bearerToken(authToken)),
+      ),
+    });
+    return yield* apiClient.state.listStacks().pipe(
+      Effect.map(() => true),
+      Effect.catchTag("Unauthorized", () => Effect.succeed(false)),
+      Effect.retry({
+        while: (error) =>
+          error._tag === "HttpClientError" &&
+          !!error.response &&
+          // worker can 404 for a bit on first deploy
+          (error.response.status === 404 || error.response.status >= 500),
+        schedule: Schedule.fixed(200),
+      }),
+    );
+  });
+
 export const makeHttpStateStore = ({
   url,
   authToken,

package/src/State/InMemoryState.ts

@@ -18,8 +18,8 @@ export const inMemoryState = (
 ) =>
   Layer.effect(
     State,
-    Effect.succeed(InMemoryService(initialState, initialOutputs)).pipe(
-      recordStateStoreInit,
+    Effect.cached(
+      InMemoryService(initialState, initialOutputs).pipe(recordStateStoreInit),
     ),
   );
 
@@ -27,87 +27,89 @@ export const InMemoryService = (
   state: Record<StackId, Record<StageId, Record<Fqn, ResourceState>>> = {},
   outputs: Record<StackId, Record<StageId, unknown>> = {},
 ) =>
-  State.of({
-    id: "inmemory",
-    getVersion: () => Effect.succeed(STATE_STORE_VERSION),
-    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",
+  State.of(
+    Effect.succeed({
+      id: "inmemory",
+      getVersion: () => Effect.succeed(STATE_STORE_VERSION),
+      listStacks: () => Effect.succeed(Array.from(Object.keys(state))),
+      listStages: (stack: string) =>
+        Effect.succeed(
+          Array.from(stack in state ? Object.keys(state[stack]) : []),
         ),
-      ),
-    set: <V extends PersistedState>({
-      stack,
-      stage,
-      fqn,
-      value,
-    }: {
-      stack: string;
-      stage: string;
-      fqn: string;
-      value: V;
-    }) =>
-      Effect.sync(() => {
-        const stackState = (state[stack] ??= {});
-        const stageState = (stackState[stage] ??= {});
-        stageState[fqn] = value as ResourceState;
-        return value;
-      }),
-    delete: ({
-      stack,
-      stage,
-      fqn,
-    }: {
-      stack: string;
-      stage: string;
-      fqn: string;
-    }) => Effect.sync(() => delete state[stack]?.[stage]?.[fqn]),
-    deleteStack: ({ stack, stage }: { stack: string; stage?: string }) =>
-      Effect.sync(() => {
-        if (stage === undefined) {
-          delete state[stack];
-        } else {
-          delete state[stack]?.[stage];
-        }
-      }),
-    list: ({ stack, stage }: { stack: string; stage: string }) =>
-      Effect.succeed(
-        Array.from(Object.keys(state[stack]?.[stage] ?? {}) ?? []),
-      ),
-    getOutput: ({ stack, stage }: { stack: string; stage: string }) =>
-      Effect.succeed(outputs[stack]?.[stage]),
-    setOutput: ({
-      stack,
-      stage,
-      value,
-    }: {
-      stack: string;
-      stage: string;
-      value: unknown;
-    }) =>
-      Effect.sync(() => {
-        const stackOutputs = (outputs[stack] ??= {});
-        stackOutputs[stage] = value;
-        return value;
-      }),
-  });
+      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 PersistedState>({
+        stack,
+        stage,
+        fqn,
+        value,
+      }: {
+        stack: string;
+        stage: string;
+        fqn: string;
+        value: V;
+      }) =>
+        Effect.sync(() => {
+          const stackState = (state[stack] ??= {});
+          const stageState = (stackState[stage] ??= {});
+          stageState[fqn] = value as ResourceState;
+          return value;
+        }),
+      delete: ({
+        stack,
+        stage,
+        fqn,
+      }: {
+        stack: string;
+        stage: string;
+        fqn: string;
+      }) => Effect.sync(() => delete state[stack]?.[stage]?.[fqn]),
+      deleteStack: ({ stack, stage }: { stack: string; stage?: string }) =>
+        Effect.sync(() => {
+          if (stage === undefined) {
+            delete state[stack];
+          } else {
+            delete state[stack]?.[stage];
+          }
+        }),
+      list: ({ stack, stage }: { stack: string; stage: string }) =>
+        Effect.succeed(
+          Array.from(Object.keys(state[stack]?.[stage] ?? {}) ?? []),
+        ),
+      getOutput: ({ stack, stage }: { stack: string; stage: string }) =>
+        Effect.succeed(outputs[stack]?.[stage]),
+      setOutput: ({
+        stack,
+        stage,
+        value,
+      }: {
+        stack: string;
+        stage: string;
+        value: unknown;
+      }) =>
+        Effect.sync(() => {
+          const stackOutputs = (outputs[stack] ??= {});
+          stackOutputs[stage] = value;
+          return value;
+        }),
+    }),
+  );

package/src/State/LocalState.ts

@@ -10,7 +10,21 @@ import { State, StateStoreError, type StateService } from "./State.ts";
 import { encodeState, reviveState } from "./StateEncoding.ts";
 
 export const localState = () =>
-  Layer.effect(State, makeLocalState().pipe(recordStateStoreInit));
+  Layer.effect(
+    State,
+    Effect.gen(function* () {
+      const context = yield* Effect.context<
+        FileSystem.FileSystem | Path.Path
+      >();
+
+      const make = makeLocalState().pipe(
+        recordStateStoreInit,
+        Effect.provideContext(context),
+      );
+
+      return yield* Effect.cached(make);
+    }),
+  );
 
 export const makeLocalState = () =>
   Effect.gen(function* () {

package/src/State/State.ts

@@ -1,8 +1,8 @@
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
-import type { ReplacedResourceState, ResourceState } from "./ResourceState.ts";
 import type { ActionState } from "./ActionState.ts";
+import type { ReplacedResourceState, ResourceState } from "./ResourceState.ts";
 
 /**
  * Anything persistable under an FQN. Resources are discriminated by status
@@ -23,9 +23,10 @@ export class StateStoreError extends Data.TaggedError("StateStoreError")<{
   cause?: Error;
 }> {}
 
-export class State extends Context.Service<State, StateService>()(
-  "alchemy/State",
-) {}
+export class State extends Context.Service<
+  State,
+  Effect.Effect<StateService>
+>()("alchemy/State") {}
 
 /**
  * State service interface.

package/src/Util/poll.ts

@@ -0,0 +1,47 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as Schedule from "effect/Schedule";
+
+export class PredicateFailed extends Data.TaggedError("PredicateFailed")<{
+  message: string;
+  actual: unknown;
+}> {}
+
+export const isPredicateFailed = (e: unknown): e is PredicateFailed =>
+  Predicate.isTagged(e, "PredicateFailed");
+
+/**
+ * Retries an effect until a predicate is met.
+ * @param input - The input to the poll function.
+ * @param input.description - The description of what is being polled; used in the error message if the predicate fails.
+ * @param input.effect - The effect to execute until the predicate is met.
+ * @param input.predicate - The predicate to check if the effect has met the desired state.
+ * @param input.schedule - The schedule to use for retries; defaults to every 3 seconds.
+ * @param input.times - The maximum number of times to poll; defaults to 50.
+ * @returns The value that satisfies the predicate.
+ */
+export const poll = Effect.fn("poll")(
+  <A, E, R>(input: {
+    description?: string;
+    effect: Effect.Effect<A, E, R>;
+    predicate: (value: A) => boolean;
+    schedule?: Schedule.Schedule<unknown, unknown, never>;
+    times?: number;
+  }) =>
+    input.effect.pipe(
+      Effect.filterOrFail(
+        input.predicate,
+        (actual) =>
+          new PredicateFailed({
+            message: `Predicate failed: ${input.description ?? "<no description>"}`,
+            actual,
+          }),
+      ),
+      Effect.retry({
+        while: isPredicateFailed,
+        schedule: input.schedule ?? Schedule.spaced("3 seconds"),
+        times: input.times ?? 50,
+      }),
+    ),
+);