@hile/micro 2.0.15 → 3.0.0

package/dist/client.d.ts

@@ -1,4 +1,5 @@
 import { MessageWs } from "@hile/message-ws";
+import { type ContextData, type ContextInput } from '@hile/context';
 import { Server } from './server.js';
 import { WebSocket } from 'ws';
 import { EventEmitter } from 'node:events';
@@ -8,6 +9,15 @@ export interface ClientProps {
     server: Server;
     ws: WebSocket;
 }
+export type MicroMessageMetadata = {
+    context?: ContextInput<ContextData>;
+    [key: string]: unknown;
+};
+export type MicroMessage<T = any> = {
+    url: string;
+    data: T;
+    metadata?: MicroMessageMetadata;
+};
 export declare class Client extends MessageWs {
     private readonly server;
     private readonly socket;
@@ -20,10 +30,7 @@ export declare class Client extends MessageWs {
     readonly events: EventEmitter<any>;
     constructor(props: ClientProps);
     private startHeartbeat;
-    protected exec(data: {
-        url: string;
-        data: any;
-    }): Promise<any>;
+    protected exec(data: MicroMessage): Promise<any>;
     request<T = any>(url: string, data: any, options?: {
         timeout?: number;
         signal?: AbortSignal;

package/dist/client.js

@@ -1,6 +1,52 @@
 import { MessageWs } from "@hile/message-ws";
+import { isContextData, runWithContext, snapshotContext, } from '@hile/context';
 import { WebSocket } from 'ws';
 import { EventEmitter } from 'node:events';
+function createEnvelope(url, data) {
+    const context = snapshotContext();
+    if (Object.keys(context).length === 0)
+        return { url, data };
+    return {
+        url,
+        data,
+        metadata: {
+            context,
+        },
+    };
+}
+function getEnvelopeContext(data) {
+    const context = data.metadata?.context;
+    if (!isContextData(context))
+        return undefined;
+    return context;
+}
+function isAsyncIterable(value) {
+    return value != null && typeof value[Symbol.asyncIterator] === 'function';
+}
+function bindAsyncIterableToContext(iterable, context) {
+    return {
+        [Symbol.asyncIterator]() {
+            const iterator = iterable[Symbol.asyncIterator]();
+            return {
+                next() {
+                    return Promise.resolve(runWithContext(context, () => iterator.next()));
+                },
+                return(value) {
+                    if (!iterator.return) {
+                        return Promise.resolve({ done: true, value });
+                    }
+                    return Promise.resolve(runWithContext(context, () => iterator.return(value)));
+                },
+                throw(error) {
+                    if (!iterator.throw) {
+                        return Promise.reject(error);
+                    }
+                    return Promise.resolve(runWithContext(context, () => iterator.throw(error)));
+                },
+            };
+        },
+    };
+}
 export class Client extends MessageWs {
     server;
     socket;
@@ -48,24 +94,35 @@ export class Client extends MessageWs {
         }
         if (!this._online)
             throw new Error('Client is not online');
-        return this.server.dispatch(data.url, data.data, {
-            client: this,
-        });
+        const context = getEnvelopeContext(data);
+        const dispatch = async () => {
+            const result = await this.server.dispatch(data.url, data.data, {
+                client: this,
+                metadata: data.metadata,
+            });
+            if (context && isAsyncIterable(result)) {
+                return bindAsyncIterableToContext(result, context);
+            }
+            return result;
+        };
+        if (context)
+            return runWithContext(context, dispatch);
+        return dispatch();
     }
     request(url, data, options) {
         if (!this._online)
             throw new Error('Client is not online');
-        return this._send({ url, data }, options);
+        return this._send(createEnvelope(url, data), options);
     }
     push(url, data, options) {
         if (!this._online)
             throw new Error('Client is not online');
-        return this._push({ url, data }, options);
+        return this._push(createEnvelope(url, data), options);
     }
     stream(url, data, options) {
         if (!this._online)
             throw new Error('Client is not online');
-        return this._stream({ url, data }, options);
+        return this._stream(createEnvelope(url, data), options);
     }
     dispose() {
         if (this.heartbeatTimer)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hile/micro",
-  "version": "2.0.15",
+  "version": "3.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -23,11 +23,13 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@hile/logger": "workspace:^",
-    "@hile/message-loader": "workspace:^",
-    "@hile/message-ws": "workspace:^",
+    "@hile/context": "^3.0.1",
+    "@hile/logger": "^2.1.1",
+    "@hile/message-loader": "^2.1.1",
+    "@hile/message-ws": "^2.1.1",
     "internal-ip": "^9.0.0",
     "ws": "^8.21.0",
     "yaml": "^2.9.0"
-  }
+  },
+  "gitHead": "14b55afba0e9af80a782eaa84f6f48c1e66861a1"
 }