alchemy-effect 0.3.0 → 0.4.0

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

@@ -38,7 +38,13 @@ export const bucketProvider = () =>
               return { action: "replace" };
             }
             if (output.storageClass !== (news.storageClass ?? "Standard")) {
-              return { action: "update" };
+              return {
+                action: "update",
+                stables:
+                  output.name === createName(id, news.name)
+                    ? ["name"]
+                    : undefined,
+              };
             }
             return { action: "noop" };
           }),

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

@@ -7,8 +7,8 @@ import type { ScopedPlanStatusSession } from "../../cli/service.ts";
 import { DotAlchemy } from "../../dot-alchemy.ts";
 import { ESBuild } from "../../esbuild.ts";
 import { sha256 } from "../../sha256.ts";
-import { CloudflareApi } from "../api.ts";
 import { Account } from "../account.ts";
+import { CloudflareApi } from "../api.ts";
 import { Assets } from "./assets.provider.ts";
 import { Worker, type WorkerAttr, type WorkerProps } from "./worker.ts";
 
@@ -187,6 +187,7 @@ export const workerProvider = () =>
       });
 
       return {
+        stables: ["id"],
         diff: Effect.fnUntraced(function* ({ id, olds, news, output }) {
           if (output.accountId !== accountId) {
             return { action: "replace" };
@@ -203,7 +204,10 @@ export const workerProvider = () =>
             assets?.hash !== output.hash.assets ||
             bundle.hash !== output.hash.bundle
           ) {
-            return { action: "update" };
+            return {
+              action: "update",
+              stables: output.name === workerName ? ["name"] : undefined,
+            };
           }
         }),
         create: Effect.fnUntraced(function* ({ id, news, bindings, session }) {

package/src/diff.ts

@@ -1,20 +1,21 @@
-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 type Diff = NoopDiff | UpdateDiff | ReplaceDiff;
+
+export interface NoopDiff {
+  action: "noop";
+  stables?: undefined;
+}
+
+export interface UpdateDiff {
+  action: "update";
+  /** properties that won't change as part of this update */
+  stables?: string[];
+}
+
+export interface ReplaceDiff {
+  action: "replace";
+  deleteFirst?: boolean;
+  stables?: undefined;
+}
 
 export const somePropsAreDifferent = <Props extends Record<string, any>>(
   olds: Props,
@@ -28,3 +29,20 @@ export const somePropsAreDifferent = <Props extends Record<string, any>>(
   }
   return false;
 };
+
+export const anyPropsAreDifferent = <Props extends Record<string, any>>(
+  olds: Props,
+  news: Props,
+) => {
+  for (const prop in olds) {
+    if (olds[prop] !== news[prop]) {
+      return true;
+    }
+  }
+  for (const prop in news) {
+    if (!(prop in olds)) {
+      return true;
+    }
+  }
+  return false;
+};

package/src/event.ts

@@ -1,11 +1,17 @@
 export type ApplyStatus =
+  | "attaching"
+  | "post-attach"
   | "pending"
+  | "pre-creating"
   | "creating"
+  | "creating replacement"
   | "created"
   | "updating"
   | "updated"
   | "deleting"
   | "deleted"
+  | "replacing"
+  | "replaced"
   | "success"
   | "fail";
 

package/src/instance-id.ts

@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect";
+
+/** A 16-byte (128-bit) random hex-encoded string representing an physical instance of a logical resource */
+export type InstanceId = string;
+
+/**
+ * @returns Hex-encoded instance ID (16 random bytes)
+ */
+export const generateInstanceId = () =>
+  Effect.sync(() => {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+  });

package/src/output.ts

@@ -1,13 +1,13 @@
 import { pipe } from "effect";
-import * as App from "./app.ts";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
+import * as App from "./app.ts";
 import { isPrimitive } from "./data.ts";
 import type { From } from "./policy.ts";
+import { getRefMetadata, isRef, ref as stageRef, type Ref } from "./ref.ts";
 import type { AnyResource, Resource } from "./resource.ts";
-import type { IsAny, UnionToIntersection } from "./util.ts";
 import * as State from "./state.ts";
-import { isRef, type Ref, getRefMetadata, ref as stageRef } from "./ref.ts";
+import type { IsAny, UnionToIntersection } from "./util.ts";
 
 // a special symbol only used at runtime to probe the Output proxy
 const ExprSymbol = Symbol.for("alchemy/Expr");
@@ -125,7 +125,7 @@ const proxy = (self: any): any => {
             return new EffectExpr(self.expr, args[0]);
           }
         }
-        throw new Error("Not callable");
+        return undefined;
       },
     },
   );
