alchemy 2.0.0-beta.51 → 2.0.0-beta.53

package/bin/exec.js

@@ -24,7 +24,7 @@ import * as Data from "effect/Data";
 import * as Duration from "effect/Duration";
 import { flow, pipe } from "effect/Function";
 import { SingleShotGen } from "effect/Utils";
-import { pipeArguments } from "effect/Pipeable";
+import * as Effectable from "effect/Effectable";
 import "effect/Predicate";
 import "effect/Record";
 import * as Cause from "effect/Cause";
@@ -71,15 +71,15 @@ const emptyConfig = () => ({
 	version: CONFIG_VERSION,
 	profiles: {}
 });
-var Profile = class extends EffectContext.Service()("Alchemy::Profile") {};
+var AlchemyProfile = class extends EffectContext.Service()("Alchemy::Profile") {};
 /**
-* Layer that builds the {@link Profile} service. Captures the
+* Layer that builds the {@link AlchemyProfile} service. Captures the
 * {@link FileSystem.FileSystem} dependency at layer-build time, so any
-* Effect that yields {@link Profile} ends up with `R = Profile` (no
+* Effect that yields {@link AlchemyProfile} ends up with `R = Profile` (no
 * `FileSystem` leak). Provide this once at the top of your runtime
 * (alongside `PlatformServices` / `NodeContext`).
 */
