alchemy-effect 0.6.2 → 0.6.4

package/src/Daemon/Client.ts

@@ -10,6 +10,7 @@ import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner
 import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
 import * as Socket from "effect/unstable/socket/Socket";
 import { resolveSocketPath } from "./Config.ts";
+import { DaemonConnectFailed, DaemonSocketNotReady } from "./Errors.ts";
 import { DaemonRpcs } from "./RpcSchema.ts";
 
 export type DaemonClient = Effect.Success<ReturnType<typeof makeClient>>;
@@ -58,17 +59,19 @@ export const DaemonLive: Layer.Layer<
     const socketPath = yield* resolveSocketPath;
 
     const client = yield* tryConnect(socketPath).pipe(
-      Effect.catch(() =>
+      Effect.catchTag("DaemonConnectFailed", () =>
         Effect.gen(function* () {
           yield* Effect.logInfo("Starting daemon…");
           yield* startDaemonProcess.pipe(Effect.forkChild);
           yield* waitForSocket(socketPath);
           yield* Effect.sleep("200 millis");
-          return yield* makeClient(socketPath);
+          return yield* tryConnect(socketPath);
         }),
       ),
       Effect.catchTag("PlatformError", (e) => Effect.die(e)),
-      Effect.catch(() => Effect.die(new Error("Failed to connect to daemon"))),
+      Effect.catchTag("DaemonConnectFailed", () =>
+        Effect.die(new Error("Failed to connect to daemon")),
+      ),
     );
 
     yield* client
@@ -90,19 +93,20 @@ const waitForSocket = (socketPath: string) =>
     const fs = yield* FileSystem.FileSystem;
     yield* fs.exists(socketPath).pipe(
       Effect.flatMap((exists) =>
-        exists ? Effect.void : Effect.fail("not yet" as const),
+        exists ? Effect.void : Effect.fail(new DaemonSocketNotReady()),
       ),
       Effect.retry(
-        Schedule.spaced("100 millis").pipe(
-          Schedule.compose(Schedule.recurs(50)),
-        ),
+        Schedule.spaced("100 millis").pipe(Schedule.both(Schedule.recurs(50))),
+      ),
+      Effect.catchTag("DaemonSocketNotReady", () =>
+        Effect.fail(new DaemonConnectFailed()),
       ),
     );
   });
 
 const tryConnect = (socketPath: string) =>
   makeClient(socketPath).pipe(
-    Effect.catch(() => Effect.fail("connect-failed" as const)),
+    Effect.catch(() => Effect.fail(new DaemonConnectFailed())),
   );
 
 const startDaemonProcess = Effect.gen(function* () {

package/src/Daemon/Errors.ts

@@ -13,7 +13,7 @@ export class ProcessNotFound extends Schema.TaggedClass<ProcessNotFound>()(
   { id: Schema.String },
 ) {}
 
-// Data-based errors used only by the server
+// Data-based errors used internally by the daemon runtime
 
 export class DaemonAlreadyRunning extends Data.TaggedError(
   "DaemonAlreadyRunning",
@@ -30,3 +30,19 @@ export class DaemonAlreadyRunning extends Data.TaggedError(
 export class LockCompromised extends Data.TaggedError("LockCompromised")<{
   readonly lockDir: string;
 }> {}
+
+export class DaemonSocketNotReady extends Data.TaggedError(
+  "DaemonSocketNotReady",
+) {
+  get message() {
+    return "Daemon socket is not ready yet";
+  }
+}
+
+export class DaemonConnectFailed extends Data.TaggedError(
+  "DaemonConnectFailed",
+) {
+  get message() {
+    return "Failed to connect to daemon";
+  }
+}

package/src/Daemon/index.ts

@@ -15,6 +15,8 @@ export type { DaemonClient } from "./Client.ts";
 
 export {
   DaemonAlreadyRunning,
+  DaemonConnectFailed,
+  DaemonSocketNotReady,
   LockCompromised,
   ProcessAlreadyExists,
   ProcessNotFound,

package/src/Plan.ts

@@ -342,20 +342,29 @@ export const make = <A>(
       ]),
     );
 
-    // Combined prop + binding upstream, filtered to resources in this graph
-    const allUpstreamDependencies: {
+    // Combined prop + binding upstream for the desired graph, including
+    // references to resources outside the current graph so delete validation can
+    // tell whether any surviving resource still points at an orphan.
+    const rawUpstreamDependencies: {
       [fqn: string]: string[];
     } = Object.fromEntries(
       resources.map((resource) => {
         const fqn = resource.FQN;
         const propDeps = newUpstreamDependencies[fqn] ?? [];
         const bindDeps = bindingUpstreamDependencies[fqn] ?? [];
-        return [
-          fqn,
-          [...new Set([...propDeps, ...bindDeps])].filter((dep) =>
-            newResourceFqns.has(dep),
-          ),
-        ];
+        return [fqn, [...new Set([...propDeps, ...bindDeps])]];
+      }),
+    );
+
+    // Combined prop + binding upstream, filtered to resources in this graph for
+    // scheduling and cycle detection.
+    const allUpstreamDependencies: {
+      [fqn: string]: string[];
+    } = Object.fromEntries(
+      resources.map((resource) => {
+        const fqn = resource.FQN;
+        const deps = rawUpstreamDependencies[fqn] ?? [];
+        return [fqn, deps.filter((dep) => newResourceFqns.has(dep))];
       }),
     );
 
@@ -755,11 +764,13 @@ export const make = <A>(
       )).filter((v) => !!v),
     );
 
-    for (const [resourceFqn, deletion] of Object.entries(deletions)) {
-      // downstream is stored as FQNs - check if any exist in resourceGraph
-      const dependencies = deletion.state.downstream.filter(
-        (d) => d in resourceGraph,
-      );
+    for (const resourceFqn of Object.keys(deletions)) {
+      const dependencies = Object.entries(rawUpstreamDependencies)
+        .filter(
+          ([survivorFqn, upstream]) =>
+            survivorFqn in resourceGraph && upstream.includes(resourceFqn),
+        )
+        .map(([survivorFqn]) => survivorFqn);
       if (dependencies.length > 0) {
         return yield* new DeleteResourceHasDownstreamDependencies({
           message: `Resource ${resourceFqn} has downstream dependencies`,

package/src/Random.ts

@@ -0,0 +1,61 @@
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import { Resource } from "./Resource.ts";
+
+export interface RandomProps {
+  /**
+   * Number of random bytes to generate before hex encoding.
+   * @default 32
+   */
+  bytes?: number;
+}
+
+export type Random = Resource<
+  "Alchemy.Random",
+  RandomProps,
+  {
+    text: Redacted.Redacted<string>;
+  }
+>;
+
+export const makeRandom = (id: string, props?: RandomProps) =>
+  Random(id, props).pipe(Effect.flatMap((rand) => rand.text.asEffect()));
+
+/**
+ * A deterministic-in-state random secret generator.
+ *
+ * The value is generated once on create and then persisted in state so
+ * subsequent deploys keep the same secret unless the resource is replaced.
+ */
+export const Random = Resource<Random>("Alchemy.Random");
+
+export const RandomProvider = () =>
+  Random.provider.succeed({
+    create: Effect.fn(function* ({ news = {}, output }) {
+      if (output?.text) {
+        return output;
+      }
+
+      const byteLength = news.bytes ?? 32;
+      const text = yield* Effect.sync(() => {
+        const bytes = new Uint8Array(byteLength);
+        crypto.getRandomValues(bytes);
+        return Redacted.make(
+          Array.from(bytes)
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join(""),
+        );
+      });
+
+      return { text };
+    }),
+    update: Effect.fn(function* ({ output }) {
+      return output;
+    }),
+    delete: Effect.fn(function* () {
+      return undefined;
+    }),
+    read: Effect.fn(function* ({ output }) {
+      return output;
+    }),
+  });

package/src/Tags.ts

@@ -31,7 +31,7 @@ export const createTagsList = (tags: Tags) =>
       Value,
     }));
 
-export const createInternalTags = Effect.fn(function* (id: string) {
+export const createInternalTags = Effect.fnUntraced(function* (id: string) {
   const stack = yield* Stack;
   const stage = yield* Stage;
   return {
@@ -45,7 +45,9 @@ export const createInternalTags = Effect.fn(function* (id: string) {
  * Creates AWS-compatible tag filters for finding resources by alchemy tags.
  * Use with AWS describe APIs that accept Filter parameters.
  */
-export const createAlchemyTagFilters = Effect.fn(function* (id: string) {
+export const createAlchemyTagFilters = Effect.fnUntraced(function* (
+  id: string,
+) {
   const stack = yield* Stack;
   const stage = yield* Stage;
   return [
@@ -58,7 +60,7 @@ export const createAlchemyTagFilters = Effect.fn(function* (id: string) {
 /**
  * Checks if a resource has the expected alchemy tags for this app/stage/id.
  */
-export const hasAlchemyTags = Effect.fn(function* (
+export const hasAlchemyTags = Effect.fnUntraced(function* (
   id: string,
   tags: Tags | undefined,
 ) {

package/src/index.ts

@@ -17,6 +17,7 @@ export * as Output from "./Output.ts";
 export * from "./PhysicalName.ts";
 export * as Plan from "./Plan.ts";
 export * from "./Provider.ts";
+export * from "./Random.ts";
 export * from "./Ref.ts";
 export * as RemovalPolicy from "./RemovalPolicy.ts";
 export * from "./Resource.ts";