@@ -367,7 +367,7 @@ export const evaluate: <A, Upstream extends AnyResource, Req>(
           }),
         );
       }
-      return resource.output;
+      return resource.attr;
     } else if (Array.isArray(expr)) {
       return yield* Effect.all(expr.map((item) => evaluate(item, upstream)));
     } else if (typeof expr === "object" && expr !== null) {
@@ -389,6 +389,30 @@ export type Upstream<O extends Output<any, any, any>> =
       }
     : never;
 
+export const hasOutputs = (value: any): value is Output<any, any, any> =>
+  Object.keys(upstreamAny(value)).length > 0;
+
+export const upstreamAny = (
+  value: any,
+): {
+  [ID in string]: Resource;
+} => {
+  if (isExpr(value)) {
+    return upstream(value);
+  } else if (Array.isArray(value)) {
+    return Object.assign({}, ...value.map(resolveUpstream));
+  } else if (
+    value &&
+    (typeof value === "object" || typeof value === "function")
+  ) {
+    return Object.assign(
+      {},
+      ...Object.values(value).map((value) => resolveUpstream(value)),
+    );
+  }
+  return {};
+};
+
 export const upstream = <E extends Output<any, AnyResource, any>>(
   expr: E,
 ): {

package/src/physical-name.ts

@@ -1,7 +1,62 @@
 import * as Effect from "effect/Effect";
 import { App } from "./app.ts";
 
-export const physicalName = Effect.fn(function* (id: string) {
+export const physicalName = Effect.fn(function* ({
+  id,
+  instanceId,
+  // 16 base32 characters = 80 bits of entropy = 4 × 10⁻⁷
+  suffixLength = 16,
+}: {
+  id: string;
+  /** Hex-encoded instance ID (16 random bytes) */
+  instanceId: string;
+  suffixLength?: number;
+}) {
   const app = yield* App;
-  return `${app.name}-${id}-${app.stage}`;
+  return `${app.name}-${id}-${app.stage}-${base32(Buffer.from(instanceId, "hex")).slice(0, suffixLength)}`;
 });
+
+// Base32 is ideal for physical names because it's denser than hex (5 bits per char vs 4)
+// and compatible with DNS/S3 (as opposed to base64 which contains uppercase letters and symbols).
+
+// base32.ts
+// Concise, fast RFC 4648 Base32 encoder (no padding), lowercase output.
+// Charset: a-z2-7 (DNS/S3 friendly)
+const ALPH = "abcdefghijklmnopqrstuvwxyz234567";
+
+/**
+ * Encode bytes into RFC4648 Base32 (no padding), lowercase.
+ *
+ * Performance notes:
+ * - O(n) single pass, no big-int
+ * - Avoids per-byte string concatenation by using a char array
+ */
+export function base32(bytes: Uint8Array): string {
+  const n = bytes.length;
+  if (n === 0) return "";
+
+  // Base32 length without padding: ceil(n*8/5)
+  const outLen = ((n * 8 + 4) / 5) | 0;
+  const out = Array.from<string>({ length: outLen });
+
+  let buffer = 0;
+  let bits = 0;
+  let o = 0;
+
+  for (let i = 0; i < n; i++) {
+    buffer = (buffer << 8) | bytes[i];
+    bits += 8;
+
+    while (bits >= 5) {
+      out[o++] = ALPH[(buffer >>> (bits - 5)) & 31];
+      bits -= 5;
+    }
+  }
+
+  if (bits > 0) {
+    out[o++] = ALPH[(buffer << (5 - bits)) & 31];
+  }
+
+  // outLen computed as exact ceiling; o should match, but slice defensively.
+  return o === outLen ? out.join("") : out.slice(0, o).join("");
+}