@terraforge/core 0.0.9 → 0.0.11

package/dist/index.mjs

@@ -0,0 +1,1454 @@
+import asyncOnExit from "async-on-exit";
+import promiseLimit from "p-limit";
+import { DirectedGraph } from "graphology";
+import { topologicalGenerations, willCreateCycle } from "graphology-dag";
+import { v5 } from "uuid";
+import { get } from "get-wild";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { lock } from "proper-lockfile";
+import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client, S3ServiceException } from "@aws-sdk/client-s3";
+import { DynamoDB } from "@aws-sdk/client-dynamodb";
+import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
+import { createHash } from "node:crypto";
+
+//#region src/node.ts
+const nodeMetaSymbol = Symbol("metadata");
+const isNode = (obj) => {
+	const meta = obj[nodeMetaSymbol];
+	return meta && typeof meta === "object" && meta !== null && "tag" in meta && typeof meta.tag === "string";
+};
+function getMeta(node) {
+	return node[nodeMetaSymbol];
+}
+const isResource = (obj) => {
+	return isNode(obj) && obj[nodeMetaSymbol].tag === "resource";
+};
+const isDataSource = (obj) => {
+	return isNode(obj) && obj[nodeMetaSymbol].tag === "data";
+};
+
+//#endregion
+//#region src/group.ts
+var Group = class Group {
+	children = [];
+	constructor(parent, type, name) {
+		this.parent = parent;
+		this.type = type;
+		this.name = name;
+		parent?.children.push(this);
+	}
+	get urn() {
+		return `${this.parent ? this.parent.urn : "urn"}:${this.type}:{${this.name}}`;
+	}
+	addChild(child) {
+		if (isNode(child)) {
+			const meta = getMeta(child);
+			if (this.children.filter((c) => isResource(c)).map((c) => getMeta(c)).find((c) => c.type === meta.type && c.logicalId === meta.logicalId)) throw new Error(`Duplicate node found: ${meta.type}:${meta.logicalId}`);
+		}
+		if (child instanceof Group) {
+			if (this.children.filter((c) => c instanceof Group).find((c) => c.type === child.type && c.name === child.name)) throw new Error(`Duplicate group found: ${child.type}:${child.name}`);
+		}
+		this.children.push(child);
+	}
+	add(...children) {
+		for (const child of children) this.addChild(child);
+	}
+	get nodes() {
+		return this.children.map((child) => {
+			if (child instanceof Group) return child.nodes;
+			if (isNode(child)) return child;
+		}).flat().filter((child) => !!child);
+	}
+	get resources() {
+		return this.nodes.filter((node) => isResource(node));
+	}
+	get dataSources() {
+		return this.nodes.filter((node) => isDataSource(node));
+	}
+};
+
+//#endregion
+//#region src/stack.ts
+var Stack = class extends Group {
+	dependencies = /* @__PURE__ */ new Set();
+	constructor(app, name) {
+		super(app, "stack", name);
+		this.app = app;
+	}
+	dependsOn(...stacks) {
+		for (const stack of stacks) {
+			if (stack.app !== this.app) throw new Error(`Stacks that belong to different apps can't be dependent on each other`);
+			this.dependencies.add(stack);
+		}
+		return this;
+	}
+};
+const findParentStack = (group) => {
+	if (group instanceof Stack) return group;
+	if (!group.parent) throw new Error("No stack found");
+	return findParentStack(group.parent);
+};
+
+//#endregion
+//#region src/app.ts
+var App = class extends Group {
+	constructor(name) {
+		super(void 0, "app", name);
+		this.name = name;
+	}
+	get stacks() {
+		return this.children.filter((child) => child instanceof Stack);
+	}
+};
+
+//#endregion
+//#region src/future.ts
+const IDLE = 0;
+const PENDING = 1;
+const RESOLVED = 2;
+const REJECTED = 3;
+var Future = class Future {
+	listeners = /* @__PURE__ */ new Set();
+	status = IDLE;
+	data;
+	error;
+	constructor(callback) {
+		this.callback = callback;
+	}
+	get [Symbol.toStringTag]() {
+		switch (this.status) {
+			case IDLE: return `<idle>`;
+			case PENDING: return `<pending>`;
+			case RESOLVED: return `${this.data}`;
+			case REJECTED: return `<rejected> ${this.error}`;
+		}
+	}
+	pipe(cb) {
+		return new Future((resolve$1, reject) => {
+			this.then((value) => {
+				Promise.resolve(cb(value)).then((value$1) => {
+					resolve$1(value$1);
+				}).catch(reject);
+			}, reject);
+		});
+	}
+	then(resolve$1, reject) {
+		if (this.status === RESOLVED) resolve$1(this.data);
+		else if (this.status === REJECTED) reject?.(this.error);
+		else {
+			this.listeners.add({
+				resolve: resolve$1,
+				reject
+			});
+			if (this.status === IDLE) {
+				this.status = PENDING;
+				this.callback((data) => {
+					if (this.status === PENDING) {
+						this.status = RESOLVED;
+						this.data = data;
+						this.listeners.forEach(({ resolve: resolve$2 }) => resolve$2(data));
+						this.listeners.clear();
+					}
+				}, (error) => {
+					if (this.status === PENDING) {
+						this.status = REJECTED;
+						this.error = error;
+						this.listeners.forEach(({ reject: reject$1 }) => reject$1?.(error));
+						this.listeners.clear();
+					}
+				});
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/input.ts
+const findInputDeps = (props) => {
+	const deps = [];
+	const find = (props$1) => {
+		if (props$1 instanceof Output) deps.push(...props$1.dependencies);
+		else if (Array.isArray(props$1)) props$1.map(find);
+		else if (props$1?.constructor === Object) Object.values(props$1).map(find);
+	};
+	find(props);
+	return deps;
+};
+const resolveInputs = async (inputs) => {
+	const unresolved = [];
+	const find = (props, parent, key) => {
+		if (props instanceof Output || props instanceof Future || props instanceof Promise) unresolved.push([parent, key]);
+		else if (Array.isArray(props)) props.map((value, index) => find(value, props, index));
+		else if (props?.constructor === Object) Object.entries(props).map(([key$1, value]) => find(value, props, key$1));
+	};
+	find(inputs, {}, "root");
+	const responses = await Promise.all(unresolved.map(async ([obj, key]) => {
+		const promise = obj[key];
+		let timeout;
+		const response = await Promise.race([promise, new Promise((_, reject) => {
+			timeout = setTimeout(() => {
+				if (promise instanceof Output) reject(/* @__PURE__ */ new Error(`Resolving Output<${[...promise.dependencies].map((d) => d.urn).join(", ")}> took too long.`));
+				else if (promise instanceof Future) reject(/* @__PURE__ */ new Error("Resolving Future took too long."));
+				else reject(/* @__PURE__ */ new Error("Resolving Promise took too long."));
+			}, 3e3);
+		})]);
+		clearTimeout(timeout);
+		return response;
+	}));
+	unresolved.forEach(([props, key], i) => {
+		props[key] = responses[i];
+	});
+	return inputs;
+};
+
+//#endregion
+//#region src/output.ts
+var Output = class Output extends Future {
+	constructor(dependencies, callback) {
+		super(callback);
+		this.dependencies = dependencies;
+	}
+	pipe(cb) {
+		return new Output(this.dependencies, (resolve$1, reject) => {
+			this.then((value) => {
+				Promise.resolve(cb(value)).then((value$1) => {
+					resolve$1(value$1);
+				}).catch(reject);
+			}, reject);
+		});
+	}
+};
+const deferredOutput = (cb) => {
+	return new Output(/* @__PURE__ */ new Set(), cb);
+};
+const output = (value) => {
+	return deferredOutput((resolve$1) => resolve$1(value));
+};
+const combine = (...inputs) => {
+	return new Output(new Set(findInputDeps(inputs)), (resolve$1, reject) => {
+		Promise.all(inputs).then((result) => {
+			resolve$1(result);
+		}, reject);
+	});
+};
+const resolve = (inputs, transformer) => {
+	return combine(...inputs).pipe((data) => {
+		return transformer(...data);
+	});
+};
+const interpolate = (literals, ...placeholders) => {
+	return combine(...placeholders).pipe((unwrapped) => {
+		const result = [];
+		for (let i = 0; i < unwrapped.length; i++) result.push(literals[i], unwrapped[i]);
+		result.push(literals.at(-1));
+		return result.join("");
+	});
+};
+
+//#endregion
+//#region src/urn.ts
+const createUrn = (tag, type, name, parentUrn) => {
+	return `${parentUrn ? parentUrn : "urn"}:${tag}:${type}:{${name}}`;
+};
+
+//#endregion
+//#region src/meta.ts
+const createMeta = (tag, provider, parent, type, logicalId, input, config) => {
+	const urn = createUrn(tag, type, logicalId, parent.urn);
+	const stack = findParentStack(parent);
+	let output$1;
+	return {
+		tag,
+		urn,
+		logicalId,
+		type,
+		stack,
+		provider,
+		input,
+		config,
+		get dependencies() {
+			const dependencies = /* @__PURE__ */ new Set();
+			const linkMetaDep = (dep) => {
+				if (dep.urn === urn) throw new Error("You can't depend on yourself");
+				dependencies.add(dep.urn);
+			};
+			for (const dep of findInputDeps(input)) linkMetaDep(dep);
+			for (const dep of config?.dependsOn ?? []) linkMetaDep(getMeta(dep));
+			return dependencies;
+		},
+		resolve(data) {
+			output$1 = data;
+		},
+		output(cb) {
+			return new Output(new Set([this]), (resolve$1) => {
+				if (!output$1) throw new Error(`Unresolved output for ${tag}: ${urn}`);
+				resolve$1(cb(output$1));
+			});
+		}
+	};
+};
+
+//#endregion
+//#region src/debug.ts
+let enabled = false;
+const enableDebug = () => {
+	enabled = true;
+};
+const createDebugger = (group) => {
+	return (...args) => {
+		if (!enabled) return;
+		console.log();
+		console.log(`${group}:`, ...args);
+		console.log();
+	};
+};
+
+//#endregion
+//#region src/workspace/exit.ts
+const listeners = /* @__PURE__ */ new Set();
+let listening = false;
+const onExit = (cb) => {
+	listeners.add(cb);
+	if (!listening) {
+		listening = true;
+		asyncOnExit(async () => {
+			await Promise.allSettled([...listeners].map((cb$1) => cb$1()));
+		}, true);
+	}
+	return () => {
+		listeners.delete(cb);
+		if (listeners.size === 0) {
+			listening = false;
+			asyncOnExit.dispose();
+		}
+	};
+};
+
+//#endregion
+//#region src/workspace/lock.ts
+const lockApp = async (lockBackend, app, fn) => {
+	let releaseLock;
+	try {
+		releaseLock = await lockBackend.lock(app.urn);
+	} catch (error) {
+		throw new Error(`Already in progress: ${app.urn}`);
+	}
+	const releaseExit = onExit(async () => {
+		await releaseLock();
+	});
+	let result;
+	try {
+		result = await fn();
+	} catch (error) {
+		throw error;
+	} finally {
+		await releaseLock();
+		releaseExit();
+	}
+	return result;
+};
+
+//#endregion
+//#region src/workspace/concurrency.ts
+const createConcurrencyQueue = (concurrency) => {
+	const queue = promiseLimit(concurrency);
+	return (cb) => {
+		return queue(cb);
+	};
+};
+
+//#endregion
+//#region src/workspace/entries.ts
+const entries = (object) => {
+	return Object.entries(object);
+};
+
+//#endregion
+//#region src/workspace/dependency.ts
+var DependencyGraph = class {
+	graph = new DirectedGraph();
+	callbacks = /* @__PURE__ */ new Map();
+	add(urn, deps, callback) {
+		this.callbacks.set(urn, callback);
+		this.graph.mergeNode(urn);
+		for (const dep of deps) {
+			if (!dep) throw new Error(`Resource ${urn} has an undefined dependency.`);
+			if (willCreateCycle(this.graph, dep, urn)) throw new Error(`There is a circular dependency between ${urn} -> ${dep}`);
+			this.graph.mergeEdge(dep, urn);
+		}
+	}
+	validate() {
+		const nodes = this.graph.nodes();
+		for (const urn of nodes) if (!this.callbacks.has(urn)) {
+			const deps = this.graph.filterNodes((node) => {
+				return this.graph.areNeighbors(node, urn);
+			});
+			throw new Error(`The following resources ${deps.join(", ")} have a missing dependency: ${urn}`);
+		}
+	}
+	async run() {
+		this.validate();
+		const graph = topologicalGenerations(this.graph);
+		const errors = [];
+		for (const list of graph) {
+			const result = await Promise.allSettled(list.map((urn) => {
+				const callback = this.callbacks.get(urn);
+				if (!callback) return;
+				return callback();
+			}));
+			for (const entry of result) if (entry.status === "rejected") if (entry.reason instanceof Error) errors.push(entry.reason);
+			else errors.push(/* @__PURE__ */ new Error(`Unknown error: ${entry.reason}`));
+			if (errors.length > 0) break;
+		}
+		return errors;
+	}
+};
+const dependentsOn = (resources, dependency) => {
+	const dependents = [];
+	for (const [urn, resource] of entries(resources)) if (resource.dependencies.includes(dependency)) dependents.push(urn);
+	return dependents;
+};
+const findDependencyPaths = (value, dependencyUrn, path = []) => {
+	const paths = [];
+	const visit = (current, currentPath) => {
+		if (current instanceof Output) {
+			for (const dep of current.dependencies) if (dep.urn === dependencyUrn) {
+				paths.push(currentPath);
+				return;
+			}
+			return;
+		}
+		if (Array.isArray(current)) {
+			current.forEach((item, index) => {
+				visit(item, [...currentPath, index]);
+			});
+			return;
+		}
+		if (current && typeof current === "object") for (const [key, item] of Object.entries(current)) visit(item, [...currentPath, key]);
+	};
+	visit(value, path);
+	return paths;
+};
+const cloneState = (value) => JSON.parse(JSON.stringify(value));
+const removeAtPath = (target, path) => {
+	if (path.length === 0) return;
+	let parent = target;
+	for (let i = 0; i < path.length - 1; i++) {
+		if (parent == null) return;
+		parent = parent[path[i]];
+	}
+	const last = path[path.length - 1];
+	if (Array.isArray(parent) && typeof last === "number") {
+		if (last >= 0 && last < parent.length) parent.splice(last, 1);
+		return;
+	}
+	if (parent && typeof parent === "object") delete parent[last];
+};
+const stripDependencyInputs = (input, metaInput, dependencyUrn) => {
+	const paths = findDependencyPaths(metaInput, dependencyUrn);
+	if (paths.length === 0) return input;
+	const detached = cloneState(input);
+	const sortedPaths = [...paths].sort((a, b) => {
+		if (a.length !== b.length) return b.length - a.length;
+		const aLast = a[a.length - 1];
+		const bLast = b[b.length - 1];
+		if (typeof aLast === "number" && typeof bLast === "number") return bLast - aLast;
+		return 0;
+	});
+	for (const path of sortedPaths) removeAtPath(detached, path);
+	return detached;
+};
+const allowsDependentReplace = (replaceOnChanges, dependencyPaths) => {
+	if (!replaceOnChanges || replaceOnChanges.length === 0) return false;
+	for (const path of dependencyPaths) {
+		const base = typeof path[0] === "string" ? path[0] : void 0;
+		if (!base) continue;
+		for (const replacePath of replaceOnChanges) if (replacePath === base || replacePath.startsWith(`${base}.`) || replacePath.startsWith(`${base}[`) || replacePath.startsWith(`${base}.*`)) return true;
+	}
+	return false;
+};
+
+//#endregion
+//#region src/workspace/error.ts
+var ResourceError = class ResourceError extends Error {
+	static wrap(urn, type, operation, error) {
+		if (error instanceof Error) return new ResourceError(urn, type, operation, error.message);
+		return new ResourceError(urn, type, operation, "Unknown Error");
+	}
+	constructor(urn, type, operation, message) {
+		super(message);
+		this.urn = urn;
+		this.type = type;
+		this.operation = operation;
+	}
+};
+var AppError = class extends Error {
+	constructor(app, issues, message) {
+		super(message);
+		this.app = app;
+		this.issues = issues;
+	}
+};
+var ResourceNotFound = class extends Error {};
+var ResourceAlreadyExists = class extends Error {};
+
+//#endregion
+//#region src/workspace/state.ts
+const compareState = (left, right) => {
+	const replacer = (_, value) => {
+		if (value !== null && value instanceof Object && !Array.isArray(value)) return Object.keys(value).sort().reduce((sorted, key) => {
+			sorted[key] = value[key];
+			return sorted;
+		}, {});
+		return value;
+	};
+	return JSON.stringify(left, replacer) === JSON.stringify(right, replacer);
+};
+const removeEmptyStackStates = (appState) => {
+	for (const [stackUrn, stackState] of entries(appState.stacks)) if (Object.keys(stackState.nodes).length === 0) delete appState.stacks[stackUrn];
+};
+
+//#endregion
+//#region src/workspace/state/v1.ts
+const v1 = (oldAppState) => {
+	const stacks = {};
+	for (const [urn, stack] of entries(oldAppState.stacks)) {
+		const nodes = {};
+		for (const [urn$1, resource] of entries(stack.resources)) nodes[urn$1] = {
+			...resource,
+			tag: "resource"
+		};
+		stacks[urn] = {
+			name: stack.name,
+			dependencies: stack.dependencies,
+			nodes
+		};
+	}
+	return {
+		...oldAppState,
+		stacks,
+		version: 1
+	};
+};
+
+//#endregion
+//#region src/workspace/state/v2.ts
+const v2 = (oldAppState) => {
+	const stacks = {};
+	for (const [urn, stack] of entries(oldAppState.stacks)) stacks[urn] = {
+		name: stack.name,
+		nodes: stack.nodes
+	};
+	return {
+		...oldAppState,
+		stacks,
+		version: 2
+	};
+};
+
+//#endregion
+//#region src/workspace/state/migrate.ts
+const versions = [[1, v1], [2, v2]];
+const migrateAppState = (oldState) => {
+	const version = "version" in oldState && oldState.version || 0;
+	for (const [v, migrate] of versions) if (v > version) oldState = migrate(oldState);
+	return oldState;
+};
+
+//#endregion
+//#region src/provider.ts
+const findProvider = (providers, id) => {
+	for (const provider of providers) if (provider.ownResource(id)) return provider;
+	throw new TypeError(`Can't find the "${id}" provider.`);
+};
+
+//#endregion
+//#region src/workspace/token.ts
+const createIdempotantToken = (appToken, urn, operation) => {
+	return v5(`${urn}-${operation}`, appToken);
+};
+
+//#endregion
+//#region src/workspace/procedure/delete-resource.ts
+const debug$7 = createDebugger("Delete");
+const deleteResource = async (appToken, urn, state, opt) => {
+	debug$7(state.type);
+	debug$7(state);
+	if (state.lifecycle?.retainOnDelete) {
+		debug$7("retain", state.type);
+		return;
+	}
+	const idempotantToken = createIdempotantToken(appToken, urn, "delete");
+	const provider = findProvider(opt.providers, state.provider);
+	try {
+		await opt.hooks?.beforeResourceDelete?.({
+			urn,
+			type: state.type,
+			oldInput: state.input,
+			oldOutput: state.output
+		});
+		await provider.deleteResource({
+			type: state.type,
+			state: state.output,
+			idempotantToken
+		});
+		await opt.hooks?.afterResourceDelete?.({
+			urn,
+			type: state.type,
+			oldInput: state.input,
+			oldOutput: state.output
+		});
+	} catch (error) {
+		if (error instanceof ResourceNotFound) debug$7(state.type, "already deleted");
+		else throw ResourceError.wrap(urn, state.type, "delete", error);
+	}
+};
+
+//#endregion
+//#region src/workspace/procedure/delete-app.ts
+const deleteApp = async (app, opt) => {
+	const latestState = await opt.backend.state.get(app.urn);
+	if (!latestState) throw new AppError(app.name, [], `App already deleted: ${app.name}`);
+	const appState = migrateAppState(latestState);
+	if (opt.idempotentToken || !appState.idempotentToken) {
+		appState.idempotentToken = opt.idempotentToken ?? crypto.randomUUID();
+		await opt.backend.state.update(app.urn, appState);
+	}
+	let stackStates = Object.values(appState.stacks);
+	if (opt.filters && opt.filters.length > 0) stackStates = stackStates.filter((stackState) => opt.filters.includes(stackState.name));
+	const queue = createConcurrencyQueue(opt.concurrency ?? 10);
+	const graph = new DependencyGraph();
+	const allNodes = {};
+	for (const stackState of Object.values(appState.stacks)) for (const [urn, nodeState] of entries(stackState.nodes)) allNodes[urn] = nodeState;
+	for (const stackState of stackStates) for (const [urn, state] of entries(stackState.nodes)) graph.add(urn, dependentsOn(allNodes, urn), async () => {
+		if (state.tag === "resource") await queue(() => deleteResource(appState.idempotentToken, urn, state, opt));
+		delete stackState.nodes[urn];
+	});
+	const errors = await graph.run();
+	removeEmptyStackStates(appState);
+	delete appState.idempotentToken;
+	await opt.backend.state.update(app.urn, appState);
+	if (errors.length > 0) throw new AppError(app.name, [...new Set(errors)], "Deleting app failed.");
+	if (Object.keys(appState.stacks).length === 0) await opt.backend.state.delete(app.urn);
+};
+
+//#endregion
+//#region src/workspace/replacement.ts
+const requiresReplacement = (priorState, proposedState, replaceOnChanges) => {
+	for (const path of replaceOnChanges) {
+		const priorValue = get(priorState, path);
+		const proposedValue = get(proposedState, path);
+		if (path.includes("*") && Array.isArray(priorValue)) {
+			for (let i = 0; i < priorValue.length; i++) if (!compareState(priorValue[i], proposedValue[i])) return true;
+		}
+		if (!compareState(priorValue, proposedValue)) return true;
+	}
+	return false;
+};
+
+//#endregion
+//#region src/workspace/procedure/create-resource.ts
+const debug$6 = createDebugger("Create");
+const createResource = async (resource, appToken, input, opt) => {
+	const meta = getMeta(resource);
+	const provider = findProvider(opt.providers, meta.provider);
+	const idempotantToken = createIdempotantToken(appToken, meta.urn, "create");
+	debug$6(meta.type);
+	debug$6(input);
+	let result;
+	try {
+		await opt.hooks?.beforeResourceCreate?.({
+			urn: resource.urn,
+			type: meta.type,
+			resource,
+			newInput: input
+		});
+		result = await provider.createResource({
+			type: meta.type,
+			state: input,
+			idempotantToken
+		});
+		await opt.hooks?.afterResourceCreate?.({
+			urn: resource.urn,
+			type: meta.type,
+			resource,
+			newInput: input,
+			newOutput: result.state
+		});
+	} catch (error) {
+		throw ResourceError.wrap(meta.urn, meta.type, "create", error);
+	}
+	return {
+		tag: "resource",
+		version: result.version,
+		type: meta.type,
+		provider: meta.provider,
+		input: meta.input,
+		output: result.state
+	};
+};
+
+//#endregion
+//#region src/workspace/procedure/get-data-source.ts
+const debug$5 = createDebugger("Data Source");
+const getDataSource = async (dataSource, input, opt) => {
+	const provider = findProvider(opt.providers, dataSource.provider);
+	debug$5(dataSource.type);
+	if (!provider.getData) throw new Error(`Provider doesn't support data sources`);
+	let result;
+	try {
+		result = await provider.getData({
+			type: dataSource.type,
+			state: input
+		});
+	} catch (error) {
+		throw ResourceError.wrap(dataSource.urn, dataSource.type, "get", error);
+	}
+	return {
+		tag: "data",
+		type: dataSource.type,
+		provider: dataSource.provider,
+		input,
+		output: result.state
+	};
+};
+
+//#endregion
+//#region src/workspace/procedure/import-resource.ts
+const debug$4 = createDebugger("Import");
+const importResource = async (resource, input, opt) => {
+	const meta = getMeta(resource);
+	const provider = findProvider(opt.providers, meta.provider);
+	debug$4(meta.type);
+	debug$4(input);
+	let result;
+	try {
+		result = await provider.getResource({
+			type: meta.type,
+			state: {
+				...input,
+				id: meta.config?.import
+			}
+		});
+	} catch (error) {
+		throw ResourceError.wrap(meta.urn, meta.type, "import", error);
+	}
+	return {
+		tag: "resource",
+		version: result.version,
+		type: meta.type,
+		provider: meta.provider,
+		input: meta.input,
+		output: result.state
+	};
+};
+
+//#endregion
+//#region src/workspace/procedure/replace-resource.ts
+const debug$3 = createDebugger("Replace");
+const replaceResource = async (resource, appToken, priorInputState, priorOutputState, proposedState, opt) => {
+	const meta = getMeta(resource);
+	const urn = meta.urn;
+	const type = meta.type;
+	const provider = findProvider(opt.providers, meta.provider);
+	const idempotantToken = createIdempotantToken(appToken, meta.urn, "replace");
+	debug$3(meta.type);
+	debug$3(proposedState);
+	if (meta.config?.retainOnDelete) debug$3("retain", type);
+	else try {
+		await opt.hooks?.beforeResourceDelete?.({
+			urn,
+			type,
+			oldInput: priorInputState,
+			oldOutput: priorOutputState
+		});
+		await provider.deleteResource({
+			type,
+			state: priorOutputState,
+			idempotantToken
+		});
+		await opt.hooks?.afterResourceDelete?.({
+			urn,
+			type,
+			oldInput: priorInputState,
+			oldOutput: priorOutputState
+		});
+	} catch (error) {
+		if (error instanceof ResourceNotFound) debug$3(type, "already deleted");
+		else throw ResourceError.wrap(urn, type, "replace", error);
+	}
+	let result;
+	try {
+		await opt.hooks?.beforeResourceCreate?.({
+			urn,
+			type,
+			resource,
+			newInput: proposedState
+		});
+		result = await provider.createResource({
+			type,
+			state: proposedState,
+			idempotantToken
+		});
+		await opt.hooks?.afterResourceCreate?.({
+			urn,
+			type,
+			resource,
+			newInput: proposedState,
+			newOutput: result.state
+		});
+	} catch (error) {
+		throw ResourceError.wrap(urn, type, "replace", error);
+	}
+	return {
+		version: result.version,
+		output: result.state
+	};
+};
+
+//#endregion
+//#region src/workspace/procedure/update-resource.ts
+const debug$2 = createDebugger("Update");
+const updateResource = async (resource, appToken, priorInputState, priorOutputState, proposedState, opt) => {
+	const meta = getMeta(resource);
+	const provider = findProvider(opt.providers, meta.provider);
+	const idempotantToken = createIdempotantToken(appToken, meta.urn, "update");
+	let result;
+	debug$2(meta.type);
+	debug$2(proposedState);
+	try {
+		await opt.hooks?.beforeResourceUpdate?.({
+			urn: resource.urn,
+			type: meta.type,
+			resource,
+			newInput: proposedState,
+			oldInput: priorInputState,
+			oldOutput: priorOutputState
+		});
+		result = await provider.updateResource({
+			type: meta.type,
+			priorState: priorOutputState,
+			proposedState,
+			idempotantToken
+		});
+		await opt.hooks?.afterResourceUpdate?.({
+			urn: resource.urn,
+			type: meta.type,
+			resource,
+			newInput: proposedState,
+			oldInput: priorInputState,
+			newOutput: result.state,
+			oldOutput: priorOutputState
+		});
+	} catch (error) {
+		throw ResourceError.wrap(meta.urn, meta.type, "update", error);
+	}
+	return {
+		version: result.version,
+		output: result.state
+	};
+};
+
+//#endregion
+//#region src/workspace/procedure/deploy-app.ts
+const debug$1 = createDebugger("Deploy App");
+const deployApp = async (app, opt) => {
+	debug$1(app.name, "start");
+	const appState = migrateAppState(await opt.backend.state.get(app.urn) ?? {
+		name: app.name,
+		stacks: {}
+	});
+	const releaseOnExit = onExit(async () => {
+		await opt.backend.state.update(app.urn, appState);
+	});
+	if (opt.idempotentToken || !appState.idempotentToken) {
+		appState.idempotentToken = opt.idempotentToken ?? crypto.randomUUID();
+		await opt.backend.state.update(app.urn, appState);
+	}
+	let stacks = app.stacks;
+	let filteredOutStacks = [];
+	if (opt.filters && opt.filters.length > 0) {
+		stacks = app.stacks.filter((stack) => opt.filters.includes(stack.name));
+		filteredOutStacks = app.stacks.filter((stack) => !opt.filters.includes(stack.name));
+	}
+	const nodeByUrn = /* @__PURE__ */ new Map();
+	const stackStates = /* @__PURE__ */ new Map();
+	const plannedDependents = /* @__PURE__ */ new Set();
+	const forcedUpdateDependents = /* @__PURE__ */ new Set();
+	for (const stack of stacks) {
+		const stackState = appState.stacks[stack.urn] = appState.stacks[stack.urn] ?? {
+			name: stack.name,
+			nodes: {}
+		};
+		stackStates.set(stack.urn, stackState);
+		for (const node of stack.nodes) nodeByUrn.set(getMeta(node).urn, node);
+	}
+	const queue = createConcurrencyQueue(opt.concurrency ?? 10);
+	const graph = new DependencyGraph();
+	const replacementDeletes = /* @__PURE__ */ new Map();
+	const allNodes = {};
+	for (const stackState of Object.values(appState.stacks)) for (const [urn, nodeState] of entries(stackState.nodes)) allNodes[urn] = nodeState;
+	for (const stack of filteredOutStacks) {
+		const stackState = appState.stacks[stack.urn];
+		if (stackState) for (const node of stack.nodes) {
+			const meta = getMeta(node);
+			const nodeState = stackState.nodes[meta.urn];
+			if (nodeState && nodeState.output) graph.add(meta.urn, [], async () => {
+				debug$1("hydrate", meta.urn);
+				meta.resolve(nodeState.output);
+			});
+		}
+	}
+	for (const [urn, stackState] of entries(appState.stacks)) {
+		const found = app.stacks.find((stack) => {
+			return stack.urn === urn;
+		});
+		const filtered = opt.filters ? opt.filters.find((filter) => filter === stackState.name) : true;
+		if (!found && filtered) for (const [urn$1, nodeState] of entries(stackState.nodes)) graph.add(urn$1, dependentsOn(allNodes, urn$1), async () => {
+			if (nodeState.tag === "resource") await queue(() => deleteResource(appState.idempotentToken, urn$1, nodeState, opt));
+			delete stackState.nodes[urn$1];
+		});
+	}
+	for (const stack of stacks) {
+		const stackState = stackStates.get(stack.urn);
+		for (const [urn, nodeState] of entries(stackState.nodes)) if (!stack.nodes.find((r) => getMeta(r).urn === urn)) graph.add(urn, dependentsOn(allNodes, urn), async () => {
+			if (nodeState.tag === "resource") await queue(() => deleteResource(appState.idempotentToken, urn, nodeState, opt));
+			delete stackState.nodes[urn];
+		});
+		for (const node of stack.nodes) {
+			const meta = getMeta(node);
+			const dependencies = [...meta.dependencies];
+			const partialNewResourceState = {
+				dependencies,
+				lifecycle: isResource(node) ? { retainOnDelete: getMeta(node).config?.retainOnDelete } : void 0
+			};
+			graph.add(meta.urn, dependencies, () => {
+				return queue(async () => {
+					let nodeState = stackState.nodes[meta.urn];
+					let input;
+					try {
+						input = await resolveInputs(meta.input);
+					} catch (error) {
+						throw ResourceError.wrap(meta.urn, meta.type, "resolve", error);
+					}
+					if (isDataSource(node)) {
+						const meta$1 = getMeta(node);
+						if (!nodeState) {
+							const dataSourceState = await getDataSource(meta$1, input, opt);
+							nodeState = stackState.nodes[meta$1.urn] = {
+								...dataSourceState,
+								...partialNewResourceState
+							};
+						} else if (!compareState(nodeState.input, input)) {
+							const dataSourceState = await getDataSource(meta$1, input, opt);
+							Object.assign(nodeState, {
+								...dataSourceState,
+								...partialNewResourceState
+							});
+						} else Object.assign(nodeState, partialNewResourceState);
+					}
+					if (isResource(node)) {
+						const meta$1 = getMeta(node);
+						if (!nodeState) if (meta$1.config?.import) {
+							const importedState = await importResource(node, input, opt);
+							const newResourceState = await updateResource(node, appState.idempotentToken, importedState.input, importedState.output, input, opt);
+							nodeState = stackState.nodes[meta$1.urn] = {
+								...importedState,
+								...newResourceState,
+								...partialNewResourceState
+							};
+						} else {
+							const newResourceState = await createResource(node, appState.idempotentToken, input, opt);
+							nodeState = stackState.nodes[meta$1.urn] = {
+								...newResourceState,
+								...partialNewResourceState
+							};
+						}
+						else if (!compareState(nodeState.input, input)) {
+							let newResourceState;
+							const ignoreReplace = forcedUpdateDependents.has(meta$1.urn);
+							if (!ignoreReplace && requiresReplacement(nodeState.input, input, meta$1.config?.replaceOnChanges ?? [])) if (meta$1.config?.createBeforeReplace) {
+								const priorState = { ...nodeState };
+								newResourceState = await createResource(node, appState.idempotentToken, input, opt);
+								if (!meta$1.config?.retainOnDelete) replacementDeletes.set(meta$1.urn, priorState);
+							} else {
+								for (const [dependentUrn, dependentNode] of nodeByUrn.entries()) {
+									if (!isResource(dependentNode)) continue;
+									const dependentMeta = getMeta(dependentNode);
+									if (!dependentMeta.dependencies.has(meta$1.urn)) continue;
+									if (plannedDependents.has(dependentUrn)) continue;
+									const dependentStackState = stackStates.get(dependentMeta.stack.urn);
+									const dependentState = dependentStackState?.nodes[dependentUrn];
+									if (!dependentStackState || !dependentState) continue;
+									const dependencyPaths = findDependencyPaths(dependentMeta.input, meta$1.urn);
+									if (dependencyPaths.length === 0) continue;
+									const detachedInput = stripDependencyInputs(dependentState.input, dependentMeta.input, meta$1.urn);
+									if (compareState(dependentState.input, detachedInput)) continue;
+									plannedDependents.add(dependentUrn);
+									let dependentRequiresReplacement = false;
+									const dependentProvider = findProvider(opt.providers, dependentMeta.provider);
+									if (dependentProvider.planResourceChange) try {
+										dependentRequiresReplacement = (await dependentProvider.planResourceChange({
+											type: dependentMeta.type,
+											priorState: dependentState.output,
+											proposedState: detachedInput
+										})).requiresReplacement;
+									} catch (error) {
+										throw ResourceError.wrap(dependentMeta.urn, dependentMeta.type, "update", error);
+									}
+									if (dependentRequiresReplacement) {
+										if (!allowsDependentReplace(dependentMeta.config?.replaceOnChanges, dependencyPaths)) throw ResourceError.wrap(dependentMeta.urn, dependentMeta.type, "update", /* @__PURE__ */ new Error(`Replacing ${meta$1.urn} requires ${dependentMeta.urn} to set replaceOnChanges for its dependency fields.`));
+										await deleteResource(appState.idempotentToken, dependentUrn, dependentState, opt);
+										delete dependentStackState.nodes[dependentUrn];
+									} else {
+										const updated = await updateResource(dependentNode, appState.idempotentToken, dependentState.input, dependentState.output, detachedInput, opt);
+										Object.assign(dependentState, {
+											input: detachedInput,
+											...updated
+										});
+										forcedUpdateDependents.add(dependentUrn);
+									}
+								}
+								newResourceState = await replaceResource(node, appState.idempotentToken, nodeState.input, nodeState.output, input, opt);
+							}
+							else {
+								newResourceState = await updateResource(node, appState.idempotentToken, nodeState.input, nodeState.output, input, opt);
+								if (ignoreReplace) forcedUpdateDependents.delete(meta$1.urn);
+							}
+							Object.assign(nodeState, {
+								input,
+								...newResourceState,
+								...partialNewResourceState
+							});
+						} else Object.assign(nodeState, partialNewResourceState);
+					}
+					if (nodeState?.output) meta.resolve(nodeState.output);
+				});
+			});
+		}
+	}
+	const errors = await graph.run();
+	if (errors.length === 0 && replacementDeletes.size > 0) for (const [urn, nodeState] of replacementDeletes.entries()) try {
+		await deleteResource(appState.idempotentToken, urn, nodeState, opt);
+	} catch (error) {
+		if (error instanceof Error) errors.push(error);
+		else errors.push(/* @__PURE__ */ new Error(`${error}`));
+	}
+	removeEmptyStackStates(appState);
+	delete appState.idempotentToken;
+	await opt.backend.state.update(app.urn, appState);
+	releaseOnExit();
+	debug$1(app.name, "done");
+	if (errors.length > 0) throw new AppError(app.name, [...new Set(errors)], "Deploying app failed.");
+	if (Object.keys(appState.stacks).length === 0) await opt.backend.state.delete(app.urn);
+	return appState;
+};
+
+//#endregion
+//#region src/workspace/procedure/hydrate.ts
+const hydrate = async (app, opt) => {
+	const appState = await opt.backend.state.get(app.urn);
+	if (appState) for (const stack of app.stacks) {
+		const stackState = appState.stacks[stack.urn];
+		if (stackState) for (const node of stack.nodes) {
+			const meta = getMeta(node);
+			const nodeState = stackState.nodes[meta.urn];
+			if (nodeState && nodeState.output) meta.resolve(nodeState.output);
+		}
+	}
+};
+
+//#endregion
+//#region src/workspace/procedure/refresh.ts
+const refresh = async (app, opt) => {
+	const appState = await opt.backend.state.get(app.urn);
+	const queue = createConcurrencyQueue(opt.concurrency ?? 10);
+	if (appState) {
+		await Promise.all(Object.values(appState.stacks).map((stackState) => {
+			return Promise.all(Object.values(stackState.nodes).map((nodeState) => {
+				return queue(async () => {
+					const provider = findProvider(opt.providers, nodeState.provider);
+					if (nodeState.tag === "data") {
+						const result = await provider.getData?.({
+							type: nodeState.type,
+							state: nodeState.output
+						});
+						if (result && !compareState(result.state, nodeState.output)) {
+							nodeState.output = result.state;
+							nodeState.input = result.state;
+						}
+					} else if (nodeState.tag === "resource") {
+						const result = await provider.getResource({
+							type: nodeState.type,
+							state: nodeState.output
+						});
+						if (result && !compareState(result.state, nodeState.output)) {
+							nodeState.output = result.state;
+							nodeState.input = result.state;
+						}
+					}
+				});
+			}));
+		}));
+		await opt.backend.state.update(app.urn, appState);
+	}
+};
+
+//#endregion
+//#region src/workspace/workspace.ts
+var WorkSpace = class {
+	constructor(props) {
+		this.props = props;
+	}
+	/**
+	* Deploy the entire app or use the filter option to deploy specific stacks inside your app.
+	*/
+	deploy(app, options = {}) {
+		return lockApp(this.props.backend.lock, app, async () => {
+			try {
+				await deployApp(app, {
+					...this.props,
+					...options
+				});
+			} finally {
+				await this.destroyProviders();
+			}
+		});
+	}
+	/**
+	* Delete the entire app or use the filter option to delete specific stacks inside your app.
+	*/
+	delete(app, options = {}) {
+		return lockApp(this.props.backend.lock, app, async () => {
+			try {
+				await deleteApp(app, {
+					...this.props,
+					...options
+				});
+			} finally {
+				await this.destroyProviders();
+			}
+		});
+	}
+	/**
+	* Hydrate the outputs of the resources & data-sources inside your app.
+	*/
+	hydrate(app) {
+		return hydrate(app, this.props);
+	}
+	/**
+	* Refresh the state of the resources & data-sources inside your app.
+	*/
+	refresh(app) {
+		return lockApp(this.props.backend.lock, app, async () => {
+			try {
+				await refresh(app, this.props);
+			} finally {
+				await this.destroyProviders();
+			}
+		});
+	}
+	async destroyProviders() {
+		await Promise.all(this.props.providers.map((p) => {
+			return p.destroy?.();
+		}));
+	}
+};
+
+//#endregion
+//#region src/backend/memory/state.ts
+var MemoryStateBackend = class {
+	states = /* @__PURE__ */ new Map();
+	async get(urn) {
+		return this.states.get(urn);
+	}
+	async update(urn, state) {
+		this.states.set(urn, state);
+	}
+	async delete(urn) {
+		this.states.delete(urn);
+	}
+	clear() {
+		this.states.clear();
+	}
+};
+
+//#endregion
+//#region src/backend/memory/lock.ts
+var MemoryLockBackend = class {
+	locks = /* @__PURE__ */ new Map();
+	async insecureReleaseLock(urn) {
+		this.locks.delete(urn);
+	}
+	async locked(urn) {
+		return this.locks.has(urn);
+	}
+	async lock(urn) {
+		if (this.locks.has(urn)) throw new Error("Already locked");
+		const id = Math.random();
+		this.locks.set(urn, id);
+		return async () => {
+			if (this.locks.get(urn) === id) this.locks.delete(urn);
+		};
+	}
+	clear() {
+		this.locks.clear();
+	}
+};
+
+//#endregion
+//#region src/backend/file/state.ts
+const debug = createDebugger("State");
+var FileStateBackend = class {
+	constructor(props) {
+		this.props = props;
+	}
+	stateFile(urn) {
+		return join(this.props.dir, `${urn}.json`);
+	}
+	async mkdir() {
+		await mkdir(this.props.dir, { recursive: true });
+	}
+	async get(urn) {
+		debug("get");
+		let json;
+		try {
+			json = await readFile(join(this.stateFile(urn)), "utf8");
+		} catch (error) {
+			return;
+		}
+		return JSON.parse(json);
+	}
+	async update(urn, state) {
+		debug("update");
+		await this.mkdir();
+		await writeFile(this.stateFile(urn), JSON.stringify(state, void 0, 2));
+	}
+	async delete(urn) {
+		debug("delete");
+		await this.mkdir();
+		await rm(this.stateFile(urn));
+	}
+};
+
+//#endregion
+//#region src/backend/file/lock.ts
+var FileLockBackend = class {
+	constructor(props) {
+		this.props = props;
+	}
+	lockFile(urn) {
+		return join(this.props.dir, `${urn}.lock`);
+	}
+	async mkdir() {
+		await mkdir(this.props.dir, { recursive: true });
+	}
+	async insecureReleaseLock(urn) {
+		if (await this.locked(urn)) await rm(this.lockFile(urn));
+	}
+	async locked(urn) {
+		return (await stat(this.lockFile(urn))).isFile();
+	}
+	async lock(urn) {
+		await this.mkdir();
+		return lock(this.lockFile(urn), { realpath: false });
+	}
+};
+
+//#endregion
+//#region src/backend/aws/s3-state.ts
+var S3StateBackend = class {
+	client;
+	constructor(props) {
+		this.props = props;
+		this.client = new S3Client(props);
+	}
+	async get(urn) {
+		let result;
+		try {
+			result = await this.client.send(new GetObjectCommand({
+				Bucket: this.props.bucket,
+				Key: `${urn}.state`
+			}));
+		} catch (error) {
+			if (error instanceof S3ServiceException && error.name === "NoSuchKey") return;
+			throw error;
+		}
+		if (!result.Body) return;
+		const body = await result.Body.transformToString("utf8");
+		return JSON.parse(body);
+	}
+	async update(urn, state) {
+		await this.client.send(new PutObjectCommand({
+			Bucket: this.props.bucket,
+			Key: `${urn}.state`,
+			Body: JSON.stringify(state)
+		}));
+	}
+	async delete(urn) {
+		await this.client.send(new DeleteObjectCommand({
+			Bucket: this.props.bucket,
+			Key: `${urn}.state`
+		}));
+	}
+};
+
+//#endregion
+//#region src/backend/aws/dynamodb-lock.ts
+var DynamoLockBackend = class {
+	client;
+	constructor(props) {
+		this.props = props;
+		this.client = new DynamoDB(props);
+	}
+	async insecureReleaseLock(urn) {
+		await this.client.updateItem({
+			TableName: this.props.tableName,
+			Key: marshall({ urn }),
+			ExpressionAttributeNames: { "#lock": "lock" },
+			UpdateExpression: "REMOVE #lock"
+		});
+	}
+	async locked(urn) {
+		const result = await this.client.getItem({
+			TableName: this.props.tableName,
+			Key: marshall({ urn })
+		});
+		if (!result.Item) return false;
+		return typeof unmarshall(result.Item).lock === "number";
+	}
+	async lock(urn) {
+		const id = Math.floor(Math.random() * 1e5);
+		const props = {
+			TableName: this.props.tableName,
+			Key: marshall({ urn }),
+			ExpressionAttributeNames: { "#lock": "lock" },
+			ExpressionAttributeValues: { ":id": marshall(id) }
+		};
+		await this.client.updateItem({
+			...props,
+			UpdateExpression: "SET #lock = :id",
+			ConditionExpression: "attribute_not_exists(#lock)"
+		});
+		return async () => {
+			await this.client.updateItem({
+				...props,
+				UpdateExpression: "REMOVE #lock",
+				ConditionExpression: "#lock = :id"
+			});
+		};
+	}
+};
+
+//#endregion
+//#region src/helpers.ts
+const file = (path, encoding = "utf8") => {
+	return new Future(async (resolve$1, reject) => {
+		try {
+			resolve$1(await readFile(path, { encoding }));
+		} catch (error) {
+			reject(error);
+		}
+	});
+};
+const hash = (path, algo = "sha256") => {
+	return file(path).pipe((file$1) => createHash(algo).update(file$1).digest("hex"));
+};
+
+//#endregion
+//#region src/globals.ts
+globalThis.$resolve = resolve;
+globalThis.$combine = combine;
+globalThis.$interpolate = interpolate;
+globalThis.$hash = hash;
+globalThis.$file = file;
+
+//#endregion
+//#region src/custom/resource.ts
+const createCustomResourceClass = (providerId, resourceType) => {
+	return new Proxy(class {}, { construct(_, [parent, id, input, config]) {
+		const meta = createMeta("resource", `custom:${providerId}`, parent, resourceType, id, input, config);
+		const node = new Proxy({}, { get(_$1, key) {
+			if (key === nodeMetaSymbol) return meta;
+			if (key === "urn") return meta.urn;
+			if (typeof key === "symbol") return;
+			return meta.output((data) => data[key]);
+		} });
+		parent.add(node);
+		return node;
+	} });
+};
+
+//#endregion
+//#region src/custom/provider.ts
+const createCustomProvider = (providerId, resourceProviders) => {
+	const version = 1;
+	const getProvider = (type) => {
+		const provider = resourceProviders[type];
+		if (!provider) throw new Error(`The "${providerId}" provider doesn't support the "${type}" resource type.`);
+		return provider;
+	};
+	return {
+		ownResource(id) {
+			return id === `custom:${providerId}`;
+		},
+		async getResource({ type, ...props }) {
+			const provider = getProvider(type);
+			if (!provider.getResource) return {
+				version,
+				state: props.state
+			};
+			return {
+				version,
+				state: await provider.getResource(props)
+			};
+		},
+		async createResource({ type, ...props }) {
+			const provider = getProvider(type);
+			if (!provider.createResource) return {
+				version,
+				state: props.state
+			};
+			return {
+				version,
+				state: await provider.createResource(props)
+			};
+		},
+		async updateResource({ type, ...props }) {
+			const provider = getProvider(type);
+			if (!provider.updateResource) return {
+				version,
+				state: props.proposedState
+			};
+			return {
+				version,
+				state: await provider.updateResource(props)
+			};
+		},
+		async deleteResource({ type, ...props }) {
+			await getProvider(type).deleteResource?.(props);
+		},
+		async planResourceChange({ type, ...props }) {
+			const provider = getProvider(type);
+			if (!provider.planResourceChange) return {
+				version,
+				state: props.proposedState,
+				requiresReplacement: false
+			};
+			return {
+				version,
+				...await provider.planResourceChange(props)
+			};
+		},
+		async getData({ type, ...props }) {
+			return {
+				version,
+				state: await getProvider(type).getData?.(props) ?? {}
+			};
+		}
+	};
+};
+
+//#endregion
+export { App, AppError, DynamoLockBackend, FileLockBackend, FileStateBackend, Future, Group, MemoryLockBackend, MemoryStateBackend, Output, ResourceAlreadyExists, ResourceError, ResourceNotFound, S3StateBackend, Stack, WorkSpace, createCustomProvider, createCustomResourceClass, createDebugger, createMeta, deferredOutput, enableDebug, findInputDeps, getMeta, isDataSource, isNode, isResource, nodeMetaSymbol, output, resolveInputs };