-const ProfileLive = Layer.effect(Profile, Effect.gen(function* () {
+const ProfileLive = Layer.effect(AlchemyProfile, Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const readConfig = fs.readFileString(configFilePath).pipe(Effect.flatMap((data) => Effect.try({
 		try: () => {
@@ -750,8 +750,8 @@ const evaluate = (expr, upstream$1) => Effect.gen(function* () {
 		}
 	}
 	if (Array.isArray(expr)) return yield* Effect.all(expr.map((item) => evaluate(item, upstream$1)));
-	else if (Redacted.isRedacted(expr)) return expr;
-	else if (Duration.isDuration(expr)) return expr;
+	else if (Config.isConfig(expr)) return yield* evaluate(yield* expr, upstream$1);
+	else if (Duration.isDuration(expr) || Redacted.isRedacted(expr)) return expr;
 	else if (typeof expr === "object" && expr !== null) return Object.fromEntries(yield* Effect.all(Object.entries(expr).map(([key, value]) => evaluate(value, upstream$1).pipe(Effect.map((value$1) => [key, value$1])))));
 	return expr;
 });
@@ -798,24 +798,12 @@ const loadConfigProvider = (envFile$1) => {
 
 //#endregion
 //#region lib/Util/effect.js
-const effectClass = ((impl) => impl === void 0 ? (innerImpl) => effectClass(innerImpl) : Object.assign(class {
-	static asEffect() {
-		return impl;
-	}
-	static [Symbol.iterator]() {
-		return new SingleShotGen(this.asEffect());
-	}
-	static pipe(...fns) {
-		return pipeArguments(this, fns);
-	}
-}, impl));
+const effectClass = ((impl) => impl === void 0 ? (innerImpl) => effectClass(innerImpl) : Object.assign(class {}, Effectable.Prototype({
+	label: "alchemy/EffectClass",
+	evaluate: () => impl
+})));
 const taggedFunction = (tag$1, fn) => {
-	const overrides = {
-		asEffect: () => tag$1,
-		[Symbol.iterator]: () => tag$1[Symbol.iterator](),
-		pipe: (...fns) => pipeArguments(tag$1, fns),
-		toString: () => `${tag$1.toString()}.${fn.name}`
-	};
+	const overrides = { toString: () => `${tag$1.toString()}.${fn.name}` };
 	return new Proxy(fn, {
 		get: (target, prop, receiver) => Reflect.has(overrides, prop) ? Reflect.get(overrides, prop, receiver) : Reflect.has(target, prop) ? Reflect.get(target, prop, receiver) : Reflect.get(tag$1, prop, tag$1),
 		has: (target, prop) => Reflect.has(overrides, prop) || Reflect.has(target, prop) || Reflect.has(tag$1, prop)
@@ -907,7 +895,7 @@ const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer, Logger.
 const unwrapRpcHandlers = (handlers, streamKeys) => {
 	return Object.fromEntries(Object.entries(handlers).map(([key, value]) => [key, typeof value === "function" ? streamKeys?.includes(key) ? unwrapRpcStreamHandler(value) : unwrapRpcEffectHandler(value) : typeof value === "object" && value !== null ? unwrapRpcHandlers(value) : value]));
 };
-const serializeError = Schema.encodeSync(Schema.Defect);
+const serializeError = Schema.encodeSync(Schema.Defect());
 const unwrapRpcEffectHandler = (handler) => flow((...args) => serializeRpcArgs(args), (args) => Effect.promise(() => handler(args)), Effect.flatMap((exit) => {
 	if (exit._tag === "Success") return Exit.succeed(exit.value);
 	return Exit.failCause(Cause.fromReasons(exit.cause.map((reason) => {
@@ -981,6 +969,10 @@ const _hasUnresolved = (value) => {
 const havePropsChanged = (oldProps, newProps) => hasOutputs(newProps) || JSON.stringify(canonicalize(oldProps ?? {}, false)) !== JSON.stringify(canonicalize(newProps ?? {}, false));
 const canonicalize = (value, stripNullish) => {
 	if (stripNullish && value == null) return void 0;
+	if (Redacted.isRedacted(value)) return {
+		_tag: "Redacted",
+		value: Redacted.value(value)
+	};
 	if (Array.isArray(value)) return value.map((v) => canonicalize(v, stripNullish));
 	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).filter(([, nested]) => !stripNullish || nested != null).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => [key, canonicalize(nested, stripNullish)]));
 	return value;
@@ -1259,8 +1251,8 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 	const resolveInput = (input) => Effect.gen(function* () {
 		if (!input) return input;
 		else if (isExpr(input)) return yield* resolveOutput(input);
-		else if (Redacted.isRedacted(input)) return input;
-		else if (Duration.isDuration(input)) return input;
+		else if (Config.isConfig(input)) return yield* resolveInput(yield* input);
+		else if (Duration.isDuration(input) || Redacted.isRedacted(input)) return input;
 		else if (Array.isArray(input)) return yield* Effect.all(input.map(resolveInput), { concurrency: "unbounded" });
 		else if (isResource(input)) return yield* resolveInput(yield* resolveOutput(of(input)));
 		else if (typeof input === "object") return Object.fromEntries(yield* Effect.all(Object.entries(input).map(([key, value]) => resolveInput(value).pipe(Effect.map((value$1) => [key, value$1]))), { concurrency: "unbounded" }));
@@ -2487,7 +2479,9 @@ const collectGarbage = Effect.fnUntraced(function* (plan, session) {
 						removalPolicy: node.resource.RemovalPolicy
 					});
 				}
-				if (attr !== void 0) yield* provider.delete({
+				const retainOldGeneration = !isDeleteNode(node) && node.removalPolicy === "retain";
+				if (retainOldGeneration) yield* scopedSession.note("Retaining replaced resource (removal policy: retain)...");
+				if (attr !== void 0 && !retainOldGeneration) yield* provider.delete({
 					id: logicalId,
 					instanceId,
 					olds: props,
@@ -2503,7 +2497,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan, session) {
 					});
 					yield* report("deleted");
 				} else {
-					yield* scopedSession.note("Cleaning up replaced resource...");
+					if (!retainOldGeneration) yield* scopedSession.note("Cleaning up replaced resource...");
 					if (node.old.status === "replacing" || node.old.status === "replaced") yield* commit({
 						status: "replaced",
 						fqn,
@@ -2532,7 +2526,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan, session) {
 						bindings: excludeDeletedBindings(node.bindings),
 						removalPolicy: node.removalPolicy
 					});
-					yield* scopedSession.note("Replaced resource cleanup complete.");
+					yield* scopedSession.note(retainOldGeneration ? "Replaced resource retained." : "Replaced resource cleanup complete.");
 				}
 			}));
 		});