@bakit/service 2.0.0 → 3.0.0

package/dist/index.d.ts

@@ -39,6 +39,8 @@ interface BaseClientDriverEvents {
 }
 
 interface BaseServerDriverEvents {
+	listen: [];
+	close: [];
 	message: [connection: unknown, message: Serializable];
 	clientConnect: [connection: unknown];
 	clientDisconnect: [connection: unknown];
@@ -66,8 +68,6 @@ interface IPCServerEvents extends BaseServerDriverEvents {
     clientDisconnect: [socket: Socket];
     clientError: [socket: Socket, error: Error];
     drain: [socket: Socket];
-    listen: [];
-    close: [];
 }
 interface IPCClientEvents extends BaseClientDriverEvents {
 }
@@ -162,12 +162,12 @@ type TransportServerOptions = {
         driver: D;
     } & TransportServerDriverSpecificOptions[D];
 }[TransportDriver];
-interface TransportClient extends TransportClientProtocol, EventBus<TransportEvents> {
+interface TransportClient extends TransportClientProtocol, EventBus<TransportClientEvents> {
     send: BaseServerDriver["send"];
     connect: BaseClientDriver["connect"];
     disconnect: BaseClientDriver["disconnect"];
 }
-interface TransportServer extends TransportServerProtocol, EventBus<TransportEvents> {
+interface TransportServer extends TransportServerProtocol, EventBus<TransportServerEvents> {
     broadcast: BaseServerDriver["broadcast"];
     listen: BaseServerDriver["listen"];
     close: BaseServerDriver["close"];
@@ -193,13 +193,15 @@ type RPCResponseMessage = {
 }, {
     error: RPCErrorPayload;
 }>;
-interface TransportEvents {
+interface TransportClientEvents {
     connect: [];
     disconnect: [];
     error: [error: Error];
-    request: [id: string, method: string];
-    response: [id: string];
-    timeout: [id: string];
+}
+interface TransportServerEvents {
+    listen: [];
+    close: [];
+    error: [error: Error];
     clientConnect: [connection: unknown];
     clientDisconnect: [connection: unknown];
 }
@@ -212,28 +214,32 @@ interface ServiceOptions {
     name: string;
     transport: TransportClientOptions & TransportServerOptions;
 }
-interface ServiceServer {
-    define<F extends ServiceFunction>(method: string, handler: F): Promisify<F>;
-    transport: TransportServer;
-}
-interface ServiceClient {
-    define<F extends ServiceFunction>(method: string, handler: F): Promisify<F>;
-    transport: TransportClient;
-}
 interface Service {
+    readonly name: string;
+    readonly role: ServiceRole;
     define<F extends ServiceFunction>(method: string, handler: F): Promisify<F>;
-    start(): void;
-    stop(): void;
 }
 type ServiceFunction = FunctionLike<any[], Awaitable<any>>;
+declare const ServiceRole: {
+    readonly Client: "client";
+    readonly Server: "server";
+    readonly Unknown: "unknown";
+};
+type ServiceRole = ValueOf<typeof ServiceRole>;
+type ServiceRuntime = {
+    role: "unknown";
+} | {
+    role: "client";
+    transport: TransportClient;
+} | {
+    role: "server";
+    transport: TransportServer;
+};
+interface ServiceInteral {
+    runtime: ServiceRuntime;
+    bind(role: "client" | "server"): void;
+}
 declare function createService(options: ServiceOptions): Service;
-/**
- * Create a service client instance.
- *
- * @param {options} options.
- * @return {ServiceClient} Service client instance.
- */
-declare function createServiceClient(options: ServiceOptions): ServiceClient;
-declare function createServiceServer(options: ServiceOptions): ServiceServer;
+declare function getInteralService(service: Service): ServiceInteral;
 
-export { type BaseClientDriver, type BaseClientDriverEvents, type BaseServerDriver, type BaseServerDriverEvents, DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, type IPCClientEvents, type IPCClientOptions, type IPCServer, type IPCServerEvents, type IPCServerOptions, IPCServerState, type IPCSocketConnection, type IPCSocketConnectionOptions, type IPCSocketMessageHandler, type IPCSocketMessageHandlerOptions, RPCError, type RPCErrorPayload, type RPCHandler, type RPCRequestMessage, type RPCResponseMessage, type Serializable, type Service, type ServiceClient, type ServiceFunction, type ServiceOptions, type ServiceServer, SocketState, type TransportClient, type TransportClientDriverSpecificOptions, type TransportClientOptions, type TransportClientProtocol, TransportDriver, type TransportEvents, type TransportServer, type TransportServerDriverSpecificOptions, type TransportServerOptions, type TransportServerProtocol, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createServiceClient, createServiceServer, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, serializeRPCError };
+export { type BaseClientDriver, type BaseClientDriverEvents, type BaseServerDriver, type BaseServerDriverEvents, DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, type IPCClientEvents, type IPCClientOptions, type IPCServer, type IPCServerEvents, type IPCServerOptions, IPCServerState, type IPCSocketConnection, type IPCSocketConnectionOptions, type IPCSocketMessageHandler, type IPCSocketMessageHandlerOptions, RPCError, type RPCErrorPayload, type RPCHandler, type RPCRequestMessage, type RPCResponseMessage, type Serializable, type Service, type ServiceFunction, type ServiceInteral, type ServiceOptions, ServiceRole, type ServiceRuntime, SocketState, type TransportClient, type TransportClientDriverSpecificOptions, type TransportClientEvents, type TransportClientOptions, type TransportClientProtocol, TransportDriver, type TransportServer, type TransportServerDriverSpecificOptions, type TransportServerEvents, type TransportServerOptions, type TransportServerProtocol, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, getInteralService, serializeRPCError };

package/dist/index.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { existsSync, rmSync } from 'fs';
 import { pack, unpack } from 'msgpackr';
 import PQueue from 'p-queue';
-import { attachEventBus, Collection, isPlainObject, promisify } from '@bakit/utils';
+import { attachEventBus, Collection, isPlainObject } from '@bakit/utils';
 import { randomUUID } from 'crypto';
 
 // src/lib/driver/ipc.ts
@@ -255,7 +255,7 @@ function createTransportServer(options) {
     listen: driver.listen,
     close: driver.close
   }, self = attachEventBus(base);
-  return driver.on("clientConnect", (conn) => self.emit("clientConnect", conn)), driver.on("clientDisconnect", (conn) => self.emit("clientDisconnect", conn)), driver.on("clientError", (_, error) => self.emit("error", error)), self;
+  return driver.on("listen", () => self.emit("listen")), driver.on("clientConnect", (conn) => self.emit("clientConnect", conn)), driver.on("clientDisconnect", (conn) => self.emit("clientDisconnect", conn)), driver.on("clientError", (_, error) => self.emit("error", error)), self;
 }
 function createTransportClientProtocol(driver) {
   let requests = new Collection();
@@ -341,42 +341,60 @@ function createTransportServerProtocol(driver) {
     handle
   };
 }
+var ServiceRole = {
+  Client: "client",
+  Server: "server",
+  Unknown: "unknown"
+}, SERVICE_INTERNAL = Symbol("service-internal");
 function createService(options) {
-  if (process.env.BAKIT_SERVICE_NAME === options.name) {
-    let server = createServiceServer(options);
-    return {
-      define: server.define,
-      start: server.transport.listen,
-      stop: server.transport.close
-    };
-  } else {
-    let client = createServiceClient(options);
-    return {
-      define: client.define,
-      start: client.transport.connect,
-      stop: client.transport.disconnect
-    };
-  }
-}
-function createServiceClient(options) {
-  let transport = createTransportClient(options.transport);
-  function define(method, _handler) {
-    return (...args) => transport.request(method, ...args);
-  }
-  return {
-    define,
-    transport
+  let handlers = new Collection(), runtime = { role: "unknown" }, service = {
+    get name() {
+      return options.name;
+    },
+    get role() {
+      return runtime.role;
+    },
+    define
   };
-}
-function createServiceServer(options) {
-  let transport = createTransportServer(options.transport);
   function define(method, handler) {
-    return transport.handle(method, handler), promisify(handler);
+    if (handlers.has(method))
+      throw new Error(`Service method "${method}" already defined`);
+    return handlers.set(method, handler), (async (...args) => {
+      if (runtime.role === "unknown")
+        throw new Error(`Service "${options.name}" is not bound (method "${method}")`);
+      return runtime.role === "server" ? handler(...args) : runtime.transport.request(method, ...args);
+    });
   }
-  return {
-    define,
-    transport
-  };
+  function bind(role) {
+    if (runtime.role !== "unknown")
+      throw new Error(`Service "${options.name}" already bound`);
+    if (role === "server") {
+      let server = createTransportServer(options.transport);
+      for (let [method, handler] of handlers)
+        server.handle(method, handler);
+      runtime = {
+        role,
+        transport: server
+      }, server.listen();
+    } else if (role === "client") {
+      let client = createTransportClient(options.transport);
+      runtime = {
+        role,
+        transport: client
+      }, client.connect();
+    }
+  }
+  return Object.defineProperty(service, SERVICE_INTERNAL, {
+    value: {
+      get runtime() {
+        return runtime;
+      },
+      bind
+    }
+  }), service;
+}
+function getInteralService(service) {
+  return service[SERVICE_INTERNAL];
 }
 
-export { DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, IPCServerState, RPCError, SocketState, TransportDriver, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createServiceClient, createServiceServer, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, serializeRPCError };
+export { DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, IPCServerState, RPCError, ServiceRole, SocketState, TransportDriver, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, getInteralService, serializeRPCError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakit/service",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Service manager for bakit framework",
   "type": "module",
   "exports": {
@@ -28,14 +28,14 @@
   "author": "louiszn",
   "license": "MIT",
   "dependencies": {
+    "p-queue": "^9.1.0",
     "msgpackr": "^1.11.8",
-    "p-queue": "^9.0.1",
     "type-fest": "^4.41.0",
-    "@bakit/utils": "^2.0.0-alpha.36"
+    "@bakit/utils": "^2.0.0"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "ws": "^8.18.3"
+    "ws": "^8.19.0"
   },
   "scripts": {
     "build": "tsup",