@terraforge/core 0.0.6 → 0.0.8

package/dist/index.d.ts

@@ -58,12 +58,13 @@ declare const isDataSource: (obj: object) => obj is DataSource;
 type ResourceConfig = Config & {
     /** Import an existing resource instead of creating a new resource. */
     import?: string;
-    /** If true the resource will be retained in the backing cloud provider during a Pulumi delete operation. */
+    /** If true the resource will be retained in the backing cloud provider during a delete operation. */
     retainOnDelete?: boolean;
-    /** Override the default create-after-delete behavior when replacing a resource. */
     /** If set, the provider’s Delete method will not be called for this resource if the specified resource is being deleted as well. */
     /** Declare that changes to certain properties should be treated as forcing a replacement. */
     replaceOnChanges?: string[];
+    /** If true, create the replacement before deleting the existing resource. */
+    createBeforeReplace?: boolean;
 };
 type ResourceMeta<I extends State = State, O extends State = State> = Meta<'resource', I, O, ResourceConfig>;
 type Resource<I extends State = State, O extends State = State> = O & {

package/dist/index.js

@@ -186,6 +186,40 @@ var findInputDeps = (props) => {
   find(props);
   return deps;
 };
+var formatPath = (path) => {
+  if (path.length === 0) {
+    return "<root>";
+  }
+  return path.map((part) => {
+    if (typeof part === "number") {
+      return `[${part}]`;
+    }
+    return `.${part}`;
+  }).join("").replace(/^\./, "");
+};
+var findInputDepsWithPaths = (props) => {
+  const deps = [];
+  const find = (value, path) => {
+    if (value instanceof Output) {
+      for (const meta of value.dependencies) {
+        deps.push({
+          meta,
+          path: formatPath(path)
+        });
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.map((item, index) => find(item, [...path, index]));
+      return;
+    }
+    if (value?.constructor === Object) {
+      Object.entries(value).map(([key, item]) => find(item, [...path, key]));
+    }
+  };
+  find(props, []);
+  return deps;
+};
 var resolveInputs = async (inputs) => {
   const unresolved = [];
   const find = (props, parent, key) => {
@@ -420,6 +454,9 @@ var DependencyGraph = class {
     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}`);
       }
@@ -1030,6 +1067,7 @@ var deployApp = async (app, opt) => {
   }
   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)) {
@@ -1099,6 +1137,14 @@ var deployApp = async (app, opt) => {
     for (const node of stack.nodes) {
       const meta = getMeta(node);
       const dependencies = [...meta.dependencies];
+      for (let i = 0; i < dependencies.length; i++) {
+        if (!dependencies[i]) {
+          const depPaths = findInputDepsWithPaths(meta.input).map((dep) => `${dep.path} -> ${dep.meta?.urn ?? "undefined"}`).join(", ");
+          throw new Error(
+            `Resource ${meta.urn} has an undefined dependency at index ${i}. Check inputs for missing/undefined Output references. ` + (depPaths ? `Dependency sources: ${depPaths}` : "")
+          );
+        }
+      }
       const partialNewResourceState = {
         dependencies,
         lifecycle: isResource(node) ? {
@@ -1177,99 +1223,107 @@ var deployApp = async (app, opt) => {
               let newResourceState;
               const ignoreReplace = forcedUpdateDependents.has(meta2.urn);
               if (!ignoreReplace && requiresReplacement(nodeState.input, input, meta2.config?.replaceOnChanges ?? [])) {
-                for (const [dependentUrn, dependentNode] of nodeByUrn.entries()) {
-                  if (!isResource(dependentNode)) {
-                    continue;
-                  }
-                  const dependentMeta = getMeta(dependentNode);
-                  if (!dependentMeta.dependencies.has(meta2.urn)) {
-                    continue;
-                  }
-                  if (plannedDependents.has(dependentUrn)) {
-                    continue;
+                if (meta2.config?.createBeforeReplace) {
+                  const priorState = { ...nodeState };
+                  newResourceState = await createResource(node, appState.idempotentToken, input, opt);
+                  if (!meta2.config?.retainOnDelete) {
+                    replacementDeletes.set(meta2.urn, priorState);
                   }
-                  const dependentStackState = stackStates.get(dependentMeta.stack.urn);
-                  const dependentState = dependentStackState?.nodes[dependentUrn];
-                  if (!dependentStackState || !dependentState) {
-                    continue;
-                  }
-                  const dependencyPaths = findDependencyPaths(dependentMeta.input, meta2.urn);
-                  if (dependencyPaths.length === 0) {
-                    continue;
-                  }
-                  const detachedInput = stripDependencyInputs(
-                    dependentState.input,
-                    dependentMeta.input,
-                    meta2.urn
-                  );
-                  if (compareState(dependentState.input, detachedInput)) {
-                    continue;
-                  }
-                  plannedDependents.add(dependentUrn);
-                  let dependentRequiresReplacement = false;
-                  const dependentProvider = findProvider(opt.providers, dependentMeta.provider);
-                  if (dependentProvider.planResourceChange) {
-                    try {
-                      const dependentPlan = await dependentProvider.planResourceChange({
-                        type: dependentMeta.type,
-                        priorState: dependentState.output,
-                        proposedState: detachedInput
-                      });
-                      dependentRequiresReplacement = dependentPlan.requiresReplacement;
-                    } catch (error) {
-                      throw ResourceError.wrap(
-                        dependentMeta.urn,
-                        dependentMeta.type,
-                        "update",
-                        error
-                      );
+                } else {
+                  for (const [dependentUrn, dependentNode] of nodeByUrn.entries()) {
+                    if (!isResource(dependentNode)) {
+                      continue;
                     }
-                  }
-                  if (dependentRequiresReplacement) {
-                    if (!allowsDependentReplace(
-                      dependentMeta.config?.replaceOnChanges,
-                      dependencyPaths
-                    )) {
-                      throw ResourceError.wrap(
-                        dependentMeta.urn,
-                        dependentMeta.type,
-                        "update",
-                        new Error(
-                          `Replacing ${meta2.urn} requires ${dependentMeta.urn} to set replaceOnChanges for its dependency fields.`
-                        )
-                      );
+                    const dependentMeta = getMeta(dependentNode);
+                    if (!dependentMeta.dependencies.has(meta2.urn)) {
+                      continue;
                     }
-                    await deleteResource(
-                      appState.idempotentToken,
-                      dependentUrn,
-                      dependentState,
-                      opt
-                    );
-                    delete dependentStackState.nodes[dependentUrn];
-                  } else {
-                    const updated = await updateResource(
-                      dependentNode,
-                      appState.idempotentToken,
+                    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, meta2.urn);
+                    if (dependencyPaths.length === 0) {
+                      continue;
+                    }
+                    const detachedInput = stripDependencyInputs(
                       dependentState.input,
-                      dependentState.output,
-                      detachedInput,
-                      opt
+                      dependentMeta.input,
+                      meta2.urn
                     );
-                    Object.assign(dependentState, {
-                      input: detachedInput,
-                      ...updated
-                    });
-                    forcedUpdateDependents.add(dependentUrn);
+                    if (compareState(dependentState.input, detachedInput)) {
+                      continue;
+                    }
+                    plannedDependents.add(dependentUrn);
+                    let dependentRequiresReplacement = false;
+                    const dependentProvider = findProvider(opt.providers, dependentMeta.provider);
+                    if (dependentProvider.planResourceChange) {
+                      try {
+                        const dependentPlan = await dependentProvider.planResourceChange({
+                          type: dependentMeta.type,
+                          priorState: dependentState.output,
+                          proposedState: detachedInput
+                        });
+                        dependentRequiresReplacement = dependentPlan.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",
+                          new Error(
+                            `Replacing ${meta2.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
+                  );
                 }
-                newResourceState = await replaceResource(
-                  node,
-                  appState.idempotentToken,
-                  nodeState.input,
-                  nodeState.output,
-                  input,
-                  opt
-                );
               } else {
                 newResourceState = await updateResource(
                   node,
@@ -1300,6 +1354,19 @@ var deployApp = async (app, opt) => {
     }
   }
   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(new Error(`${error}`));
+        }
+      }
+    }
+  }
   removeEmptyStackStates(appState);
   delete appState.idempotentToken;
   await opt.backend.state.update(app.urn, appState);

package/package.json

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