alchemy 2.0.0-beta.23 → 2.0.0-beta.25

package/src/Telemetry/Metrics.ts

@@ -30,6 +30,24 @@ export const cliCounter = Metric.counter("alchemy.cli.invocations", {
   incremental: true,
 });
 
+/**
+ * Counter for Cloudflare State Store bootstrap/deploy operations.
+ * Tagged per call with `op` (e.g. `deploy`) and `status`
+ * (`success`/`error`) so that the deploy success rate of the
+ * state store itself can be tracked separately from regular
+ * resource lifecycle ops.
+ */
+export const stateStoreCounter = Metric.counter(
+  "alchemy.state_store.operations",
+  {
+    description:
+      "Number of Cloudflare State Store deploy/bootstrap operations dispatched by alchemy.",
+    incremental: true,
+  },
+);
+
+export type StateStoreOp = "deploy";
+
 /**
  * Wraps a resource lifecycle Effect to record a counter + timer entry,
  * tagged with `resource_type`, `op`, and `status` (`success`/`error`).
@@ -75,6 +93,26 @@ export const recordCli =
       ),
     );
 
+/**
+ * Wraps a Cloudflare State Store deploy/bootstrap Effect to bump
+ * {@link stateStoreCounter} with the outcome (`success`/`error`),
+ * tagged with the given `op`.
+ */
+export const recordStateStoreOp =
+  (op: StateStoreOp) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    self.pipe(
+      Effect.onExit((exit) =>
+        Metric.update(
+          Metric.withAttributes(stateStoreCounter, {
+            op,
+            status: Exit.isSuccess(exit) ? "success" : "error",
+          }),
+          1,
+        ),
+      ),
+    );
+
 export type ResourceOp = "precreate" | "create" | "update" | "delete" | "read";
 
 const elapsed = (startNs: bigint): Duration.Duration =>

package/src/Util/PlatformServices.ts

@@ -5,6 +5,8 @@ import type { Path } from "effect/Path";
 import type { Teardown } from "effect/Runtime";
 import type { Stdio } from "effect/Stdio";
 import type { Terminal } from "effect/Terminal";
+import type { HttpServer } from "effect/unstable/http/HttpServer";
+import type { ServeError } from "effect/unstable/http/HttpServerError";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 import type { WebSocketConstructor } from "effect/unstable/socket/Socket";
 
@@ -60,3 +62,20 @@ export const runMain = <E, A>(
     );
   }
 };
+
+export const httpServer = (
+  port: number = 0,
+  host: string = "localhost",
+): Layer.Layer<HttpServer, ServeError> =>
+  Effect.promise(async () => {
+    if (isBun) {
+      const BunHttpServer = await import("@effect/platform-bun/BunHttpServer");
+      return BunHttpServer.layer({ hostname: host, port });
+    } else {
+      const [NodeHttpServer, Http] = await Promise.all([
+        import("@effect/platform-node/NodeHttpServer"),
+        import("node:http"),
+      ]);
+      return NodeHttpServer.layerServer(Http.createServer, { host, port });
+    }
+  }).pipe(Layer.unwrap);

package/src/Util/layer-scoped.ts

@@ -0,0 +1,25 @@
+import type * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Scope from "effect/Scope";
+
+/**
+ * Builds a layer with the current scope.
+ * @param layer - The layer to build.
+ * @returns A scoped effect returning a Context with the provided layer.
+ */
+export const buildLayerScoped = <ROut, E, RIn>(
+  layer: Layer.Layer<ROut, E, RIn>,
+): Effect.Effect<Context.Context<ROut>, E, RIn | Scope.Scope> =>
+  Effect.flatMap(Effect.scope, (scope) => Layer.buildWithScope(layer, scope));
+
+/**
+ * Builds a layer with the current scope and provides it to the given effect.
+ * @param layer - The layer to build.
+ */
+export const provideLayerScoped =
+  <ROut, E1, RIn>(layer: Layer.Layer<ROut, E1, RIn>) =>
+  <A, E2, R>(effect: Effect.Effect<A, E2, R>) =>
+    Effect.flatMap(buildLayerScoped(layer), (context) =>
+      Effect.provideContext(effect, context),
+    );