@terraforge/core 0.0.29 → 0.0.31

package/dist/index.d.mts

@@ -252,12 +252,16 @@ type GetDataProps<T = State> = {
   type: string;
   state: T;
 };
-type RefreshStateProps<T = State> = {
+type RefreshResourceProps<T = State> = {
   type: string;
-  tag: 'resource' | 'data';
   priorInputState: T;
   priorOutputState: T;
-  refreshedState: T;
+};
+type RefreshResourceResult<T = State> = {
+  kind: 'unchanged' | 'updated';
+  state: T;
+} | {
+  kind: 'deleted';
 };
 interface Provider {
   ownResource(id: string): boolean;
@@ -282,7 +286,7 @@ interface Provider {
   getData?(props: GetDataProps): Promise<{
     state: State;
   }>;
-  isRefreshStateEqual?(props: RefreshStateProps): Promise<boolean> | boolean;
+  refreshResource?(props: RefreshResourceProps): Promise<RefreshResourceResult | undefined>;
   destroy?(): Promise<void>;
 }
 //#endregion
@@ -540,8 +544,8 @@ type CustomResourceProvider = Partial<{
     state: State;
     requiresReplacement: boolean;
   }>;
-  isRefreshStateEqual?(props: Omit<RefreshStateProps, 'type'>): Promise<boolean> | boolean;
+  refreshResource?(props: Omit<RefreshResourceProps, 'type'>): Promise<RefreshResourceResult<State> | undefined>;
 }>;
 declare const createCustomProvider: (providerId: string, resourceProviders: Record<string, CustomResourceProvider>) => Provider;
 //#endregion
-export { ActivityLogBackend, App, AppError, type Config, type CreateProps, type CustomResourceProvider, type DataSource, type DataSourceFunction, type DataSourceMeta, type DeleteProps, DynamoActivityLogBackend, DynamoLockBackend, FileActivityLogBackend, FileLockBackend, FileStateBackend, Future, type GetDataProps, type GetProps, Group, type Input, LockBackend, Log, LogProps, MemoryActivityLogBackend, MemoryLockBackend, MemoryStateBackend, type Meta, type Node, type OptionalInput, type OptionalOutput, Output, type PlanProps, type ProcedureOptions, type Provider, type RefreshStateProps, type Resource, ResourceAlreadyExists, type ResourceClass, type ResourceConfig, ResourceError, type ResourceMeta, ResourceNotFound, type ResourceStatus, type ResourceStatusInfo, S3StateBackend, Stack, type StackStatusInfo, type State, StateBackend, type Tag, type URN, type UpdateProps, WorkSpace, type WorkSpaceOptions, createCustomProvider, createCustomResourceClass, createDebugger, createMeta, deferredOutput, enableDebug, findInputDeps, getMeta, isDataSource, isNode, isResource, nodeMetaSymbol, output, resolveInputs };
+export { ActivityLogBackend, App, AppError, type Config, type CreateProps, type CustomResourceProvider, type DataSource, type DataSourceFunction, type DataSourceMeta, type DeleteProps, DynamoActivityLogBackend, DynamoLockBackend, FileActivityLogBackend, FileLockBackend, FileStateBackend, Future, type GetDataProps, type GetProps, Group, type Input, LockBackend, Log, LogProps, MemoryActivityLogBackend, MemoryLockBackend, MemoryStateBackend, type Meta, type Node, type OptionalInput, type OptionalOutput, Output, type PlanProps, type ProcedureOptions, type Provider, type RefreshResourceProps, type RefreshResourceResult, type Resource, ResourceAlreadyExists, type ResourceClass, type ResourceConfig, ResourceError, type ResourceMeta, ResourceNotFound, type ResourceStatus, type ResourceStatusInfo, S3StateBackend, Stack, type StackStatusInfo, type State, StateBackend, type Tag, type URN, type UpdateProps, WorkSpace, type WorkSpaceOptions, createCustomProvider, createCustomResourceClass, createDebugger, createMeta, deferredOutput, enableDebug, findInputDeps, getMeta, isDataSource, isNode, isResource, nodeMetaSymbol, output, resolveInputs };

package/dist/index.mjs

@@ -965,6 +965,7 @@ const deployApp = async (app, opt) => {
 					}
 					if (isResource(node)) {
 						const meta$1 = getMeta(node);
+						const provider = findProvider(opt.providers, meta$1.provider);
 						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);
@@ -980,94 +981,104 @@ const deployApp = async (app, opt) => {
 								...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) {
-								meta$1.resolve(input);
-								try {
+						else {
+							const inputChanged = !compareState(nodeState.input, input);
+							const plannedChange = provider.planResourceChange ? await provider.planResourceChange({
+								type: meta$1.type,
+								priorState: nodeState.output,
+								proposedState: input
+							}) : void 0;
+							const hasDrift = !inputChanged && !!provider.refreshResource && !!plannedChange && !compareState(plannedChange.state, nodeState.output);
+							if (!inputChanged && !hasDrift) Object.assign(nodeState, partialNewResourceState);
+							else {
+								let newResourceState;
+								const ignoreReplace = forcedUpdateDependents.has(meta$1.urn);
+								if (!ignoreReplace && (requiresReplacement(nodeState.input, input, meta$1.config?.replaceOnChanges ?? []) || !inputChanged && (plannedChange?.requiresReplacement ?? false))) if (meta$1.config?.createBeforeReplace) {
+									meta$1.resolve(input);
+									try {
+										for (const [dependentUrn, dependentNode] of nodeByUrn.entries()) {
+											if (!isResource(dependentNode)) continue;
+											const dependentMeta = getMeta(dependentNode);
+											if (!dependentMeta.dependencies.has(meta$1.urn)) 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 dependentProvider = findProvider(opt.providers, dependentMeta.provider);
+											if (dependentProvider.planResourceChange) {
+												const dependentProposedInput = await resolveInputs(dependentMeta.input);
+												if ((await dependentProvider.planResourceChange({
+													type: dependentMeta.type,
+													priorState: dependentState.output,
+													proposedState: dependentProposedInput
+												})).requiresReplacement) {
+													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.`));
+												}
+											}
+										}
+									} finally {
+										meta$1.resolve(nodeState.output);
+									}
+									const priorState = { ...nodeState };
+									newResourceState = await createResource(node, appState.idempotentToken, input, opt);
+									if (newResourceState.output) meta$1.resolve(newResourceState.output);
+									if (!meta$1.config?.retainOnDelete) {
+										appState.pendingDeletes ??= {};
+										appState.pendingDeletes[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) {
-											const dependentProposedInput = await resolveInputs(dependentMeta.input);
-											if ((await dependentProvider.planResourceChange({
+										if (dependentProvider.planResourceChange) try {
+											dependentRequiresReplacement = (await dependentProvider.planResourceChange({
 												type: dependentMeta.type,
 												priorState: dependentState.output,
-												proposedState: dependentProposedInput
-											})).requiresReplacement) {
-												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.`));
-											}
+												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);
 										}
 									}
-								} finally {
-									meta$1.resolve(nodeState.output);
+									newResourceState = await replaceResource(node, appState.idempotentToken, nodeState.input, nodeState.output, input, opt);
+									if (newResourceState.output) meta$1.resolve(newResourceState.output);
 								}
-								const priorState = { ...nodeState };
-								newResourceState = await createResource(node, appState.idempotentToken, input, opt);
-								if (newResourceState.output) meta$1.resolve(newResourceState.output);
-								if (!meta$1.config?.retainOnDelete) {
-									appState.pendingDeletes ??= {};
-									appState.pendingDeletes[meta$1.urn] = priorState;
+								else {
+									newResourceState = await updateResource(node, appState.idempotentToken, nodeState.input, nodeState.output, input, opt);
+									if (ignoreReplace) forcedUpdateDependents.delete(meta$1.urn);
 								}
-							} 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);
-								if (newResourceState.output) meta$1.resolve(newResourceState.output);
+								Object.assign(nodeState, {
+									input,
+									...newResourceState,
+									...partialNewResourceState
+								});
 							}
-							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);
 				});
