@pulumi/pulumi - npm Package Compare versions

Comparing version 3.121.1-alpha.x0cd3a46 to 3.121.1-alpha.x129270a

package.json

 {
     "name": "@pulumi/pulumi",
-    "version": "3.121.1-alpha.x0cd3a46",
+    "version": "3.121.1-alpha.x129270a",
     "description": "Pulumi's Node.js SDK",
@@ -44,2 +44,3 @@ "license": "Apache-2.0",
     "devDependencies": {
+        "@biomejs/biome": "^1.8.2",
         "@types/ini": "^1.3.31",
@@ -62,3 +63,2 @@ "@types/js-yaml": "^3.12.5",
         "nyc": "^15.1.0",
-        "rome": "^12.1.0",
         "sinon": "^14.0.0",
@@ -87,10 +87,5 @@ "ts-node": "^7.0.1",
     "mocha": {
-        "require": [
-            "ts-node/register",
-            "source-map-support/register"
-        ]
+        "require": ["ts-node/register", "source-map-support/register"]
     },
-    "//": [
-        "NOTE: @types/node is pinned due to grpc/grpc-node#2002"
-    ]
+    "//": ["NOTE: @types/node is pinned due to grpc/grpc-node#2002"]
 }

proto/resource_grpc_pb.d.ts

@@ -25,3 +25,3 @@ // package: pulumirpc
     registerStackTransform: IResourceMonitorService_IRegisterStackTransform;
-    registerProvider: IResourceMonitorService_IRegisterProvider;
+    registerPackage: IResourceMonitorService_IRegisterPackage;
 }
@@ -101,10 +101,10 @@
 }
-interface IResourceMonitorService_IRegisterProvider extends grpc.MethodDefinition<pulumi_resource_pb.RegisterProviderRequest, pulumi_resource_pb.RegisterProviderResponse> {
-    path: "/pulumirpc.ResourceMonitor/RegisterProvider";
+interface IResourceMonitorService_IRegisterPackage extends grpc.MethodDefinition<pulumi_resource_pb.RegisterPackageRequest, pulumi_resource_pb.RegisterPackageResponse> {
+    path: "/pulumirpc.ResourceMonitor/RegisterPackage";
     requestStream: false;
     responseStream: false;
-    requestSerialize: grpc.serialize<pulumi_resource_pb.RegisterProviderRequest>;
-    requestDeserialize: grpc.deserialize<pulumi_resource_pb.RegisterProviderRequest>;
-    responseSerialize: grpc.serialize<pulumi_resource_pb.RegisterProviderResponse>;
-    responseDeserialize: grpc.deserialize<pulumi_resource_pb.RegisterProviderResponse>;
+    requestSerialize: grpc.serialize<pulumi_resource_pb.RegisterPackageRequest>;
+    requestDeserialize: grpc.deserialize<pulumi_resource_pb.RegisterPackageRequest>;
+    responseSerialize: grpc.serialize<pulumi_resource_pb.RegisterPackageResponse>;
+    responseDeserialize: grpc.deserialize<pulumi_resource_pb.RegisterPackageResponse>;
 }
@@ -123,3 +123,3 @@
     registerStackTransform: grpc.handleUnaryCall<pulumi_callback_pb.Callback, google_protobuf_empty_pb.Empty>;
-    registerProvider: grpc.handleUnaryCall<pulumi_resource_pb.RegisterProviderRequest, pulumi_resource_pb.RegisterProviderResponse>;
+    registerPackage: grpc.handleUnaryCall<pulumi_resource_pb.RegisterPackageRequest, pulumi_resource_pb.RegisterPackageResponse>;
 }
@@ -151,5 +151,5 @@
     registerStackTransform(request: pulumi_callback_pb.Callback, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall;
-    registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
-    registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
-    registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
+    registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
+    registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
+    registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
 }
@@ -182,5 +182,5 @@
     public registerStackTransform(request: pulumi_callback_pb.Callback, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall;
-    public registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
-    public registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
-    public registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
+    public registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
+    public registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
+    public registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
 }

