@zlink-systems/framework 0.11.0 → 0.12.0

package/dist/runtime/backend/node/node-socket-backend-adapter.js

@@ -1,45 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapSocket = wrapSocket;
+exports.nodeEventLoopPollerOf = nodeEventLoopPollerOf;
 exports.disconnectStreamPeer = disconnectStreamPeer;
-exports.isDisconnectRouteNotFoundError = isDisconnectRouteNotFoundError;
 exports.isEndpointCloseIgnorableError = isEndpointCloseIgnorableError;
 const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
-function wrapSocket(nativeInstance) {
-    const boundEndpoints = new Set();
-    const connectedEndpoints = new Set();
-    const peerRoutingIds = new Set();
+const node_event_loop_poller_1 = require("./node-event-loop-poller");
+const eventLoopPollers = new WeakMap();
+function wrapSocket(nativeInstance, pollCompletion) {
     const socket = nativeInstance;
     const hasRequest = typeof nativeInstance.request === 'function';
     const hasRoutedPeer = hasRequest
         && typeof nativeInstance.reply === 'function';
     const hasStream = typeof nativeInstance.recvPacket === 'function';
+    const eventLoopPoller = pollCompletion === undefined
+        ? undefined
+        : new node_event_loop_poller_1.ZLinkNodeEventLoopPoller(nativeInstance, pollCompletion, () => { });
     const adapter = {
         nativeInstance,
         async dispose() {
+            eventLoopPoller?.dispose();
             (0, node_backend_adapter_support_1.disableSocketLinger)(nativeInstance);
-            closeSocketRoutes(nativeInstance, peerRoutingIds);
-            closeSocketEndpoints(nativeInstance, boundEndpoints, connectedEndpoints);
             await (0, node_backend_adapter_support_1.closeWithBusyRetry)(nativeInstance);
         },
         close() {
+            eventLoopPoller?.dispose();
             nativeInstance.close();
         },
         bind(endpoint) {
             nativeInstance.bind(endpoint);
-            boundEndpoints.add(endpoint);
         },
         unbind(endpoint) {
             nativeInstance.unbind(endpoint);
-            boundEndpoints.delete(endpoint);
         },
         connect(endpoint) {
             nativeInstance.connect(endpoint);
-            connectedEndpoints.add(endpoint);
         },
         disconnect(endpoint) {
             nativeInstance.disconnect(endpoint);
-            connectedEndpoints.delete(endpoint);
         },
         setChannelName(channelName) {
             const setChannelName = nativeInstance.setChannelName;
@@ -103,14 +101,12 @@ function wrapSocket(nativeInstance) {
         send(...args) {
             if (hasStream) {
                 const [routingId, payload] = args;
-                peerRoutingIds.add(routingId);
                 const operation = nativeInstance.send((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId));
                 (0, node_backend_adapter_support_1.submitBindingSyncSend)(operation, payload);
                 return true;
             }
             if (hasRoutedPeer) {
                 const [routingId, payload] = args;
-                peerRoutingIds.add(routingId);
                 return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(nativeInstance
                     .send((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId)), payload);
             }
@@ -128,14 +124,12 @@ function wrapSocket(nativeInstance) {
         submit(routingId, payload, _timeoutMs) {
             if (!hasStream)
                 throw new TypeError('Async stream send requires a STREAM socket.');
-            peerRoutingIds.add(routingId);
             return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(nativeInstance
                 .send((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId)), payload);
         },
         request(...args) {
             if (hasRoutedPeer) {
                 const [routingId, payload, timeoutMs] = args;
-                peerRoutingIds.add(routingId);
                 return (0, node_backend_adapter_support_1.submitBindingRequest)(nativeInstance
                     .request((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId)), payload, timeoutMs);
             }
@@ -147,7 +141,6 @@ function wrapSocket(nativeInstance) {
         },
         reply(...args) {
             const [routingId, replyToken, payload] = args;
-            peerRoutingIds.add(routingId);
             const operation = nativeInstance.reply((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId), replyToken);
             return args.length < 3 ? operation : (0, node_backend_adapter_support_1.submitBindingReply)(operation, payload);
         },
@@ -210,8 +203,17 @@ function wrapSocket(nativeInstance) {
             return false;
         }
     };
+    if (eventLoopPoller !== undefined)
+        eventLoopPollers.set(adapter, eventLoopPoller);
     return adapter;
 }
+function nodeEventLoopPollerOf(socket) {
+    const poller = eventLoopPollers.get(socket);
+    if (poller === undefined) {
+        throw new TypeError('Node backend socket does not own an event-loop poller.');
+    }
+    return poller;
+}
 function disconnectStreamPeer(socket, routingId) {
     try {
         socket.disconnectRid((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId));
@@ -229,57 +231,6 @@ function requireSocketOptions(socket) {
     }
     return socket.options;
 }
-function closeSocketRoutes(target, peerRoutingIds) {
-    if (peerRoutingIds.size === 0 || !hasDisconnectRid(target)) {
-        return;
-    }
-    for (const routingId of peerRoutingIds) {
-        try {
-            target.disconnectRid((0, node_backend_adapter_support_1.toNativeRoutingId)(routingId));
-        }
-        catch (error) {
-            if (!isDisconnectRouteNotFoundError(error)) {
-                throw error;
-            }
-        }
-        peerRoutingIds.delete(routingId);
-    }
-}
-function isDisconnectRouteNotFoundError(error) {
-    return (0, node_backend_adapter_support_1.isBindingNotFound)(error) || (0, node_backend_adapter_support_1.isContextTerminatedError)(error) || (error instanceof Error && 'code' in error &&
-        (error.code === node_backend_adapter_support_1.zlink.ConnectResult.NotFound ||
-            error.code === node_backend_adapter_support_1.zlink.ConnectResult.Busy ||
-            (error.code === node_backend_adapter_support_1.zlink.ConnectResult.InternalError &&
-                /current state/i.test(error.message))));
-}
-function hasDisconnectRid(target) {
-    return target !== null && typeof target === 'object' && 'disconnectRid' in target &&
-        typeof target.disconnectRid === 'function';
-}
-function closeSocketEndpoints(target, boundEndpoints, connectedEndpoints) {
-    for (const endpoint of connectedEndpoints) {
-        try {
-            target.disconnect(endpoint);
-        }
-        catch (error) {
-            if (!isEndpointCloseIgnorableError(error)) {
-                throw error;
-            }
-        }
-        connectedEndpoints.delete(endpoint);
-    }
-    for (const endpoint of boundEndpoints) {
-        try {
-            target.unbind(endpoint);
-        }
-        catch (error) {
-            if (!isEndpointCloseIgnorableError(error)) {
-                throw error;
-            }
-        }
-        boundEndpoints.delete(endpoint);
-    }
-}
 function isEndpointCloseIgnorableError(error) {
     return (0, node_backend_adapter_support_1.isContextTerminatedError)(error) || (error instanceof Error && 'code' in error &&
         (error.code === 604 || error.code === node_backend_adapter_support_1.zlink.ConnectResult.NotFound));

package/dist/runtime/backend/raw-binding-port.d.ts

@@ -19,6 +19,7 @@ export interface ZLinkRawMonitorRecord {
     readonly flags?: number;
 }
 export interface ZLinkRawSocketPort {
+    setReadableHandler(handler: () => void): void;
     bind(endpoint: string): void;
     unbind(endpoint: string): void;
     connect(endpoint: string): void;

package/dist/runtime/backend/runtime-values.d.ts

@@ -47,9 +47,13 @@ export declare function isZLinkBackendResultError(error: unknown): error is ZLin
 export declare function isBackendNotConnectedError(error: unknown): boolean;
 export declare function isBackendRequestTimeoutError(error: unknown): boolean;
 export type ZLinkBackendMessageLike = Message | Buffer | Uint8Array | string;
+/** Binding의 SendSubmission과 구조적으로 호환된다. binding 타입을 import 하지 않는다. */
+export interface ZLinkBackendSendSubmission {
+    readonly admitted: Promise<void>;
+}
 export interface ZLinkBackendSendSubmitBuilder {
     message(message: ZLinkBackendMessageLike): ZLinkBackendSendSubmitBuilder;
-    submit(): Promise<void>;
+    submit(): ZLinkBackendSendSubmission;
 }
 export interface ZLinkBackendSendBuilder {
     message(message: ZLinkBackendMessageLike): ZLinkBackendSendSubmitBuilder;

package/dist/runtime/channels/channel-dispatchers.js

@@ -33,7 +33,7 @@ class ZLinkChannelRequestDispatcher {
             if (received.send === undefined) {
                 throw new configuration_1.ZLinkConfigurationException('Routed SPOT packet is missing a local SPOT delivery context.');
             }
-            await (0, channel_multipart_1.appendParts)(received.send(), received.parts).submit();
+            await (0, channel_multipart_1.appendParts)(received.send(), received.parts).submit().admitted;
             return true;
         }
         if (received.parts.length === 0 || received.parts[0].data().length === 0) {
@@ -354,7 +354,7 @@ class ZLinkRoutePacketDispatcher {
             if (received.send === undefined) {
                 throw new configuration_1.ZLinkConfigurationException('Routed SPOT packet is missing a local SPOT delivery context.');
             }
-            return (0, channel_multipart_1.appendParts)(received.send(), received.parts).submit();
+            return (0, channel_multipart_1.appendParts)(received.send(), received.parts).submit().admitted;
         }
         return false;
     }