@@ -1111,55 +1122,55 @@ const hydrate = async (app, opt) => {
 
 //#endregion
 //#region src/workspace/procedure/refresh.ts
+const createDeleteOperation = (urn, stackState) => {
+	return {
+		urn,
+		operation: "delete",
+		commit() {
+			delete stackState.nodes[urn];
+		}
+	};
+};
+const createUpdateOperation = (urn, state, nodeState) => {
+	return {
+		urn,
+		operation: "update",
+		commit() {
+			nodeState.output = state;
+		}
+	};
+};
 const refresh = async (app, opt) => {
 	const appState = await opt.backend.state.get(app.urn);
 	const queue = createConcurrencyQueue(opt.concurrency ?? 10);
 	let filteredStacks = Object.values(appState?.stacks ?? {});
-	if (opt.filters && opt.filters.length > 0) filteredStacks = Object.entries(appState?.stacks ?? {}).filter(([stackName]) => {
-		return opt.filters.includes(stackName);
-	}).map(([_, state]) => state);
+	if (opt.filters && opt.filters.length > 0) filteredStacks = Object.values(appState?.stacks ?? {}).filter((stackState) => {
+		return opt.filters.includes(stackState.name);
+	});
 	if (appState && filteredStacks.length > 0) {
 		const filteredOperations = (await Promise.all(filteredStacks.map((stackState) => {
 			return Promise.all(Object.entries(stackState.nodes).map(([_urn, nodeState]) => {
 				const urn = _urn;
 				return queue(async () => {
 					const provider = findProvider(opt.providers, nodeState.provider);
-					let result;
-					if (nodeState.tag === "data") result = await provider.getData?.({
-						type: nodeState.type,
-						state: nodeState.output
-					});
-					else result = await provider.getResource({
-						type: nodeState.type,
-						state: nodeState.output
-					});
-					const hasChanged = !result ? true : provider.isRefreshStateEqual ? !await provider.isRefreshStateEqual({
+					if (nodeState.tag === "data") {
+						const result = await provider.getData?.({
+							type: nodeState.type,
+							state: nodeState.output
+						});
+						if (!result) return createDeleteOperation(urn, stackState);
+						if (compareState(result.state, nodeState.output)) return;
+						return createUpdateOperation(urn, result.state, nodeState);
+					}
+					if (!provider.refreshResource) return;
+					const refreshed = await provider.refreshResource({
 						type: nodeState.type,
-						tag: nodeState.tag,
 						priorInputState: nodeState.input,
-						priorOutputState: nodeState.output,
-						refreshedState: result.state
-					}) : !compareState(result.state, nodeState.output);
-					if (!result) return {
-						urn,
-						operation: "delete",
-						commit() {
-							delete stackState.nodes[urn];
-						}
-					};
-					else if (hasChanged) {
-						console.log(urn);
-						console.log(nodeState.output);
-						console.log(result?.state);
-						return {
-							urn,
-							operation: "update",
-							commit() {
-								nodeState.output = result.state;
-								if (nodeState.tag === "resource" && "version" in result) nodeState.version = result.version;
-							}
-						};
-					}
+						priorOutputState: nodeState.output
+					});
+					if (!refreshed || refreshed.kind === "unchanged") return;
+					if (refreshed.kind === "deleted") return createDeleteOperation(urn, stackState);
+					return createUpdateOperation(urn, refreshed.state, nodeState);
 				});
 			}));
 		}))).flat().filter((op) => !!op);
@@ -1687,61 +1698,62 @@ const createCustomResourceClass = (providerId, resourceType) => {
 //#region src/custom/provider.ts
 const createCustomProvider = (providerId, resourceProviders) => {
 	const version = 1;
+	const hasRefreshResource = Object.values(resourceProviders).some((provider$1) => !!provider$1.refreshResource);
 	const getProvider = (type) => {
-		const provider = resourceProviders[type];
-		if (!provider) throw new Error(`The "${providerId}" provider doesn't support the "${type}" resource type.`);
-		return provider;
+		const provider$1 = resourceProviders[type];
+		if (!provider$1) throw new Error(`The "${providerId}" provider doesn't support the "${type}" resource type.`);
+		return provider$1;
 	};
-	return {
+	const provider = {
 		ownResource(id) {
 			return id === `custom:${providerId}`;
 		},
 		async getResource({ type, ...props }) {
-			const provider = getProvider(type);
-			if (!provider.getResource) return {
+			const provider$1 = getProvider(type);
+			if (!provider$1.getResource) return {
 				version,
 				state: props.state
 			};
 			return {
 				version,
-				state: await provider.getResource(props)
+				state: await provider$1.getResource(props)
 			};
 		},
 		async createResource({ type, ...props }) {
-			const provider = getProvider(type);
-			if (!provider.createResource) return {
+			const provider$1 = getProvider(type);
+			if (!provider$1.createResource) return {
 				version,
 				state: props.state
 			};
 			return {
 				version,
-				state: await provider.createResource(props)
+				state: await provider$1.createResource(props)
 			};
 		},
 		async updateResource({ type, ...props }) {
-			const provider = getProvider(type);
-			if (!provider.updateResource) return {
+			const provider$1 = getProvider(type);
+			if (!provider$1.updateResource) return {
 				version,
 				state: props.proposedState
 			};
 			return {
 				version,
-				state: await provider.updateResource(props)
+				state: await provider$1.updateResource(props)
 			};
 		},
 		async deleteResource({ type, ...props }) {
 			await getProvider(type).deleteResource?.(props);
 		},
 		async planResourceChange({ type, ...props }) {
-			const provider = getProvider(type);
-			if (!provider.planResourceChange) return {
+			const provider$1 = getProvider(type);
+			if (!provider$1.planResourceChange) return {
 				version,
 				state: props.proposedState,
 				requiresReplacement: false
 			};
 			return {
 				version,
-				...await provider.planResourceChange(props)
+				...await provider$1.planResourceChange(props)
 			};
 		},
 		async getData({ type, ...props }) {
@@ -1749,11 +1761,12 @@ const createCustomProvider = (providerId, resourceProviders) => {
 				version,
 				state: await getProvider(type).getData?.(props) ?? {}
 			};
-		},
-		async isRefreshStateEqual({ type, ...props }) {
-			return await getProvider(type).isRefreshStateEqual?.(props) ?? false;
 		}
 	};
+	if (hasRefreshResource) provider.refreshResource = async ({ type, ...props }) => {
+		return await getProvider(type).refreshResource?.(props);
+	};
+	return provider;
 };
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@terraforge/core",
-	"version": "0.0.29",
+	"version": "0.0.31",
 	"type": "module",
 	"repository": {
 		"type": "git",