@endo/eventual-send 0.15.5 → 0.16.0

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.16.0](https://github.com/endojs/endo/compare/@endo/eventual-send@0.15.5...@endo/eventual-send@0.16.0) (2022-08-23)
+
+
+### ⚠ BREAKING CHANGES
+
+* **eventual-send:** Disallow using E proxy methods as functions (#1255)
+
+### Bug Fixes
+
+* **eventual-send:** Disallow using E proxy methods as functions ([#1255](https://github.com/endojs/endo/issues/1255)) ([43b7962](https://github.com/endojs/endo/commit/43b796232634b54c9e7de1c0a2349d22c29fc384))
+* typedef default onfulfilled handler for E.when ([c5582ca](https://github.com/endojs/endo/commit/c5582ca7473e0a5d94ef4753ff54e0626cdb1d0a))
+
+
+
 ### [0.15.5](https://github.com/endojs/endo/compare/@endo/eventual-send@0.15.4...@endo/eventual-send@0.15.5) (2022-06-28)
 
 **Note:** Version bump only for package @endo/eventual-send

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@endo/eventual-send",
-  "version": "0.15.5",
+  "version": "0.16.0",
   "description": "Extend a Promise class to implement the eventual-send API",
   "type": "module",
   "main": "src/no-shim.js",
@@ -27,8 +27,8 @@
   },
   "homepage": "https://github.com/endojs/endo#readme",
   "devDependencies": {
-    "@endo/lockdown": "^0.1.15",
-    "@endo/ses-ava": "^0.2.27",
+    "@endo/lockdown": "^0.1.16",
+    "@endo/ses-ava": "^0.2.28",
     "ava": "^3.12.1",
     "c8": "^7.7.3",
     "tsd": "^0.19.1"
@@ -62,5 +62,5 @@
     ],
     "timeout": "2m"
   },
-  "gitHead": "a311acb02115271fbda6953734d0b4f52aa85892"
+  "gitHead": "7dc29059b201826295cbf2deb28bb2ed70f5ec1f"
 }

package/src/E.js

@@ -3,6 +3,8 @@ import { trackTurns } from './track-turns.js';
 
 /// <reference path="index.d.ts" />
 
+const { details: X, quote: q } = assert;
+
 /** @type {ProxyHandler<any>} */
 const baseFreezableProxyHandler = {
   set(_target, _prop, _value) {
@@ -19,6 +21,15 @@ const baseFreezableProxyHandler = {
   },
 };
 
+// E Proxy handlers pretend that any property exists on the target and returns
+// a function for their value. While this function is "bound" by context, it is
+// meant to be called as a method. For that reason, the returned function
+// includes a check that the `this` argument corresponds to the initial
+// receiver when the function was retrieved.
+// E Proxy handlers also forward direct calls to the target in case the remote
+// is a function instead of an object. No such receiver checks are necessary in
+// that case.
+
 /**
  * A Proxy handler for E(x).
  *
@@ -29,8 +40,28 @@ const baseFreezableProxyHandler = {
 function EProxyHandler(x, HandledPromise) {
   return harden({
     ...baseFreezableProxyHandler,
-    get(_target, p, _receiver) {
-      return harden((...args) => HandledPromise.applyMethod(x, p, args));
+    get(_target, p, receiver) {
+      return harden(
+        {
+          // This function purposely checks the `this` value (see above)
+          // In order to be `this` sensitive it is defined using concise method
+          // syntax rather than as an arrow function. To ensure the function
+          // is not constructable, it also avoids the `function` syntax.
+          [p](...args) {
+            if (this !== receiver) {
+              // Reject the async function call
+              return HandledPromise.reject(
+                assert.error(
+                  X`Unexpected receiver for "${p}" method of E(${q(x)})`,
+                ),
+              );
+            }
+
+            return HandledPromise.applyMethod(x, p, args);
+          },
+          // @ts-expect-error https://github.com/microsoft/TypeScript/issues/50319
+        }[p],
+      );
     },
     apply(_target, _thisArg, argArray = []) {
       return HandledPromise.applyFunction(x, argArray);
@@ -53,11 +84,26 @@ function EProxyHandler(x, HandledPromise) {
 function EsendOnlyProxyHandler(x, HandledPromise) {
   return harden({
     ...baseFreezableProxyHandler,
-    get(_target, p, _receiver) {
-      return (...args) => {
-        HandledPromise.applyMethodSendOnly(x, p, args);
-        return undefined;
-      };
+    get(_target, p, receiver) {
+      return harden(
+        {
+          // This function purposely checks the `this` value (see above)
+          // In order to be `this` sensitive it is defined using concise method
+          // syntax rather than as an arrow function. To ensure the function
+          // is not constructable, it also avoids the `function` syntax.
+          [p](...args) {
+            // Throw since the function returns nothing
+            assert.equal(
+              this,
+              receiver,
+              X`Unexpected receiver for "${p}" method of E.sendOnly(${q(x)})`,
+            );
+            HandledPromise.applyMethodSendOnly(x, p, args);
+            return undefined;
+          },
+          // @ts-expect-error https://github.com/microsoft/TypeScript/issues/50319
+        }[p],
+      );
     },
     apply(_target, _thisArg, argsArray = []) {
       HandledPromise.applyFunctionSendOnly(x, argsArray);

package/src/index.d.ts

@@ -257,7 +257,7 @@ interface EProxy {
    * E.when(x, res, rej) is equivalent to
    * HandledPromise.resolve(x).then(res, rej)
    */
-  readonly when: <T, U>(
+  readonly when: <T, U = Awaited<T>>(
     x: T,
     onfulfilled?: (value: Awaited<T>) => ERef<U>,
     onrejected?: (reason: any) => ERef<U>,

package/src/index.test-d.ts

@@ -46,3 +46,26 @@ const foo2 = async (a: FarRef<{ bar(): string; baz: number }>) => {
   // @ts-expect-error - calling directly is valid but not yet in the typedef
   a.bar;
 };
+
+// when
+const aPromise = Promise.resolve('a');
+const onePromise = Promise.resolve(1);
+const remoteString: ERef<string> = Promise.resolve('remote');
+E.when(Promise.all([aPromise, onePromise, remoteString])).then(
+  ([str, num, remote]) => {
+    expectType<string>(str);
+    expectType<number>(num);
+    expectType<string>(remote);
+  },
+);
+E.when(
+  Promise.all([aPromise, onePromise, remoteString]),
+  ([str, num, remote]) => {
+    expectType<string>(str);
+    expectType<number>(num);
+    expectType<string>(remote);
+    return { something: 'new' };
+  },
+).then(result => {
+  expectType<{ something: string }>(result);
+});