@pulumi/pulumi 3.65.1 → 3.66.0

package/tests/runtime/langhost/cases/005.resource_thens/index.js

@@ -6,8 +6,8 @@ let pulumi = require("../../../../../");
 class ResourceA extends pulumi.CustomResource {
     constructor(name) {
         super("test:index:ResourceA", name, {
-            "inprop": 777,
-            "outprop": undefined,
+            inprop: 777,
+            outprop: undefined,
         });
     }
 }
@@ -15,31 +15,31 @@ class ResourceA extends pulumi.CustomResource {
 class ResourceB extends pulumi.CustomResource {
     constructor(name, other) {
         super("test:index:ResourceB", name, {
-            "otherIn": other.inprop,
-            "otherOut": other.outprop,
+            otherIn: other.inprop,
+            otherOut: other.outprop,
         });
     }
 }
 
 // First create and validate a simple resource A with an input and output.
 let a = new ResourceA("resourceA");
-a.urn.apply(urn => {
+a.urn.apply((urn) => {
     console.log(`A.URN: ${urn}`);
     assert.strictEqual(urn, "test:index:ResourceA::resourceA");
 });
-a.id.apply(id => {
+a.id.apply((id) => {
     if (id) {
         console.log(`A.ID: ${id}`);
         assert.strictEqual(id, "resourceA");
     }
 });
-a.inprop.apply(prop => {
+a.inprop.apply((prop) => {
     if (prop) {
         console.log(`A.InProp: ${prop}`);
         assert.strictEqual(prop, 777);
     }
 });
-a.outprop.apply(prop => {
+a.outprop.apply((prop) => {
     if (prop) {
         console.log(`A.OutProp: ${prop}`);
         assert.strictEqual(prop, "output yeah");
@@ -48,26 +48,25 @@ a.outprop.apply(prop => {
 
 // Next, create and validate another resource B which depends upon resource A.
 let b = new ResourceB("resourceB", a);
-b.urn.apply(urn => {
+b.urn.apply((urn) => {
     console.log(`B.URN: ${urn}`);
     assert.strictEqual(urn, "test:index:ResourceB::resourceB");
 });
-b.id.apply(id => {
+b.id.apply((id) => {
     if (id) {
         console.log(`B.ID: ${id}`);
         assert.strictEqual(id, "resourceB");
     }
 });
-b.otherIn.apply(prop => {
+b.otherIn.apply((prop) => {
     if (prop) {
         console.log(`B.OtherIn: ${prop}`);
         assert.strictEqual(prop, 777);
     }
 });
-b.otherOut.apply(prop => {
+b.otherOut.apply((prop) => {
     if (prop) {
         console.log(`B.OtherOut: ${prop}`);
         assert.strictEqual(prop, "output yeah");
     }
 });
-

package/tests/runtime/langhost/cases/006.asset/index.js

@@ -5,10 +5,9 @@ let pulumi = require("../../../../../");
 class FileResource extends pulumi.CustomResource {
     constructor(name, data) {
         super("test:index:FileResource", name, {
-            "data": data,
+            data: data,
         });
     }
 }
 
 new FileResource("file1", new pulumi.asset.FileAsset("./testdata.txt"));
-

package/tests/runtime/langhost/cases/007.promises_io/index.js

@@ -6,7 +6,7 @@ let fs = require("fs");
 class FileResource extends pulumi.CustomResource {
     constructor(name, data) {
         super("test:index:FileResource", name, {
-            "data": data,
+            data: data,
         });
     }
 }
@@ -21,6 +21,5 @@ new FileResource(
                 resolve(data.toString("utf-8"));
             }
         });
-    })
+    }),
 );
-

package/tests/runtime/langhost/cases/008.ten_depends_on_resources/index.js

@@ -23,16 +23,24 @@ for (let i = 0; i < 10; i++) {
     //     - Promise<Output<Resource>[]>
     //     - Output<Promise<Resource>[]>
     //     - Output<Output<Resource>[]>
-    let r0 = new MyResource("testResource" + i*10, { dependsOn: last });
-    let r1 = new MyResource("testResource" + i*10+1, { dependsOn: all });
-    let r2 = new MyResource("testResource" + i*10+2, { dependsOn: Promise.resolve(last) });
-    let r3 = new MyResource("testResource" + i*10+3, { dependsOn: pulumi.Output.create(last) });
-    let r4 = new MyResource("testResource" + i*10+4, { dependsOn: Promise.resolve(all) });
-    let r5 = new MyResource("testResource" + i*10+5, { dependsOn: pulumi.Output.create(all) });
-    let r6 = new MyResource("testResource" + i*10+6, { dependsOn: Promise.resolve(all.map(a => Promise.resolve(a))) });
-    let r7 = new MyResource("testResource" + i*10+7, { dependsOn: Promise.resolve(all.map(a => pulumi.Output.create(a))) });
-    let r8 = new MyResource("testResource" + i*10+8, { dependsOn: pulumi.Output.create(all).apply(a => Promise.resolve(a)) });
-    let r9 = new MyResource("testResource" + i*10+9, { dependsOn: pulumi.Output.create(all).apply(a => pulumi.Output.create(a)) });
-    all = all.concat([ r0, r1, r2, r3, r4, r5, r6, r7, r8, r9 ]);
+    let r0 = new MyResource("testResource" + i * 10, { dependsOn: last });
+    let r1 = new MyResource("testResource" + i * 10 + 1, { dependsOn: all });
+    let r2 = new MyResource("testResource" + i * 10 + 2, { dependsOn: Promise.resolve(last) });
+    let r3 = new MyResource("testResource" + i * 10 + 3, { dependsOn: pulumi.Output.create(last) });
+    let r4 = new MyResource("testResource" + i * 10 + 4, { dependsOn: Promise.resolve(all) });
+    let r5 = new MyResource("testResource" + i * 10 + 5, { dependsOn: pulumi.Output.create(all) });
+    let r6 = new MyResource("testResource" + i * 10 + 6, {
+        dependsOn: Promise.resolve(all.map((a) => Promise.resolve(a))),
+    });
+    let r7 = new MyResource("testResource" + i * 10 + 7, {
+        dependsOn: Promise.resolve(all.map((a) => pulumi.Output.create(a))),
+    });
+    let r8 = new MyResource("testResource" + i * 10 + 8, {
+        dependsOn: pulumi.Output.create(all).apply((a) => Promise.resolve(a)),
+    });
+    let r9 = new MyResource("testResource" + i * 10 + 9, {
+        dependsOn: pulumi.Output.create(all).apply((a) => pulumi.Output.create(a)),
+    });
+    all = all.concat([r0, r1, r2, r3, r4, r5, r6, r7, r8, r9]);
     last = r0;
 }

package/tests/runtime/langhost/cases/009.invoke/index.js

@@ -20,6 +20,6 @@ for (const key in args) {
 
 // When invoking asynchronously: Ensure the properties are available asynchronously through normal
 // Promise semantics.
-result2.then(v => {
+result2.then((v) => {
     assert.deepStrictEqual(v, args);
 });

package/tests/runtime/langhost/cases/012.assets_archive/index.js

@@ -5,17 +5,19 @@ let pulumi = require("../../../../../");
 class MyResource extends pulumi.CustomResource {
     constructor(name) {
         let archive = new pulumi.asset.AssetArchive({
-            "asset": new pulumi.asset.StringAsset("foo"),
-            "archive": new pulumi.asset.AssetArchive({}),
+            asset: new pulumi.asset.StringAsset("foo"),
+            archive: new pulumi.asset.AssetArchive({}),
         });
-        let archiveP = Promise.resolve(new pulumi.asset.AssetArchive({
-            "foo": new pulumi.asset.StringAsset("bar"),
-        }));
+        let archiveP = Promise.resolve(
+            new pulumi.asset.AssetArchive({
+                foo: new pulumi.asset.StringAsset("bar"),
+            }),
+        );
         let assetP = Promise.resolve(new pulumi.asset.StringAsset("baz"));
         super("test:index:MyResource", name, {
-            "archive": archive,
-            "archiveP": archiveP,
-            "assetP": assetP,
+            archive: archive,
+            archiveP: archiveP,
+            assetP: assetP,
         });
     }
 }

package/tests/runtime/langhost/cases/013.unhandled_promise_rejection/index.js

@@ -1,3 +1,3 @@
 new Promise((resolve, reject) => {
-	reject(new Error("💥 goes the dynamite (as promised)"));
+    reject(new Error("💥 goes the dynamite (as promised)"));
 });

package/tests/runtime/langhost/cases/014.read_resource/index.js

@@ -6,14 +6,14 @@ let pulumi = require("../../../../../");
 let inputs = {
     a: "fizzz",
     b: false,
-    c: [ 0.73, "x", { zed: 923 } ],
+    c: [0.73, "x", { zed: 923 }],
     d: undefined,
 };
 
 let res = new pulumi.CustomResource("test:read:resource", "foo", inputs, { id: "abc123" });
-res.id.apply(id => assert.strictEqual(id, "abc123"));
-res.urn.apply(urn => assert.strictEqual(urn, "test:read:resource::foo"));
-res.a.apply(a => assert.strictEqual(a, inputs.a)); // same as input
-res.b.apply(b => assert.strictEqual(b, true)); // output changed to true
-res.c.apply(c => assert.deepStrictEqual(c, inputs.c)); // same as input
-res.d.apply(d => assert.strictEqual(d, "and then, out of nowhere ...")); // from the inputs
+res.id.apply((id) => assert.strictEqual(id, "abc123"));
+res.urn.apply((urn) => assert.strictEqual(urn, "test:read:resource::foo"));
+res.a.apply((a) => assert.strictEqual(a, inputs.a)); // same as input
+res.b.apply((b) => assert.strictEqual(b, true)); // output changed to true
+res.c.apply((c) => assert.deepStrictEqual(c, inputs.c)); // same as input
+res.d.apply((d) => assert.strictEqual(d, "and then, out of nowhere ...")); // from the inputs

package/tests/runtime/langhost/cases/015.runtime_sxs/index.js

@@ -5,7 +5,7 @@
 // Subsequent copies of the runtime are able to configure themselves by using environment variables.
 
 let assert = require("assert");
-let path = require('path');
+let path = require("path");
 
 const sdkPath = "../../../../../";
 
@@ -14,11 +14,11 @@ let pulumi1 = require(sdkPath);
 
 // Now delete the entries in the require cache, and load up the second copy:
 const resolvedSdkPath = path.dirname(require.resolve(sdkPath));
-Object.keys(require.cache).forEach(path => {
+Object.keys(require.cache).forEach((path) => {
     if (path.startsWith(resolvedSdkPath)) {
         delete require.cache[path];
     }
-})
+});
 let pulumi2 = require(sdkPath);
 
 // Make sure they are different:
@@ -26,10 +26,26 @@ assert(pulumi1 !== pulumi2, "pulumi1 !== pulumi2");
 assert(pulumi1.runtime !== pulumi2.runtime, "pulumi1.runtime !== pulumi2.runtime");
 
 // Check that various settings are equal:
-assert.strictEqual(pulumi1.runtime.isDryRun(), pulumi2.runtime.isDryRun(), "pulumi1.runtime.isDryRun() !== pulumi2.runtime.isDryRun()");
-assert.strictEqual(pulumi1.runtime.getProject(), pulumi2.runtime.getProject(), "pulumi1.runtime.getProject() !== pulumi2.runtime.getProject()");
-assert.strictEqual(pulumi1.runtime.getStack(), pulumi2.runtime.getStack(), "pulumi1.runtime.getStack() !== pulumi2.runtime.getStack()");
-assert.deepStrictEqual(pulumi1.runtime.allConfig(), pulumi2.runtime.allConfig(), "pulumi1.runtime.allConfig() !== pulumi2.runtime.getStack()");
+assert.strictEqual(
+    pulumi1.runtime.isDryRun(),
+    pulumi2.runtime.isDryRun(),
+    "pulumi1.runtime.isDryRun() !== pulumi2.runtime.isDryRun()",
+);
+assert.strictEqual(
+    pulumi1.runtime.getProject(),
+    pulumi2.runtime.getProject(),
+    "pulumi1.runtime.getProject() !== pulumi2.runtime.getProject()",
+);
+assert.strictEqual(
+    pulumi1.runtime.getStack(),
+    pulumi2.runtime.getStack(),
+    "pulumi1.runtime.getStack() !== pulumi2.runtime.getStack()",
+);
+assert.deepStrictEqual(
+    pulumi1.runtime.allConfig(),
+    pulumi2.runtime.allConfig(),
+    "pulumi1.runtime.allConfig() !== pulumi2.runtime.getStack()",
+);
 
 // Check that the two runtimes agree on the stack resource
 let stack1 = pulumi1.runtime.getStackResource();
@@ -43,27 +59,27 @@ assert.strictEqual(cfg1.get("message"), cfg2.get("message"));
 
 // Try and set a stack transformation
 function transform1(args) {
-    args.props["runtime1"] = 1
-    return { props: args.props, opts: args.opts }
+    args.props["runtime1"] = 1;
+    return { props: args.props, opts: args.opts };
 }
 function transform2(args) {
-    args.props["runtime2"] = 2
-    return { props: args.props, opts: args.opts }
+    args.props["runtime2"] = 2;
+    return { props: args.props, opts: args.opts };
 }
 
-pulumi1.runtime.registerStackTransformation(transform1)
-pulumi2.runtime.registerStackTransformation(transform2)
+pulumi1.runtime.registerStackTransformation(transform1);
+pulumi2.runtime.registerStackTransformation(transform2);
 
 // Now do some useful things that require RPC connections:
 pulumi1.log.info("logging via Pulumi1 works!");
 pulumi2.log.info("logging via Pulumi2 works too!");
 let res1 = new pulumi1.CustomResource("test:x:resource", "p1p1p1");
-res1.urn.apply(urn => assert.strictEqual(urn, "test:x:resource::p1p1p1"));
+res1.urn.apply((urn) => assert.strictEqual(urn, "test:x:resource::p1p1p1"));
 let res2 = new pulumi2.CustomResource("test:y:resource", "p2p2p2");
-res2.urn.apply(urn => assert.strictEqual(urn, "test:y:resource::p2p2p2"));
+res2.urn.apply((urn) => assert.strictEqual(urn, "test:y:resource::p2p2p2"));
 
 // Both resources should have the stack transforms applied
-res1.runtime1.apply(value => assert.strictEqual(value, 1));
-res1.runtime2.apply(value => assert.strictEqual(value, 2));
-res2.runtime1.apply(value => assert.strictEqual(value, 1));
-res2.runtime2.apply(value => assert.strictEqual(value, 2));
+res1.runtime1.apply((value) => assert.strictEqual(value, 1));
+res1.runtime2.apply((value) => assert.strictEqual(value, 2));
+res2.runtime1.apply((value) => assert.strictEqual(value, 1));
+res2.runtime2.apply((value) => assert.strictEqual(value, 2));

package/tests/runtime/langhost/cases/017.parent_defaults/index.js

@@ -6,56 +6,56 @@ let assert = require("assert");
 let pulumi = require("../../../../../");
 
 class Provider extends pulumi.ProviderResource {
-	constructor(name, opts) {
-		super("test", name, {}, opts);
-	}
+    constructor(name, opts) {
+        super("test", name, {}, opts);
+    }
 }
 
 class Resource extends pulumi.CustomResource {
-	constructor(name, createChildren, opts) {
-		super("test:index:Resource", name, {}, opts)
+    constructor(name, createChildren, opts) {
+        super("test:index:Resource", name, {}, opts);
 
-		if (createChildren) {
-			createChildren(name, this);
-		}
-	}
+        if (createChildren) {
+            createChildren(name, this);
+        }
+    }
 }
 
 class Component extends pulumi.ComponentResource {
-	constructor(name, createChildren, opts) {
-		super("test:index:Component", name, {}, opts);
+    constructor(name, createChildren, opts) {
+        super("test:index:Component", name, {}, opts);
 
-		createChildren(name, this);
-	}
+        createChildren(name, this);
+    }
 }
 
 function createResources(name, createChildren, parent) {
-	// Use all parent defaults
-	new Resource(`${name}/r0`, createChildren, { parent: parent });
+    // Use all parent defaults
+    new Resource(`${name}/r0`, createChildren, { parent: parent });
 
-	// Override protect
-	new Resource(`${name}/r1`, createChildren, { parent: parent, protect: false });
-	new Resource(`${name}/r2`, createChildren, { parent: parent, protect: true });
+    // Override protect
+    new Resource(`${name}/r1`, createChildren, { parent: parent, protect: false });
+    new Resource(`${name}/r2`, createChildren, { parent: parent, protect: true });
 
-	// Override provider
-	const provider = new Provider(`${name}-p`, { parent });
-	const r3 = new Resource(`${name}/r3`, createChildren, { parent, provider });
-	assert.strictEqual(r3.getProvider("test:index:Resource"), provider);
+    // Override provider
+    const provider = new Provider(`${name}-p`, { parent });
+    const r3 = new Resource(`${name}/r3`, createChildren, { parent, provider });
+    assert.strictEqual(r3.getProvider("test:index:Resource"), provider);
 }
 
 function createComponents(name, createChildren, parent) {
-	// Use all parent defaults
-	new Component(`${name}/c0`, createChildren, { parent: parent });
-
-	// Override protect.
-	new Component(`${name}/c1`, createChildren, { parent: parent, protect: false });
-	new Component(`${name}/c2`, createChildren, { parent: parent, protect: true });
-
-	// Override providers.
-	new Component(`${name}/c3`, createChildren, {
-		parent: parent,
-		providers: { "test": new Provider(`${name}-p`, { parent: parent }) },
-	});
+    // Use all parent defaults
+    new Component(`${name}/c0`, createChildren, { parent: parent });
+
+    // Override protect.
+    new Component(`${name}/c1`, createChildren, { parent: parent, protect: false });
+    new Component(`${name}/c2`, createChildren, { parent: parent, protect: true });
+
+    // Override providers.
+    new Component(`${name}/c3`, createChildren, {
+        parent: parent,
+        providers: { test: new Provider(`${name}-p`, { parent: parent }) },
+    });
 }
 
 // Create default (unparented) resources
@@ -63,19 +63,27 @@ createResources("unparented");
 
 // Create singly-nested resources
 createComponents("single-nest", (name, parent) => {
-	createResources(name, undefined, parent);
+    createResources(name, undefined, parent);
 });
 
 // Create doubly-nested resources
 createComponents("double-nest", (name, parent) => {
-	createComponents(name, (name, parent) => {
-		createResources(name, undefined, parent);
-	}, parent);
+    createComponents(
+        name,
+        (name, parent) => {
+            createResources(name, undefined, parent);
+        },
+        parent,
+    );
 });
 
 // Create doubly-nested resources parented to other resources
 createComponents("double-nest-2", (name, parent) => {
-	createResources(name, (name, parent) => {
-		createResources(name, undefined, parent);
-	}, parent);
+    createResources(
+        name,
+        (name, parent) => {
+            createResources(name, undefined, parent);
+        },
+        parent,
+    );
 });

package/tests/runtime/langhost/cases/020.property_dependencies/index.js

@@ -4,27 +4,36 @@ let assert = require("assert");
 let pulumi = require("../../../../../");
 
 class MyResource extends pulumi.CustomResource {
-	constructor(name, args, opts) {
-		super("test:index:MyResource", name, Object.assign(args, {
-			outprop: undefined,
-		}), opts);
-	}
+    constructor(name, args, opts) {
+        super(
+            "test:index:MyResource",
+            name,
+            Object.assign(args, {
+                outprop: undefined,
+            }),
+            opts,
+        );
+    }
 }
 
 let resA = new MyResource("resA", {});
-let resB = new MyResource("resB", {}, { dependsOn: [ resA ] });
+let resB = new MyResource("resB", {}, { dependsOn: [resA] });
 let resC = new MyResource("resC", {
-	"propA": resA.outprop,
-	"propB": resB.outprop,
-	"propC": "foo",
+    propA: resA.outprop,
+    propB: resB.outprop,
+    propC: "foo",
 });
-let resD  = new MyResource("resD", {
-	"propA": pulumi.all([resA.outprop, resB.outprop]).apply(([a, b]) => `${a} ${b}`),
-	"propB": resC.outprop,
-	"propC": "bar",
+let resD = new MyResource("resD", {
+    propA: pulumi.all([resA.outprop, resB.outprop]).apply(([a, b]) => `${a} ${b}`),
+    propB: resC.outprop,
+    propC: "bar",
 });
-let resE = new MyResource("resE", {
-	"propA": resC.outprop,
-	"propB": pulumi.all([resA.outprop, resB.outprop]).apply(([a, b]) => `${a} ${b}`),
-	"propC": "baz",
-}, { dependsOn: [ resD ] });
+let resE = new MyResource(
+    "resE",
+    {
+        propA: resC.outprop,
+        propB: pulumi.all([resA.outprop, resB.outprop]).apply(([a, b]) => `${a} ${b}`),
+        propC: "baz",
+    },
+    { dependsOn: [resD] },
+);

package/tests/runtime/langhost/cases/021.parent_child_dependencies/index.js

@@ -2,9 +2,9 @@ let assert = require("assert");
 let pulumi = require("../../../../../");
 
 class MyResource extends pulumi.CustomResource {
-	constructor(name, args, opts) {
-		super("test:index:MyResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyResource", name, args, opts);
+    }
 }
 
 //            cust1

package/tests/runtime/langhost/cases/022.parent_child_dependencies_2/index.js

@@ -2,9 +2,9 @@ let assert = require("assert");
 let pulumi = require("../../../../../");
 
 class MyResource extends pulumi.CustomResource {
-	constructor(name, args, opts) {
-		super("test:index:MyResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyResource", name, args, opts);
+    }
 }
 
 //            cust1

package/tests/runtime/langhost/cases/023.parent_child_dependencies_3/index.js

@@ -2,15 +2,15 @@ let assert = require("assert");
 let pulumi = require("../../../../../");
 
 class MyCustomResource extends pulumi.CustomResource {
-	constructor(name, args, opts) {
-		super("test:index:MyCustomResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyCustomResource", name, args, opts);
+    }
 }
 
 class MyComponentResource extends pulumi.ComponentResource {
-	constructor(name, args, opts) {
-		super("test:index:MyComponentResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyComponentResource", name, args, opts);
+    }
 }
 
 //            comp1

package/tests/runtime/langhost/cases/024.parent_child_dependencies_4/index.js

@@ -2,15 +2,15 @@ let assert = require("assert");
 let pulumi = require("../../../../../");
 
 class MyCustomResource extends pulumi.CustomResource {
-	constructor(name, args, opts) {
-		super("test:index:MyCustomResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyCustomResource", name, args, opts);
+    }
 }
 
 class MyComponentResource extends pulumi.ComponentResource {
-	constructor(name, args, opts) {
-		super("test:index:MyComponentResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyComponentResource", name, args, opts);
+    }
 }
 
 //            comp1
@@ -18,5 +18,5 @@ class MyComponentResource extends pulumi.ComponentResource {
 //       cust1    cust2
 
 let comp1 = new MyComponentResource("comp1");
-let cust1 = new MyCustomResource("cust1", { }, { parent: comp1 });
-let cust2 = new MyCustomResource("cust2", { }, { parent: comp1 });
+let cust1 = new MyCustomResource("cust1", {}, { parent: comp1 });
+let cust2 = new MyCustomResource("cust2", {}, { parent: comp1 });

package/tests/runtime/langhost/cases/025.parent_child_dependencies_5/index.js

@@ -2,15 +2,15 @@ let assert = require("assert");
 let pulumi = require("../../../../../");
 
 class MyCustomResource extends pulumi.CustomResource {
-	constructor(name, args, opts) {
-		super("test:index:MyCustomResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyCustomResource", name, args, opts);
+    }
 }
 
 class MyComponentResource extends pulumi.ComponentResource {
-	constructor(name, args, opts) {
-		super("test:index:MyComponentResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyComponentResource", name, args, opts);
+    }
 }
 
 //            comp1
@@ -18,7 +18,7 @@ class MyComponentResource extends pulumi.ComponentResource {
 //        cust1   cust2
 
 let comp1 = new MyComponentResource("comp1");
-let cust1 = new MyCustomResource("cust1", { }, { parent: comp1 });
-let cust2 = new MyCustomResource("cust2", { }, { parent: comp1 });
+let cust1 = new MyCustomResource("cust1", {}, { parent: comp1 });
+let cust2 = new MyCustomResource("cust2", {}, { parent: comp1 });
 
-let res1 = new MyCustomResource("res1", { }, { dependsOn: comp1 });
+let res1 = new MyCustomResource("res1", {}, { dependsOn: comp1 });

package/tests/runtime/langhost/cases/026.parent_child_dependencies_6/index.js

@@ -2,15 +2,15 @@ let assert = require("assert");
 let pulumi = require("../../../../../");
 
 class MyCustomResource extends pulumi.CustomResource {
-	constructor(name, args, opts) {
-		super("test:index:MyCustomResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyCustomResource", name, args, opts);
+    }
 }
 
 class MyComponentResource extends pulumi.ComponentResource {
-	constructor(name, args, opts) {
-		super("test:index:MyComponentResource", name, args, opts);
-	}
+    constructor(name, args, opts) {
+        super("test:index:MyComponentResource", name, args, opts);
+    }
 }
 
 //            comp1
@@ -20,10 +20,10 @@ class MyComponentResource extends pulumi.ComponentResource {
 //            cust2    cust3
 
 let comp1 = new MyComponentResource("comp1");
-let cust1 = new MyCustomResource("cust1", { }, { parent: comp1 });
+let cust1 = new MyCustomResource("cust1", {}, { parent: comp1 });
 
-let comp2 = new MyComponentResource("comp2", { }, { parent: comp1 });
-let cust2 = new MyCustomResource("cust2", { }, { parent: comp2 });
-let cust3 = new MyCustomResource("cust3", { }, { parent: comp2 });
+let comp2 = new MyComponentResource("comp2", {}, { parent: comp1 });
+let cust2 = new MyCustomResource("cust2", {}, { parent: comp2 });
+let cust3 = new MyCustomResource("cust3", {}, { parent: comp2 });
 
-let res1 = new MyCustomResource("res1", { }, { dependsOn: comp1 });
+let res1 = new MyCustomResource("res1", {}, { dependsOn: comp1 });