@pulumi/pulumi 3.163.0-alpha.xdc88586 → 3.163.0-alpha.xe7c1e4f

package/runtime/resource.js

@@ -12,15 +12,6 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -71,8 +62,8 @@ function getResource(res, parent, props, custom, urn) {
     const resopAsync = prepareResource(label, res, parent, custom, false, props, {});
     const preallocError = new Error();
     debuggable_1.debuggablePromise(resopAsync
-        .then((resop) => __awaiter(this, void 0, void 0, function* () {
-        const inputs = yield rpc_1.serializeProperties(label, { urn });
+        .then(async (resop) => {
+        const inputs = await rpc_1.serializeProperties(label, { urn });
         const req = new resproto.ResourceInvokeRequest();
         req.setTok("pulumi:pulumi:getResource");
         req.setArgs(gstruct.Struct.fromJavaScript(inputs));
@@ -81,12 +72,12 @@ function getResource(res, parent, props, custom, urn) {
         req.setAcceptresources(!utils.disableResourceReferences);
         // Now run the operation, serializing the invocation if necessary.
         const opLabel = `monitor.getResource(${label})`;
-        runAsyncResourceOp(opLabel, () => __awaiter(this, void 0, void 0, function* () {
+        runAsyncResourceOp(opLabel, async () => {
             let resp = {};
             let err;
             try {
                 if (monitor) {
-                    resp = yield debuggable_1.debuggablePromise(new Promise((resolve, reject) => monitor.invoke(req, (rpcError, innerResponse) => {
+                    resp = await debuggable_1.debuggablePromise(new Promise((resolve, reject) => monitor.invoke(req, (rpcError, innerResponse) => {
                         log.debug(`getResource Invoke RPC finished: err: ${rpcError}, resp: ${innerResponse}`);
                         if (rpcError) {
                             if (rpcError.code === grpc.status.UNAVAILABLE ||
@@ -105,7 +96,7 @@ function getResource(res, parent, props, custom, urn) {
                     })), opLabel);
                     // If the invoke failed, raise an error
                     const failures = resp.getFailuresList();
-                    if (failures === null || failures === void 0 ? void 0 : failures.length) {
+                    if (failures?.length) {
                         let reasons = "";
                         for (let i = 0; i < failures.length; i++) {
                             if (reasons !== "") {
@@ -139,10 +130,10 @@ function getResource(res, parent, props, custom, urn) {
                 const id = resp.id || undefined;
                 resop.resolveID(id, id !== undefined, err);
             }
-            yield resolveOutputs(res, type, urnName, props, resp.state, {}, resop.resolvers, err);
+            await resolveOutputs(res, type, urnName, props, resp.state, {}, resop.resolvers, err);
             done();
-        }));
-    }))
+        });
+    })
         .catch((err) => {
         done();
         throw err;
@@ -167,13 +158,13 @@ function readResource(res, parent, t, name, props, opts, sourcePosition, package
     const resopAsync = prepareResource(label, res, parent, true, false, props, opts);
     const preallocError = new Error();
     debuggable_1.debuggablePromise(resopAsync
-        .then((resop) => __awaiter(this, void 0, void 0, function* () {
-        const resolvedID = yield rpc_1.serializeProperty(label, yield id, new Set(), { keepOutputValues: false });
+        .then(async (resop) => {
+        const resolvedID = await rpc_1.serializeProperty(label, await id, new Set(), { keepOutputValues: false });
         log.debug(`ReadResource RPC prepared: id=${resolvedID}, t=${t}, name=${name}` +
             (settings_1.excessiveDebugOutput ? `, obj=${JSON.stringify(resop.serializedProps)}` : ``));
         let packageRefStr = undefined;
         if (packageRef !== undefined) {
-            packageRefStr = yield packageRef;
+            packageRefStr = await packageRef;
             if (packageRefStr !== undefined) {
                 // If we have a package reference we can clear some of the resource options
                 opts.version = undefined;
@@ -198,13 +189,13 @@ function readResource(res, parent, t, name, props, opts, sourcePosition, package
         req.setPackageref(packageRefStr || "");
         // Now run the operation, serializing the invocation if necessary.
         const opLabel = `monitor.readResource(${label})`;
-        runAsyncResourceOp(opLabel, () => __awaiter(this, void 0, void 0, function* () {
+        runAsyncResourceOp(opLabel, async () => {
             let resp = {};
             let err;
             try {
                 if (monitor) {
                     // If we're attached to the engine, make an RPC call and wait for it to resolve.
-                    resp = yield debuggable_1.debuggablePromise(new Promise((resolve, reject) => monitor.readResource(req, (rpcError, innerResponse) => {
+                    resp = await debuggable_1.debuggablePromise(new Promise((resolve, reject) => monitor.readResource(req, (rpcError, innerResponse) => {
                         log.debug(`ReadResource RPC finished: ${label}; err: ${rpcError}, resp: ${innerResponse}`);
                         if (rpcError) {
                             if (rpcError.code === grpc.status.UNAVAILABLE ||
@@ -224,7 +215,7 @@ function readResource(res, parent, t, name, props, opts, sourcePosition, package
                 }
                 else {
                     // If we aren't attached to the engine, in test mode, mock up a fake response for testing purposes.
-                    const mockurn = yield resource_1.createUrn(req.getName(), req.getType(), req.getParent()).promise();
+                    const mockurn = await resource_1.createUrn(req.getName(), req.getType(), req.getParent()).promise();
                     resp = {
                         getUrn: () => mockurn,
                         getProperties: () => req.getProperties(),
@@ -241,10 +232,10 @@ function readResource(res, parent, t, name, props, opts, sourcePosition, package
             // Now resolve everything: the URN, the ID (supplied as input), and the output properties.
             resop.resolveURN(resp.getUrn(), err);
             resop.resolveID(resolvedID, resolvedID !== undefined, err);
-            yield resolveOutputs(res, t, name, props, resp.getProperties(), {}, resop.resolvers, err);
+            await resolveOutputs(res, t, name, props, resp.getProperties(), {}, resop.resolvers, err);
             done();
-        }));
-    }))
+        });
+    })
         .catch((err) => {
         done();
         throw err;
@@ -261,17 +252,17 @@ function mapAliasesForRequest(aliases, parentURN) {
     if (aliases === undefined) {
         return Promise.resolve([]);
     }
-    return Promise.all(aliases.map((a) => __awaiter(this, void 0, void 0, function* () {
+    return Promise.all(aliases.map(async (a) => {
         const newAlias = new aliasproto.Alias();
         if (typeof a === "string") {
             newAlias.setUrn(a);
         }
         else {
             const newAliasSpec = new aliasproto.Alias.Spec();
-            const name = a.name === undefined ? undefined : yield output_1.output(a.name).promise();
-            const type = a.type === undefined ? undefined : yield output_1.output(a.type).promise();
-            const stack = a.stack === undefined ? undefined : yield output_1.output(a.stack).promise();
-            const project = a.project === undefined ? undefined : yield output_1.output(a.project).promise();
+            const name = a.name === undefined ? undefined : await output_1.output(a.name).promise();
+            const type = a.type === undefined ? undefined : await output_1.output(a.type).promise();
+            const stack = a.stack === undefined ? undefined : await output_1.output(a.stack).promise();
+            const project = a.project === undefined ? undefined : await output_1.output(a.project).promise();
             newAliasSpec.setName(name || "");
             newAliasSpec.setType(type || "");
             newAliasSpec.setStack(stack || "");
@@ -282,7 +273,7 @@ function mapAliasesForRequest(aliases, parentURN) {
                 }
                 else {
                     const aliasParentUrn = getParentURN(a.parent);
-                    const urn = yield aliasParentUrn.promise();
+                    const urn = await aliasParentUrn.promise();
                     if (urn !== undefined) {
                         newAliasSpec.setParenturn(urn);
                     }
@@ -301,7 +292,7 @@ function mapAliasesForRequest(aliases, parentURN) {
             newAlias.setSpec(newAliasSpec);
         }
         return newAlias;
-    })));
+    }));
 }
 exports.mapAliasesForRequest = mapAliasesForRequest;
 /**
@@ -324,10 +315,10 @@ function registerResource(res, parent, t, name, custom, remote, newDependency, p
     // with a non-useful stack trace.
     const preallocError = new Error();
     debuggable_1.debuggablePromise(resopAsync
-        .then((resop) => __awaiter(this, void 0, void 0, function* () {
+        .then(async (resop) => {
         log.debug(`RegisterResource RPC prepared: t=${t}, name=${name}` +
             (settings_1.excessiveDebugOutput ? `, obj=${JSON.stringify(resop.serializedProps)}` : ``));
-        yield settings_1.awaitStackRegistrations();
+        await settings_1.awaitStackRegistrations();
         const callbacks = [];
         if (opts.transforms !== undefined && opts.transforms.length > 0) {
             if (!state_1.getStore().supportsTransforms) {
@@ -338,13 +329,13 @@ function registerResource(res, parent, t, name, custom, remote, newDependency, p
                 throw new Error("Callback server could not initialize");
             }
             for (const transform of opts.transforms) {
-                callbacks.push(yield callbackServer.registerTransform(transform));
+                callbacks.push(await callbackServer.registerTransform(transform));
             }
         }
         // If we have a package reference, we need to wait for it to resolve.
         let packageRefStr = undefined;
         if (packageRef !== undefined) {
-            packageRefStr = yield packageRef;
+            packageRefStr = await packageRef;
             if (packageRefStr !== undefined) {
                 // If we have a package reference we can clear some of the resource options
                 opts.version = undefined;
@@ -371,7 +362,7 @@ function registerResource(res, parent, t, name, custom, remote, newDependency, p
         req.setAcceptresources(!utils.disableResourceReferences);
         req.setAdditionalsecretoutputsList(opts.additionalSecretOutputs || []);
         if (resop.monitorSupportsStructuredAliases) {
-            const aliasesList = yield mapAliasesForRequest(resop.aliases, resop.parentURN);
+            const aliasesList = await mapAliasesForRequest(resop.aliases, resop.parentURN);
             req.setAliasesList(aliasesList);
         }
         else {
@@ -418,13 +409,13 @@ function registerResource(res, parent, t, name, custom, remote, newDependency, p
         }
         // Now run the operation, serializing the invocation if necessary.
         const opLabel = `monitor.registerResource(${label})`;
-        runAsyncResourceOp(opLabel, () => __awaiter(this, void 0, void 0, function* () {
+        runAsyncResourceOp(opLabel, async () => {
             let resp = {};
             let err;
             try {
                 if (monitor) {
                     // If we're running with an attachment to the engine, perform the operation.
-                    resp = yield debuggable_1.debuggablePromise(new Promise((resolve, reject) => monitor.registerResource(req, (rpcErr, innerResponse) => {
+                    resp = await debuggable_1.debuggablePromise(new Promise((resolve, reject) => monitor.registerResource(req, (rpcErr, innerResponse) => {
                         if (rpcErr) {
                             err = rpcErr;
                             // If the monitor is unavailable, it is in the process of shutting down or has already
@@ -449,7 +440,7 @@ function registerResource(res, parent, t, name, custom, remote, newDependency, p
                 }
                 else {
                     // If we aren't attached to the engine, in test mode, mock up a fake response for testing purposes.
-                    const mockurn = yield resource_1.createUrn(req.getName(), req.getType(), req.getParent()).promise();
+                    const mockurn = await resource_1.createUrn(req.getName(), req.getType(), req.getParent()).promise();
                     resp = {
                         getUrn: () => mockurn,
                         getId: () => undefined,
@@ -486,10 +477,10 @@ function registerResource(res, parent, t, name, custom, remote, newDependency, p
             }
             // Now resolve the output properties.
             const keepUnknowns = resp.getResult() !== resproto.Result.SUCCESS;
-            yield resolveOutputs(res, t, name, props, resp.getObject(), deps, resop.resolvers, err, keepUnknowns);
+            await resolveOutputs(res, t, name, props, resp.getObject(), deps, resop.resolvers, err, keepUnknowns);
             done();
-        }));
-    }))
+        });
+    })
         .catch((err) => {
         // If we fail to prepare the resource, we need to ensure that we still call done to prevent a hang.
         done();
@@ -503,196 +494,193 @@ exports.registerResource = registerResource;
  *
  * @internal
  */
-function prepareResource(label, res, parent, custom, remote, props, opts, type, name) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        // Simply initialize the URN property and get prepared to resolve it later on.
-        // Note: a resource urn will always get a value, and thus the output property
-        // for it can always run .apply calls.
-        let resolveURN;
-        {
-            let resolveValue;
-            let rejectValue;
-            let resolveIsKnown;
-            let rejectIsKnown;
-            res.urn = new output_1.Output(res, debuggable_1.debuggablePromise(new Promise((resolve, reject) => {
-                resolveValue = resolve;
-                rejectValue = reject;
-            }), `resolveURN(${label})`), debuggable_1.debuggablePromise(new Promise((resolve, reject) => {
-                resolveIsKnown = resolve;
-                rejectIsKnown = reject;
-            }), `resolveURNIsKnown(${label})`), 
-            /*isSecret:*/ Promise.resolve(false), Promise.resolve(res));
-            resolveURN = (v, err) => {
-                if (err) {
-                    if (errors_1.isGrpcError(err)) {
-                        if (debuggable_1.debugPromiseLeaks) {
-                            console.error("info: skipped rejection in resolveURN");
-                        }
-                        return;
-                    }
-                    rejectValue(err);
-                    rejectIsKnown(err);
-                }
-                else {
-                    resolveValue(v);
-                    resolveIsKnown(true);
-                }
-            };
-        }
-        // If a custom resource, make room for the ID property.
-        let resolveID;
-        if (custom) {
-            let resolveValue;
-            let rejectValue;
-            let resolveIsKnown;
-            let rejectIsKnown;
-            res.id = new output_1.Output(res, debuggable_1.debuggablePromise(new Promise((resolve, reject) => {
-                resolveValue = resolve;
-                rejectValue = reject;
-            }), `resolveID(${label})`), debuggable_1.debuggablePromise(new Promise((resolve, reject) => {
-                resolveIsKnown = resolve;
-                rejectIsKnown = reject;
-            }), `resolveIDIsKnown(${label})`), Promise.resolve(false), Promise.resolve(res));
-            resolveID = (v, isKnown, err) => {
-                if (err) {
-                    if (errors_1.isGrpcError(err)) {
-                        if (debuggable_1.debugPromiseLeaks) {
-                            console.error("info: skipped rejection in resolveID");
-                        }
-                        return;
+async function prepareResource(label, res, parent, custom, remote, props, opts, type, name) {
+    // Simply initialize the URN property and get prepared to resolve it later on.
+    // Note: a resource urn will always get a value, and thus the output property
+    // for it can always run .apply calls.
+    let resolveURN;
+    {
+        let resolveValue;
+        let rejectValue;
+        let resolveIsKnown;
+        let rejectIsKnown;
+        res.urn = new output_1.Output(res, debuggable_1.debuggablePromise(new Promise((resolve, reject) => {
+            resolveValue = resolve;
+            rejectValue = reject;
+        }), `resolveURN(${label})`), debuggable_1.debuggablePromise(new Promise((resolve, reject) => {
+            resolveIsKnown = resolve;
+            rejectIsKnown = reject;
+        }), `resolveURNIsKnown(${label})`), 
+        /*isSecret:*/ Promise.resolve(false), Promise.resolve(res));
+        resolveURN = (v, err) => {
+            if (err) {
+                if (errors_1.isGrpcError(err)) {
+                    if (debuggable_1.debugPromiseLeaks) {
+                        console.error("info: skipped rejection in resolveURN");
                     }
-                    rejectValue(err);
-                    rejectIsKnown(err);
-                }
-                else {
-                    resolveValue(v);
-                    resolveIsKnown(isKnown);
+                    return;
                 }
-            };
-        }
-        // Now "transfer" all input properties into unresolved Promises on res.  This way,
-        // this resource will look like it has all its output properties to anyone it is
-        // passed to.  However, those promises won't actually resolve until the registerResource
-        // RPC returns
-        const resolvers = rpc_1.transferProperties(res, label, props);
-        /** IMPORTANT!  We should never await prior to this line, otherwise the Resource will be partly uninitialized. */
-        // Before we can proceed, all our dependencies must be finished.
-        const explicitDirectDependencies = new Set(yield dependsOn_1.gatherExplicitDependencies(opts.dependsOn));
-        // Serialize out all our props to their final values.  In doing so, we'll also collect all
-        // the Resources pointed to by any Dependency objects we encounter, adding them to 'propertyDependencies'.
-        const [serializedProps, propertyToDirectDependencies] = yield rpc_1.serializeResourceProperties(label, props, {
-            // To initially scope the use of this new feature, we only keep output values when
-            // remote is true (for multi-lang components, i.e. MLCs).
-            keepOutputValues: remote,
-            // When remote is true, exclude resource references from 'propertyDependencies'.
-            // This way, component providers creating outputs for component inputs based
-            // on 'propertyDependencies' won't create outputs for properties that only
-            // contain resource references.
-            excludeResourceReferencesFromDependencies: remote,
-        });
-        // Wait for the parent to complete.
-        // If no parent was provided, parent to the root resource.
-        const parentURN = parent ? yield parent.urn.promise() : undefined;
-        let importID;
-        if (custom) {
-            const customOpts = opts;
-            importID = customOpts.import;
-        }
-        let providerRef;
-        let sendProvider = custom;
-        if (remote && opts.provider) {
-            // If it's a remote component and a provider was specified, only
-            // send the provider in the request if the provider's package is
-            // the same as the component's package. Otherwise, don't send it
-            // because the user specified `provider: someProvider` as shorthand
-            // for `providers: [someProvider]`.
-            const pkg = resource_1.pkgFromType(type);
-            if (pkg && pkg === opts.provider.getPackage()) {
-                sendProvider = true;
+                rejectValue(err);
+                rejectIsKnown(err);
             }
-        }
-        if (sendProvider) {
-            providerRef = yield resource_1.ProviderResource.register(opts.provider);
-        }
-        const providerRefs = new Map();
-        if (remote || !custom) {
-            const componentOpts = opts;
-            resource_1.expandProviders(componentOpts);
-            // the <ProviderResource[]> casts are safe because expandProviders
-            // /always/ leaves providers as an array.
-            if (componentOpts.provider !== undefined) {
-                if (componentOpts.providers === undefined) {
-                    // We still want to do the promotion, so we define providers
-                    componentOpts.providers = [componentOpts.provider];
-                }
-                else if (((_a = componentOpts.providers) === null || _a === void 0 ? void 0 : _a.indexOf(componentOpts.provider)) !== -1) {
-                    const pkg = componentOpts.provider.getPackage();
-                    const message = `There is a conflict between the 'provider' field (${pkg}) and a member of the 'providers' map'. `;
-                    const deprecationd = "This will become an error in a future version. See https://github.com/pulumi/pulumi/issues/8799 for more details";
-                    log.warn(message + deprecationd);
-                }
-                else {
-                    componentOpts.providers.push(componentOpts.provider);
-                }
+            else {
+                resolveValue(v);
+                resolveIsKnown(true);
             }
-            if (componentOpts.providers) {
-                for (const provider of componentOpts.providers) {
-                    const pref = yield resource_1.ProviderResource.register(provider);
-                    if (pref) {
-                        providerRefs.set(provider.getPackage(), pref);
+        };
+    }
+    // If a custom resource, make room for the ID property.
+    let resolveID;
+    if (custom) {
+        let resolveValue;
+        let rejectValue;
+        let resolveIsKnown;
+        let rejectIsKnown;
+        res.id = new output_1.Output(res, debuggable_1.debuggablePromise(new Promise((resolve, reject) => {
+            resolveValue = resolve;
+            rejectValue = reject;
+        }), `resolveID(${label})`), debuggable_1.debuggablePromise(new Promise((resolve, reject) => {
+            resolveIsKnown = resolve;
+            rejectIsKnown = reject;
+        }), `resolveIDIsKnown(${label})`), Promise.resolve(false), Promise.resolve(res));
+        resolveID = (v, isKnown, err) => {
+            if (err) {
+                if (errors_1.isGrpcError(err)) {
+                    if (debuggable_1.debugPromiseLeaks) {
+                        console.error("info: skipped rejection in resolveID");
                     }
+                    return;
                 }
+                rejectValue(err);
+                rejectIsKnown(err);
             }
+            else {
+                resolveValue(v);
+                resolveIsKnown(isKnown);
+            }
+        };
+    }
+    // Now "transfer" all input properties into unresolved Promises on res.  This way,
+    // this resource will look like it has all its output properties to anyone it is
+    // passed to.  However, those promises won't actually resolve until the registerResource
+    // RPC returns
+    const resolvers = rpc_1.transferProperties(res, label, props);
+    /** IMPORTANT!  We should never await prior to this line, otherwise the Resource will be partly uninitialized. */
+    // Before we can proceed, all our dependencies must be finished.
+    const explicitDirectDependencies = new Set(await dependsOn_1.gatherExplicitDependencies(opts.dependsOn));
+    // Serialize out all our props to their final values.  In doing so, we'll also collect all
+    // the Resources pointed to by any Dependency objects we encounter, adding them to 'propertyDependencies'.
+    const [serializedProps, propertyToDirectDependencies] = await rpc_1.serializeResourceProperties(label, props, {
+        // To initially scope the use of this new feature, we only keep output values when
+        // remote is true (for multi-lang components, i.e. MLCs).
+        keepOutputValues: remote,
+        // When remote is true, exclude resource references from 'propertyDependencies'.
+        // This way, component providers creating outputs for component inputs based
+        // on 'propertyDependencies' won't create outputs for properties that only
+        // contain resource references.
+        excludeResourceReferencesFromDependencies: remote,
+    });
+    // Wait for the parent to complete.
+    // If no parent was provided, parent to the root resource.
+    const parentURN = parent ? await parent.urn.promise() : undefined;
+    let importID;
+    if (custom) {
+        const customOpts = opts;
+        importID = customOpts.import;
+    }
+    let providerRef;
+    let sendProvider = custom;
+    if (remote && opts.provider) {
+        // If it's a remote component and a provider was specified, only
+        // send the provider in the request if the provider's package is
+        // the same as the component's package. Otherwise, don't send it
+        // because the user specified `provider: someProvider` as shorthand
+        // for `providers: [someProvider]`.
+        const pkg = resource_1.pkgFromType(type);
+        if (pkg && pkg === opts.provider.getPackage()) {
+            sendProvider = true;
         }
-        // Collect the URNs for explicit/implicit dependencies for the engine so that it can understand
-        // the dependency graph and optimize operations accordingly.
-        // The list of all dependencies (implicit or explicit).
-        const allDirectDependencies = new Set(explicitDirectDependencies);
-        const exclude = new Set([res]);
-        const allDirectDependencyURNs = yield dependsOn_1.getAllTransitivelyReferencedResourceURNs(explicitDirectDependencies, exclude);
-        const propertyToDirectDependencyURNs = new Map();
-        for (const [propertyName, directDependencies] of propertyToDirectDependencies) {
-            addAll(allDirectDependencies, directDependencies);
-            const urns = yield dependsOn_1.getAllTransitivelyReferencedResourceURNs(directDependencies, exclude);
-            addAll(allDirectDependencyURNs, urns);
-            propertyToDirectDependencyURNs.set(propertyName, urns);
-        }
-        const monitorSupportsStructuredAliases = state_1.getStore().supportsAliasSpecs;
-        let computedAliases;
-        if (!monitorSupportsStructuredAliases && parent) {
-            computedAliases = resource_1.allAliases(opts.aliases || [], name, type, parent, parent.__name);
-        }
-        else {
-            computedAliases = opts.aliases || [];
+    }
+    if (sendProvider) {
+        providerRef = await resource_1.ProviderResource.register(opts.provider);
+    }
+    const providerRefs = new Map();
+    if (remote || !custom) {
+        const componentOpts = opts;
+        resource_1.expandProviders(componentOpts);
+        // the <ProviderResource[]> casts are safe because expandProviders
+        // /always/ leaves providers as an array.
+        if (componentOpts.provider !== undefined) {
+            if (componentOpts.providers === undefined) {
+                // We still want to do the promotion, so we define providers
+                componentOpts.providers = [componentOpts.provider];
+            }
+            else if (componentOpts.providers?.indexOf(componentOpts.provider) !== -1) {
+                const pkg = componentOpts.provider.getPackage();
+                const message = `There is a conflict between the 'provider' field (${pkg}) and a member of the 'providers' map'. `;
+                const deprecationd = "This will become an error in a future version. See https://github.com/pulumi/pulumi/issues/8799 for more details";
+                log.warn(message + deprecationd);
+            }
+            else {
+                componentOpts.providers.push(componentOpts.provider);
+            }
         }
-        // Wait for all aliases.
-        const aliases = [];
-        const uniqueAliases = new Set();
-        for (const alias of computedAliases || []) {
-            const aliasVal = yield output_1.output(alias).promise();
-            if (!uniqueAliases.has(aliasVal)) {
-                uniqueAliases.add(aliasVal);
-                aliases.push(aliasVal);
+        if (componentOpts.providers) {
+            for (const provider of componentOpts.providers) {
+                const pref = await resource_1.ProviderResource.register(provider);
+                if (pref) {
+                    providerRefs.set(provider.getPackage(), pref);
+                }
             }
         }
-        const deletedWithURN = (opts === null || opts === void 0 ? void 0 : opts.deletedWith) ? yield opts.deletedWith.urn.promise() : undefined;
-        return {
-            resolveURN: resolveURN,
-            resolveID: resolveID,
-            resolvers: resolvers,
-            serializedProps: serializedProps,
-            parentURN: parentURN,
-            providerRef: providerRef,
-            providerRefs: providerRefs,
-            allDirectDependencyURNs: allDirectDependencyURNs,
-            propertyToDirectDependencyURNs: propertyToDirectDependencyURNs,
-            aliases: aliases,
-            import: importID,
-            monitorSupportsStructuredAliases,
-            deletedWithURN,
-        };
-    });
+    }
+    // Collect the URNs for explicit/implicit dependencies for the engine so that it can understand
+    // the dependency graph and optimize operations accordingly.
+    // The list of all dependencies (implicit or explicit).
+    const allDirectDependencies = new Set(explicitDirectDependencies);
+    const exclude = new Set([res]);
+    const allDirectDependencyURNs = await dependsOn_1.getAllTransitivelyReferencedResourceURNs(explicitDirectDependencies, exclude);
+    const propertyToDirectDependencyURNs = new Map();
+    for (const [propertyName, directDependencies] of propertyToDirectDependencies) {
+        addAll(allDirectDependencies, directDependencies);
+        const urns = await dependsOn_1.getAllTransitivelyReferencedResourceURNs(directDependencies, exclude);
+        addAll(allDirectDependencyURNs, urns);
+        propertyToDirectDependencyURNs.set(propertyName, urns);
+    }
+    const monitorSupportsStructuredAliases = state_1.getStore().supportsAliasSpecs;
+    let computedAliases;
+    if (!monitorSupportsStructuredAliases && parent) {
+        computedAliases = resource_1.allAliases(opts.aliases || [], name, type, parent, parent.__name);
+    }
+    else {
+        computedAliases = opts.aliases || [];
+    }
+    // Wait for all aliases.
+    const aliases = [];
+    const uniqueAliases = new Set();
+    for (const alias of computedAliases || []) {
+        const aliasVal = await output_1.output(alias).promise();
+        if (!uniqueAliases.has(aliasVal)) {
+            uniqueAliases.add(aliasVal);
+            aliases.push(aliasVal);
+        }
+    }
+    const deletedWithURN = opts?.deletedWith ? await opts.deletedWith.urn.promise() : undefined;
+    return {
+        resolveURN: resolveURN,
+        resolveID: resolveID,
+        resolvers: resolvers,
+        serializedProps: serializedProps,
+        parentURN: parentURN,
+        providerRef: providerRef,
+        providerRefs: providerRefs,
+        allDirectDependencyURNs: allDirectDependencyURNs,
+        propertyToDirectDependencyURNs: propertyToDirectDependencyURNs,
+        aliases: aliases,
+        import: importID,
+        monitorSupportsStructuredAliases,
+        deletedWithURN,
+    };
 }
 exports.prepareResource = prepareResource;
 function addAll(to, from) {
@@ -704,31 +692,29 @@ function addAll(to, from) {
  * Finishes a resource creation RPC operation by resolving its outputs to the
  * resulting RPC payload.
  */
-function resolveOutputs(res, t, name, props, outputs, deps, resolvers, err, keepUnknowns) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Produce a combined set of property states, starting with inputs and then applying
-        // outputs.  If the same property exists in the inputs and outputs states, the output wins.
-        const allProps = {};
-        if (outputs) {
-            Object.assign(allProps, rpc_1.deserializeProperties(outputs, keepUnknowns));
-        }
-        const label = `resource:${name}[${t}]#...`;
-        if (!settings_1.isDryRun() || settings_1.isLegacyApplyEnabled()) {
-            for (const key of Object.keys(props)) {
-                if (!allProps.hasOwnProperty(key)) {
-                    // input prop the engine didn't give us a final value for.  Just use the value passed into the resource
-                    // after round-tripping it through serialization. We do the round-tripping primarily s.t. we ensure that
-                    // Output values are handled properly w.r.t. unknowns.
-                    const inputProp = yield rpc_1.serializeProperty(label, props[key], new Set(), { keepOutputValues: false });
-                    if (inputProp === undefined) {
-                        continue;
-                    }
-                    allProps[key] = rpc_1.deserializeProperty(inputProp, keepUnknowns);
+async function resolveOutputs(res, t, name, props, outputs, deps, resolvers, err, keepUnknowns) {
+    // Produce a combined set of property states, starting with inputs and then applying
+    // outputs.  If the same property exists in the inputs and outputs states, the output wins.
+    const allProps = {};
+    if (outputs) {
+        Object.assign(allProps, rpc_1.deserializeProperties(outputs, keepUnknowns));
+    }
+    const label = `resource:${name}[${t}]#...`;
+    if (!settings_1.isDryRun() || settings_1.isLegacyApplyEnabled()) {
+        for (const key of Object.keys(props)) {
+            if (!allProps.hasOwnProperty(key)) {
+                // input prop the engine didn't give us a final value for.  Just use the value passed into the resource
+                // after round-tripping it through serialization. We do the round-tripping primarily s.t. we ensure that
+                // Output values are handled properly w.r.t. unknowns.
+                const inputProp = await rpc_1.serializeProperty(label, props[key], new Set(), { keepOutputValues: false });
+                if (inputProp === undefined) {
+                    continue;
                 }
+                allProps[key] = rpc_1.deserializeProperty(inputProp, keepUnknowns);
             }
         }
-        rpc_1.resolveProperties(res, resolvers, t, name, allProps, deps, err, keepUnknowns);
-    });
+    }
+    rpc_1.resolveProperties(res, resolvers, t, name, allProps, deps, err, keepUnknowns);
 }
 /**
  * Completes a resource registration, attaching an optional set of computed
@@ -741,12 +727,12 @@ function registerResourceOutputs(res, outputs) {
     // never resolve.
     const opLabel = `monitor.registerResourceOutputs(...)`;
     const done = settings_1.rpcKeepAlive();
-    runAsyncResourceOp(opLabel, () => __awaiter(this, void 0, void 0, function* () {
+    runAsyncResourceOp(opLabel, async () => {
         try {
             // The registration could very well still be taking place, so we will need to wait for its URN.
             // Additionally, the output properties might have come from other resources, so we must await those too.
-            const urn = yield res.urn.promise();
-            const resolved = yield rpc_1.serializeProperties(opLabel, { outputs });
+            const urn = await res.urn.promise();
+            const resolved = await rpc_1.serializeProperties(opLabel, { outputs });
             const outputsObj = gstruct.Struct.fromJavaScript(resolved.outputs);
             log.debug(`RegisterResourceOutputs RPC prepared: urn=${urn}` +
                 (settings_1.excessiveDebugOutput ? `, outputs=${JSON.stringify(outputsObj)}` : ``));
@@ -757,7 +743,7 @@ function registerResourceOutputs(res, outputs) {
                 req.setUrn(urn);
                 req.setOutputs(outputsObj);
                 const label = `monitor.registerResourceOutputs(${urn}, ...)`;
-                yield debuggable_1.debuggablePromise(new Promise((resolve, reject) => monitor.registerResourceOutputs(req, (err, innerResponse) => {
+                await debuggable_1.debuggablePromise(new Promise((resolve, reject) => monitor.registerResourceOutputs(req, (err, innerResponse) => {
                     log.debug(`RegisterResourceOutputs RPC finished: urn=${urn}; ` +
                         `err: ${err}, resp: ${innerResponse}`);
                     if (err) {
@@ -781,7 +767,7 @@ function registerResourceOutputs(res, outputs) {
         finally {
             done();
         }
-    }), false);
+    }, false);
 }
 exports.registerResourceOutputs = registerResourceOutputs;
 /**
@@ -803,13 +789,13 @@ function runAsyncResourceOp(label, callback, serial) {
     if (serial === undefined) {
         serial = settings_1.serialize();
     }
-    const resourceOp = rpc_1.suppressUnhandledGrpcRejections(debuggable_1.debuggablePromise(resourceChain.then(() => __awaiter(this, void 0, void 0, function* () {
+    const resourceOp = rpc_1.suppressUnhandledGrpcRejections(debuggable_1.debuggablePromise(resourceChain.then(async () => {
         if (serial) {
             resourceChainLabel = label;
             log.debug(`Resource RPC serialization requested: ${label} is current`);
         }
         return callback();
-    })), label + "-initial"));
+    }), label + "-initial"));
     const finalOp = debuggable_1.debuggablePromise(resourceOp, label + "-final");
     // Set up another promise that propagates the error, if any, so that it triggers unhandled rejection logic.
     resourceOp.catch((err) => Promise.reject(err));