alchemy-effect 0.3.0 → 0.5.0

package/src/instance-id.ts

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+
+/** A 16-byte (128-bit) random hex-encoded string representing an physical instance of a logical resource */
+export class InstanceId extends Context.Tag("instance-id")<
+  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,84 @@
 import * as Effect from "effect/Effect";
 import { App } from "./app.ts";
+import { InstanceId } from "./instance-id.ts";
 
-export const physicalName = Effect.fn(function* (id: string) {
+export const createPhysicalName = Effect.fn(function* ({
+  id,
+  // 16 base32 characters = 80 bits of entropy = 4 × 10⁻⁷
+  instanceId,
+  suffixLength = 16,
+  maxLength = 64,
+}: {
+  id: string;
+  /**
+   * Hex-encoded instance ID (16 random bytes)
+   *
+   * @default - the InstanceID set by the engine in Context
+   */
+  instanceId?: string;
+  suffixLength?: number;
+  /**
+   * Maximum length of the physical name.
+   *
+   * If the name exceeds this length, the human-friendly portion of the name will be truncated to maxLength-suffixLength
+   */
+  maxLength?: number;
+}) {
   const app = yield* App;
-  return `${app.name}-${id}-${app.stage}`;
+  const sanitizedId = id.replace(/[^a-zA-Z0-9-_]/g, "-");
+  const prefix = `${app.name}-${sanitizedId}-${app.stage}-`;
+  const randomId = base32(
+    Buffer.from(instanceId ?? (yield* InstanceId), "hex"),
+  );
+  const suffix = randomId.slice(0, suffixLength);
+  const name = `${prefix}${suffix}`;
+  if (maxLength && name.length > maxLength) {
+    return `${prefix.slice(0, maxLength - suffix.length)}${suffix}`;
+  }
+  return name;
 });
+
+// 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("");
+}