proto/resource_grpc_pb.js

@@ -94,5 +94,5 @@ // GENERATED CODE -- DO NOT EDIT!
 
-function serialize_pulumirpc_RegisterProviderRequest(arg) {
-  if (!(arg instanceof pulumi_resource_pb.RegisterProviderRequest)) {
-    throw new Error('Expected argument of type pulumirpc.RegisterProviderRequest');
+function serialize_pulumirpc_RegisterPackageRequest(arg) {
+  if (!(arg instanceof pulumi_resource_pb.RegisterPackageRequest)) {
+    throw new Error('Expected argument of type pulumirpc.RegisterPackageRequest');
   }
@@ -102,9 +102,9 @@ return Buffer.from(arg.serializeBinary());
 
-function deserialize_pulumirpc_RegisterProviderRequest(buffer_arg) {
-  return pulumi_resource_pb.RegisterProviderRequest.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_pulumirpc_RegisterPackageRequest(buffer_arg) {
+  return pulumi_resource_pb.RegisterPackageRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_pulumirpc_RegisterProviderResponse(arg) {
-  if (!(arg instanceof pulumi_resource_pb.RegisterProviderResponse)) {
-    throw new Error('Expected argument of type pulumirpc.RegisterProviderResponse');
+function serialize_pulumirpc_RegisterPackageResponse(arg) {
+  if (!(arg instanceof pulumi_resource_pb.RegisterPackageResponse)) {
+    throw new Error('Expected argument of type pulumirpc.RegisterPackageResponse');
   }
@@ -114,4 +114,4 @@ return Buffer.from(arg.serializeBinary());
 
-function deserialize_pulumirpc_RegisterProviderResponse(buffer_arg) {
-  return pulumi_resource_pb.RegisterProviderResponse.deserializeBinary(new Uint8Array(buffer_arg));
+function deserialize_pulumirpc_RegisterPackageResponse(buffer_arg) {
+  return pulumi_resource_pb.RegisterPackageResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
@@ -287,12 +287,12 @@
   },
-  registerProvider: {
-    path: '/pulumirpc.ResourceMonitor/RegisterProvider',
+  registerPackage: {
+    path: '/pulumirpc.ResourceMonitor/RegisterPackage',
     requestStream: false,
     responseStream: false,
-    requestType: pulumi_resource_pb.RegisterProviderRequest,
-    responseType: pulumi_resource_pb.RegisterProviderResponse,
-    requestSerialize: serialize_pulumirpc_RegisterProviderRequest,
-    requestDeserialize: deserialize_pulumirpc_RegisterProviderRequest,
-    responseSerialize: serialize_pulumirpc_RegisterProviderResponse,
-    responseDeserialize: deserialize_pulumirpc_RegisterProviderResponse,
+    requestType: pulumi_resource_pb.RegisterPackageRequest,
+    responseType: pulumi_resource_pb.RegisterPackageResponse,
+    requestSerialize: serialize_pulumirpc_RegisterPackageRequest,
+    requestDeserialize: deserialize_pulumirpc_RegisterPackageRequest,
+    responseSerialize: serialize_pulumirpc_RegisterPackageResponse,
+    responseDeserialize: deserialize_pulumirpc_RegisterPackageResponse,
   },
@@ -299,0 +299,0 @@ };

proto/resource_pb.d.ts

@@ -243,2 +243,4 @@ // package: pulumirpc
     setSupportsresultreporting(value: boolean): RegisterResourceRequest;
+    getPackage(): string;
+    setPackage(value: string): RegisterResourceRequest;
 
@@ -292,2 +294,3 @@ serializeBinary(): Uint8Array;
         supportsresultreporting: boolean,
+        pb_package: string,
     }
@@ -717,9 +720,9 @@
 
-export class RegisterProviderRequest extends jspb.Message { 
+export class RegisterPackageRequest extends jspb.Message { 
     getName(): string;
-    setName(value: string): RegisterProviderRequest;
+    setName(value: string): RegisterPackageRequest;
     getVersion(): string;
-    setVersion(value: string): RegisterProviderRequest;
+    setVersion(value: string): RegisterPackageRequest;
     getPluginDownloadUrl(): string;
-    setPluginDownloadUrl(value: string): RegisterProviderRequest;
+    setPluginDownloadUrl(value: string): RegisterPackageRequest;
 
@@ -731,16 +734,16 @@ getPluginChecksumsMap(): jspb.Map<string, Uint8Array | string>;
     clearParameter(): void;
-    getParameter(): ProviderParameter | undefined;
-    setParameter(value?: ProviderParameter): RegisterProviderRequest;
+    getParameter(): PackageParameter | undefined;
+    setParameter(value?: PackageParameter): RegisterPackageRequest;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): RegisterProviderRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: RegisterProviderRequest): RegisterProviderRequest.AsObject;
+    toObject(includeInstance?: boolean): RegisterPackageRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: RegisterPackageRequest): RegisterPackageRequest.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: RegisterProviderRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): RegisterProviderRequest;
-    static deserializeBinaryFromReader(message: RegisterProviderRequest, reader: jspb.BinaryReader): RegisterProviderRequest;
+    static serializeBinaryToWriter(message: RegisterPackageRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RegisterPackageRequest;
+    static deserializeBinaryFromReader(message: RegisterPackageRequest, reader: jspb.BinaryReader): RegisterPackageRequest;
 }
 
-export namespace RegisterProviderRequest {
+export namespace RegisterPackageRequest {
     export type AsObject = {
@@ -752,21 +755,21 @@ name: string,
         pluginChecksumsMap: Array<[string, Uint8Array | string]>,
-        parameter?: ProviderParameter.AsObject,
+        parameter?: PackageParameter.AsObject,
     }
 }
 
-export class RegisterProviderResponse extends jspb.Message { 
+export class RegisterPackageResponse extends jspb.Message { 
     getRef(): string;
-    setRef(value: string): RegisterProviderResponse;
+    setRef(value: string): RegisterPackageResponse;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): RegisterProviderResponse.AsObject;
-    static toObject(includeInstance: boolean, msg: RegisterProviderResponse): RegisterProviderResponse.AsObject;
+    toObject(includeInstance?: boolean): RegisterPackageResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: RegisterPackageResponse): RegisterPackageResponse.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: RegisterProviderResponse, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): RegisterProviderResponse;
-    static deserializeBinaryFromReader(message: RegisterProviderResponse, reader: jspb.BinaryReader): RegisterProviderResponse;
+    static serializeBinaryToWriter(message: RegisterPackageResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RegisterPackageResponse;
+    static deserializeBinaryFromReader(message: RegisterPackageResponse, reader: jspb.BinaryReader): RegisterPackageResponse;
 }
 
-export namespace RegisterProviderResponse {
+export namespace RegisterPackageResponse {
     export type AsObject = {
@@ -777,7 +780,7 @@ ref: string,
 
-export class ProviderParameter extends jspb.Message { 
+export class PackageParameter extends jspb.Message { 
     getName(): string;
-    setName(value: string): ProviderParameter;
+    setName(value: string): PackageParameter;
     getVersion(): string;
-    setVersion(value: string): ProviderParameter;
+    setVersion(value: string): PackageParameter;
 
@@ -787,15 +790,15 @@ hasValue(): boolean;
     getValue(): google_protobuf_struct_pb.Value | undefined;
-    setValue(value?: google_protobuf_struct_pb.Value): ProviderParameter;
+    setValue(value?: google_protobuf_struct_pb.Value): PackageParameter;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): ProviderParameter.AsObject;
-    static toObject(includeInstance: boolean, msg: ProviderParameter): ProviderParameter.AsObject;
+    toObject(includeInstance?: boolean): PackageParameter.AsObject;
+    static toObject(includeInstance: boolean, msg: PackageParameter): PackageParameter.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: ProviderParameter, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): ProviderParameter;
-    static deserializeBinaryFromReader(message: ProviderParameter, reader: jspb.BinaryReader): ProviderParameter;
+    static serializeBinaryToWriter(message: PackageParameter, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): PackageParameter;
+    static deserializeBinaryFromReader(message: PackageParameter, reader: jspb.BinaryReader): PackageParameter;
 }
 
-export namespace ProviderParameter {
+export namespace PackageParameter {
     export type AsObject = {
@@ -802,0 +805,0 @@ name: string,

provider/server.js

@@ -39,2 +39,3 @@ "use strict";
 const settings = __importStar(require("../runtime/settings"));
+const localState = __importStar(require("../runtime/state"));
 const internals_1 = require("./internals");
@@ -50,7 +51,19 @@ const anyproto = __importStar(require("google-protobuf/google/protobuf/any_pb"));
     constructor(engineAddr, provider, uncaughtErrors) {
-        /** Queue of construct calls. */
-        this.constructCallQueue = Promise.resolve();
+        this._callbacks = new Map();
         this.engineAddr = engineAddr;
         this.provider = provider;
         this.uncaughtErrors = uncaughtErrors;
+        // When we catch an uncaught error, we need to respond to the inflight call/construct gRPC requests
+        // with the error to avoid a hang.
+        const uncaughtHandler = (err) => {
+            if (!this.uncaughtErrors.has(err)) {
+                this.uncaughtErrors.add(err);
+            }
+            // terminate the outstanding gRPC requests.
+            this._callbacks.forEach((callback) => callback(err, undefined));
+        };
+        process.on("uncaughtException", uncaughtHandler);
+        // @ts-ignore 'unhandledRejection' will almost always invoke uncaughtHandler with an Error. so
+        // just suppress the TS strictness here.
+        process.on("unhandledRejection", uncaughtHandler);
     }
@@ -261,83 +274,60 @@ // Misc. methods
         return __awaiter(this, void 0, void 0, function* () {
-            // Serialize invocations of `construct` and `call` so that each call runs one after another, avoiding concurrent
-            // runs. We do this because `construct` and `call` modify global state to reset the SDK's runtime options.
-            // This is a short-term workaround to provide correctness, but likely isn't sustainable long-term due to the
-            // limits it places on parallelism. We will likely want to investigate if it's possible to run each invocation
-            // in its own context, possibly using Node's `createContext` API to avoid modifying global state:
-            // https://nodejs.org/api/vm.html#vm_vm_createcontext_contextobject_options
-            const res = this.constructCallQueue.then(() => this.constructImpl(call, callback));
-            /* eslint-disable no-empty,no-empty-function,@typescript-eslint/no-empty-function */
-            this.constructCallQueue = res.catch(() => { });
-            return res;
-        });
-    }
-    constructImpl(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // given that construct calls are serialized, we can attach an uncaught handler to pick up exceptions
-            // in underlying user code. When we catch the error, we need to respond to the gRPC request with the error
-            // to avoid a hang.
-            const uncaughtHandler = (err) => {
-                if (!this.uncaughtErrors.has(err)) {
-                    this.uncaughtErrors.add(err);
+            // Setup a new async state store for this run
+            const store = new localState.LocalStore();
+            return localState.asyncLocalStorage.run(store, () => __awaiter(this, void 0, void 0, function* () {
+                const callbackId = Symbol("id");
+                this._callbacks.set(callbackId, callback);
+                try {
+                    const req = call.request;
+                    const type = req.getType();
+                    const name = req.getName();
+                    if (!this.provider.construct) {
+                        callback(new Error(`unknown resource type ${type}`), undefined);
+                        return;
+                    }
+                    yield configureRuntime(req, this.engineAddr);
+                    const inputs = yield deserializeInputs(req.getInputs(), req.getInputdependenciesMap());
+                    // Rebuild the resource options.
+                    const dependsOn = [];
+                    for (const urn of req.getDependenciesList()) {
+                        dependsOn.push(new resource.DependencyResource(urn));
+                    }
+                    const providers = {};
+                    const rpcProviders = req.getProvidersMap();
+                    if (rpcProviders) {
+                        for (const [pkg, ref] of rpcProviders.entries()) {
+                            providers[pkg] = createProviderResource(ref);
+                        }
+                    }
+                    const opts = {
+                        aliases: req.getAliasesList(),
+                        dependsOn: dependsOn,
+                        protect: req.getProtect(),
+                        providers: providers,
+                        parent: req.getParent() ? new resource.DependencyResource(req.getParent()) : undefined,
+                    };
+                    const result = yield this.provider.construct(name, type, inputs, opts);
+                    const resp = new provproto.ConstructResponse();
+                    resp.setUrn(yield output_1.output(result.urn).promise());
+                    const [state, stateDependencies] = yield rpc.serializeResourceProperties(`construct(${type}, ${name})`, result.state);
+                    const stateDependenciesMap = resp.getStatedependenciesMap();
+                    for (const [key, resources] of stateDependencies) {
+                        const deps = new provproto.ConstructResponse.PropertyDependencies();
+                        deps.setUrnsList(yield Promise.all(Array.from(resources).map((r) => r.urn.promise())));
+                        stateDependenciesMap.set(key, deps);
+                    }
+                    resp.setState(structproto.Struct.fromJavaScript(state));
+                    // Wait for RPC operations to complete.
+                    yield settings.waitForRPCs();
+                    callback(undefined, resp);
                 }
-                // bubble the uncaught error in the user code back and terminate the outstanding gRPC request.
-                callback(err, undefined);
-            };
-            process.on("uncaughtException", uncaughtHandler);
-            // @ts-ignore 'unhandledRejection' will almost always invoke uncaughtHandler with an Error. so
-            // just suppress the TS strictness here.
-            process.on("unhandledRejection", uncaughtHandler);
-            try {
-                const req = call.request;
-                const type = req.getType();
-                const name = req.getName();
-                if (!this.provider.construct) {
-                    callback(new Error(`unknown resource type ${type}`), undefined);
-                    return;
+                catch (e) {
+                    console.error(`${e}: ${e.stack}`);
+                    callback(e, undefined);
                 }
-                yield configureRuntime(req, this.engineAddr);
-                const inputs = yield deserializeInputs(req.getInputs(), req.getInputdependenciesMap());
-                // Rebuild the resource options.
-                const dependsOn = [];
-                for (const urn of req.getDependenciesList()) {
-                    dependsOn.push(new resource.DependencyResource(urn));
+                finally {
+                    // remove the gRPC callback context from the map of in-flight callbacks
+                    this._callbacks.delete(callbackId);
                 }
-                const providers = {};
-                const rpcProviders = req.getProvidersMap();
-                if (rpcProviders) {
-                    for (const [pkg, ref] of rpcProviders.entries()) {
-                        providers[pkg] = createProviderResource(ref);
-                    }
-                }
-                const opts = {
-                    aliases: req.getAliasesList(),
-                    dependsOn: dependsOn,
-                    protect: req.getProtect(),
-                    providers: providers,
-                    parent: req.getParent() ? new resource.DependencyResource(req.getParent()) : undefined,
-                };
-                const result = yield this.provider.construct(name, type, inputs, opts);
-                const resp = new provproto.ConstructResponse();
-                resp.setUrn(yield output_1.output(result.urn).promise());
-                const [state, stateDependencies] = yield rpc.serializeResourceProperties(`construct(${type}, ${name})`, result.state);
-                const stateDependenciesMap = resp.getStatedependenciesMap();
-                for (const [key, resources] of stateDependencies) {
-                    const deps = new provproto.ConstructResponse.PropertyDependencies();
-                    deps.setUrnsList(yield Promise.all(Array.from(resources).map((r) => r.urn.promise())));
-                    stateDependenciesMap.set(key, deps);
-                }
-                resp.setState(structproto.Struct.fromJavaScript(state));
-                // Wait for RPC operations to complete.
-                yield settings.waitForRPCs();
-                callback(undefined, resp);
-            }
-            catch (e) {
-                console.error(`${e}: ${e.stack}`);
-                callback(e, undefined);
-            }
-            finally {
-                // remove these uncaught handlers that are specific to this gRPC callback context
-                process.off("uncaughtException", uncaughtHandler);
-                process.off("unhandledRejection", uncaughtHandler);
-            }
+            }));
         });
@@ -347,73 +337,50 @@ }
         return __awaiter(this, void 0, void 0, function* () {
-            // Serialize invocations of `construct` and `call` so that each call runs one after another, avoiding concurrent
-            // runs. We do this because `construct` and `call` modify global state to reset the SDK's runtime options.
-            // This is a short-term workaround to provide correctness, but likely isn't sustainable long-term due to the
-            // limits it places on parallelism. We will likely want to investigate if it's possible to run each invocation
-            // in its own context, possibly using Node's `createContext` API to avoid modifying global state:
-            // https://nodejs.org/api/vm.html#vm_vm_createcontext_contextobject_options
-            const res = this.constructCallQueue.then(() => this.callImpl(call, callback));
-            /* eslint-disable no-empty, no-empty-function, @typescript-eslint/no-empty-function */
-            this.constructCallQueue = res.catch(() => { });
-            return res;
-        });
-    }
-    callImpl(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // given that call calls are serialized, we can attach an uncaught handler to pick up exceptions
-            // in underlying user code. When we catch the error, we need to respond to the gRPC request with the error
-            // to avoid a hang.
-            const uncaughtHandler = (err) => {
-                if (!this.uncaughtErrors.has(err)) {
-                    this.uncaughtErrors.add(err);
+            // Setup a new async state store for this run
+            const store = new localState.LocalStore();
+            return localState.asyncLocalStorage.run(store, () => __awaiter(this, void 0, void 0, function* () {
+                const callbackId = Symbol("id");
+                this._callbacks.set(callbackId, callback);
+                try {
+                    const req = call.request;
+                    if (!this.provider.call) {
+                        callback(new Error(`unknown function ${req.getTok()}`), undefined);
+                        return;
+                    }
+                    yield configureRuntime(req, this.engineAddr);
+                    const args = yield deserializeInputs(req.getArgs(), req.getArgdependenciesMap());
+                    const result = yield this.provider.call(req.getTok(), args);
+                    const resp = new provproto.CallResponse();
+                    if (result.outputs) {
+                        const [ret, retDependencies] = yield rpc.serializeResourceProperties(`call(${req.getTok()})`, result.outputs);
+                        const returnDependenciesMap = resp.getReturndependenciesMap();
+                        for (const [key, resources] of retDependencies) {
+                            const deps = new provproto.CallResponse.ReturnDependencies();
+                            deps.setUrnsList(yield Promise.all(Array.from(resources).map((r) => r.urn.promise())));
+                            returnDependenciesMap.set(key, deps);
+                        }
+                        resp.setReturn(structproto.Struct.fromJavaScript(ret));
+                    }
+                    if ((result.failures || []).length !== 0) {
+                        const failureList = [];
+                        for (const f of result.failures) {
+                            const failure = new provproto.CheckFailure();
+                            failure.setProperty(f.property);
+                            failure.setReason(f.reason);
+                            failureList.push(failure);
+                        }
+                        resp.setFailuresList(failureList);
+                    }
+                    // Wait for RPC operations to complete.
+                    yield settings.waitForRPCs();
+                    callback(undefined, resp);
                 }
-                // bubble the uncaught error in the user code back and terminate the outstanding gRPC request.
-                callback(err, undefined);
-            };
-            process.on("uncaughtException", uncaughtHandler);
-            // @ts-ignore 'unhandledRejection' will almost always invoke uncaughtHandler with an Error. so
-            // just suppress the TS strictness here.
-            process.on("unhandledRejection", uncaughtHandler);
-            try {
-                const req = call.request;
-                if (!this.provider.call) {
-                    callback(new Error(`unknown function ${req.getTok()}`), undefined);
-                    return;
+                catch (e) {
+                    console.error(`${e}: ${e.stack}`);
+                    callback(e, undefined);
                 }
-                yield configureRuntime(req, this.engineAddr);
-                const args = yield deserializeInputs(req.getArgs(), req.getArgdependenciesMap());
-                const result = yield this.provider.call(req.getTok(), args);
-                const resp = new provproto.CallResponse();
-                if (result.outputs) {
-                    const [ret, retDependencies] = yield rpc.serializeResourceProperties(`call(${req.getTok()})`, result.outputs);
-                    const returnDependenciesMap = resp.getReturndependenciesMap();
-                    for (const [key, resources] of retDependencies) {
-                        const deps = new provproto.CallResponse.ReturnDependencies();
-                        deps.setUrnsList(yield Promise.all(Array.from(resources).map((r) => r.urn.promise())));
-                        returnDependenciesMap.set(key, deps);
-                    }
-                    resp.setReturn(structproto.Struct.fromJavaScript(ret));
+                finally {
+                    // remove the gRPC callback context from the map of in-flight callbacks
+                    this._callbacks.delete(callbackId);
                 }
-                if ((result.failures || []).length !== 0) {
-                    const failureList = [];
-                    for (const f of result.failures) {
-                        const failure = new provproto.CheckFailure();
-                        failure.setProperty(f.property);
-                        failure.setReason(f.reason);
-                        failureList.push(failure);
-                    }
-                    resp.setFailuresList(failureList);
-                }
-                // Wait for RPC operations to complete.
-                yield settings.waitForRPCs();
-                callback(undefined, resp);
-            }
-            catch (e) {
-                console.error(`${e}: ${e.stack}`);
-                callback(e, undefined);
-            }
-            finally {
-                // remove these uncaught handlers that are specific to this gRPC callback context
-                process.off("uncaughtException", uncaughtHandler);
-                process.off("unhandledRejection", uncaughtHandler);
-            }
+            }));
         });
@@ -420,0 +387,0 @@ }

runtime/callbacks.js

@@ -340,8 +340,13 @@ "use strict";
             .then((req) => {
-            this._monitor.registerStackTransform(req, (err, _) => {
-                if (err !== null) {
-                    // Remove this from the list of callbacks given we didn't manage to actually register it.
-                    this._callbacks.delete(req.getToken());
-                    return;
-                }
+            return new Promise((resolve, reject) => {
+                this._monitor.registerStackTransform(req, (err, _) => {
+                    if (err !== null) {
+                        // Remove this from the list of callbacks given we didn't manage to actually register it.
+                        this._callbacks.delete(req.getToken());
+                        reject();
+                    }
+                    else {
+                        resolve();
+                    }
+                });
             });
@@ -348,0 +353,0 @@ }, (err) => log.error(`failed to register stack transform: ${err}`))

tests/automation/data/tcfg/tsconfig.json

@@ -15,5 +15,3 @@ {
     },
-    "files": [
-        "index.ts"
-    ]
+    "files": ["index.ts"]
 }

tests/runtime/langhost/cases/067.native_es_module/package.json

@@ -1,1 +0,1 @@
-{ "type": "module" }
+{ "type": "module" }

tests/runtime/langhost/cases/068.remote_component_providers/package.json

 {
-  "type": "module"
+    "type": "module"
 }

version.js

@@ -16,3 +16,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.version = "3.121.1-alpha.x0cd3a46";
+exports.version = "3.121.1-alpha.x129270a";
 //# sourceMappingURL=version.js.map

No alert changes

Worsened metrics

Total package byte prevSize

14576289

decreased by-0.01%

Lines of code

129528

No dependency changes