@tstdl/base 0.93.117 → 0.93.119

package/rpc/rpc.js

@@ -3,6 +3,7 @@
 import { NotFoundError } from '../errors/not-found.error.js';
 import { NotImplementedError } from '../errors/not-implemented.error.js';
 import { NotSupportedError } from '../errors/not-supported.error.js';
+import { internal } from '../internal.js';
 import { deserialize, registerSerializer, serialize } from '../serializer/index.js';
 import { valueOfType } from '../utils/helpers.js';
 import { hasOwnProperty } from '../utils/object/object.js';
@@ -16,31 +17,31 @@ const adapters = new Map();
 const adapterTargets = new WeakMap();
 const proxyTargets = new WeakSet();
 const exposings = new Map();
+const proxyChannels = new WeakMap();
 const channelFinalizationRegistry = new FinalizationRegistry((data) => data.channel.close());
 class RpcProxy {
 }
-// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
 export const Rpc = {
     listen(endpoint) {
         const controlChannel = endpoint.getChannel('control');
         controlChannel.request$.subscribe(async ({ id: messageId, data: message }) => {
-            switch (message.type) {
-                case 'connect': {
-                    try {
+            try {
+                switch (message.type) {
+                    case 'connect': {
                         const exposing = exposings.get(message.name);
                         if (isUndefined(exposing)) {
                             throw new NotFoundError(`Could not connect to "${message.name}" as nothing with that name is exposed.`);
                         }
                         const value = getAdapterOrProxy(exposing, endpoint);
                         await controlChannel.respond(messageId, value);
+                        break;
                     }
-                    catch (error) {
-                        await controlChannel.respond(messageId, { type: 'throw', error });
-                    }
-                    break;
+                    default:
+                        throw new NotSupportedError(`Message type ${message.type} not supported in listen.`);
                 }
-                default:
-                    throw new NotSupportedError(`Message type ${message.type} not supported in listen.`);
+            }
+            catch (error) {
+                await controlChannel.respond(messageId, { type: 'throw', error: serialize(error) });
             }
         });
     },
@@ -93,10 +94,37 @@ export const Rpc = {
     },
     isProxied(object) {
         return proxyTargets.has(object);
-    }
+    },
+    release(proxy) {
+        const channel = proxyChannels.get(proxy);
+        if (isDefined(channel)) {
+            channel.close();
+            proxyChannels.delete(proxy);
+        }
+    },
+    isAlive(proxy) {
+        const channel = proxyChannels.get(proxy);
+        return isDefined(channel);
+    },
+    async set(proxy, property, value) {
+        await Reflect.set(proxy, property, value);
+    },
+    async delete(proxy, property) {
+        return await Reflect.deleteProperty(proxy, property);
+    },
+    async has(proxy, property) {
+        return await Reflect.has(proxy, property);
+    },
+    reset() {
+        exposings.clear();
+    },
+    [internal]: {
+        parseRpcMessageValue: parseRpcMessageValue,
+        adapters: adapters,
+        RpcProxy: RpcProxy,
+    },
 };
 function createProxy(channel, path = []) {
-    // eslint-disable-next-line prefer-const
     let proxy;
     const { endpoint } = channel;
     const handlers = {
@@ -128,9 +156,25 @@ function createProxy(channel, path = []) {
                 .request({ type: 'set', path: [...path, property], value: postMessageData.value }, postMessageData.transfer)
                 .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
         },
+        deleteProperty(_target, property) {
+            return channel
+                .request({ type: 'deleteProperty', path: [...path, property] })
+                .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+        },
+        defineProperty(_target, property, attributes) {
+            const postMessageData = getPostMessageData(attributes, endpoint);
+            return channel
+                .request({ type: 'defineProperty', path: [...path, property], attributes: postMessageData.value }, postMessageData.transfer)
+                .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+        },
+        has(_target, property) {
+            return channel
+                .request({ type: 'has', path: [...path, property] })
+                .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+        },
         getPrototypeOf() {
             return null;
-        }
+        },
     };
     for (const method of reflectMethods) {
         if (!hasOwnProperty(handlers, method)) {
@@ -172,12 +216,34 @@ function exposeObject(object, channel) {
                     await channel.respond(messageId, postMessageData.value, postMessageData.transfer);
                     break;
                 }
+                case 'deleteProperty': {
+                    const { value } = deref(object, message.path, true);
+                    const result = Reflect.deleteProperty(value, message.path[message.path.length - 1]);
+                    const postMessageData = getPostMessageData(result, endpoint);
+                    await channel.respond(messageId, postMessageData.value, postMessageData.transfer);
+                    break;
+                }
+                case 'defineProperty': {
+                    const { value } = deref(object, message.path, true);
+                    const attributes = parseRpcMessageValue(message.attributes, channel.endpoint);
+                    const result = Reflect.defineProperty(value, message.path[message.path.length - 1], attributes);
+                    const postMessageData = getPostMessageData(result, endpoint);
+                    await channel.respond(messageId, postMessageData.value, postMessageData.transfer);
+                    break;
+                }
+                case 'has': {
+                    const { parent, value } = deref(object, message.path, true);
+                    const result = Reflect.has(parent ?? value, message.path[message.path.length - 1]);
+                    const postMessageData = getPostMessageData(result, endpoint);
+                    await channel.respond(messageId, postMessageData.value, postMessageData.transfer);
+                    break;
+                }
                 default:
                     throw new NotImplementedError(`Unsupported message type ${message.type}.`);
             }
         }
         catch (error) {
-            await channel.respond(messageId, { type: 'throw', error });
+            await channel.respond(messageId, { type: 'throw', error: serialize(error) });
         }
     });
 }
@@ -240,11 +306,18 @@ function parseRpcMessageValue(value, endpoint) {
         }
         case 'throw': {
             const remoteError = new RpcRemoteError(value.error);
-            throw new RpcError(`Received error from remote: ${remoteError.message}`, remoteError);
+            const rpcError = new RpcError(`Received error from remote: ${remoteError.message}`, remoteError);
+            for (const [key, val] of Object.entries(remoteError)) {
+                if (!(key in rpcError)) {
+                    rpcError[key] = val;
+                }
+            }
+            throw rpcError;
         }
         case 'proxy': {
             const channel = endpoint.getChannel(value.channel);
             const proxy = createProxy(channel);
+            proxyChannels.set(proxy, channel);
             channelFinalizationRegistry.register(proxy, { channel });
             return proxy;
         }
@@ -255,6 +328,7 @@ function parseRpcMessageValue(value, endpoint) {
                 throw new NotSupportedError(`No adapter registration for "${value.adapter}" found.`);
             }
             const adaptedValue = adapter.adaptTarget(value.data, channel);
+            proxyChannels.set(adaptedValue, channel);
             channelFinalizationRegistry.register(adaptedValue, { channel });
             return adaptedValue;
         }

package/rpc/tests/rpc.integration.test.d.ts

@@ -0,0 +1 @@
+export {};