@bakit/service 2.0.1 → 3.1.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,35 @@ interface ServiceOptions {
     name: string;
     transport: TransportClientOptions & TransportServerOptions;
 }
-interface ServiceServer {
+interface Service {
+    readonly name: string;
+    readonly role: ServiceRole;
     define<F extends ServiceFunction>(method: string, handler: F): Promisify<F>;
-    transport: TransportServer;
 }
-interface ServiceClient {
-    define<F extends ServiceFunction>(method: string, handler: F): Promisify<F>;
+type ServiceFunction = FunctionLike<any[], Awaitable<any>>;
+declare const ServiceRole: {
+    readonly Client: "client";
+    readonly Server: "server";
+};
+type ServiceRole = ValueOf<typeof ServiceRole>;
+interface ServiceClientRuntime {
+    role: typeof ServiceRole.Client;
     transport: TransportClient;
 }
-interface Service {
-    define<F extends ServiceFunction>(method: string, handler: F): Promisify<F>;
-    start(): void;
-    stop(): void;
+interface ServiceServerRuntime {
+    role: typeof ServiceRole.Server;
+    transport: TransportServer;
+}
+type ServiceRuntime = ServiceClientRuntime | ServiceServerRuntime;
+interface MutableRuntime {
+    role: ServiceRole | "unknown";
+    transport?: TransportClient | TransportServer;
+}
+interface ServiceInteral {
+    runtime: ServiceRuntime;
+    bind(role: "client" | "server"): void;
 }
-type ServiceFunction = FunctionLike<any[], Awaitable<any>>;
 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 getInternalService(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, type MutableRuntime, RPCError, type RPCErrorPayload, type RPCHandler, type RPCRequestMessage, type RPCResponseMessage, type Serializable, type Service, type ServiceClientRuntime, type ServiceFunction, type ServiceInteral, type ServiceOptions, ServiceRole, type ServiceRuntime, type ServiceServerRuntime, 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, getInternalService, 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,64 @@ function createTransportServerProtocol(driver) {
     handle
   };
 }
+var ServiceRole = {
+  Client: "client",
+  Server: "server"
+}, 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() {
+      if (runtime.role === "unknown")
+        throw new Error(`Service "${options.name}" is not bound`);
+      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 (ensureClientBound(), runtime.role === "unknown")
+        throw new Error(`Service "${options.name}" is not bound (method "${method}")`);
+      return runtime.role === "server" ? handler(...args) : (assertClient(runtime), runtime.transport.request(method, ...args));
+    });
   }
-  return {
-    define,
-    transport
-  };
+  function ensureClientBound() {
+    runtime.role !== "unknown" || process.env.BAKIT_SERVICE_NAME === options.name || bind(ServiceRole.Client);
+  }
+  function assertClient(runtime2) {
+    if (runtime2.role !== "client")
+      throw new Error(`Service "${options.name}" is not a client`);
+  }
+  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 = "server", runtime.transport = server, server.listen();
+    } else if (role === "client") {
+      let client = createTransportClient(options.transport);
+      runtime.role = "client", runtime.transport = client, client.connect();
+    }
+  }
+  return Object.defineProperty(service, SERVICE_INTERNAL, {
+    value: {
+      get runtime() {
+        if (runtime.role === "unknown")
+          throw new Error(`Service "${options.name}" is not bound`);
+        return runtime;
+      },
+      bind
+    }
+  }), service;
+}
+function getInternalService(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, getInternalService, serializeRPCError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakit/service",
-  "version": "2.0.1",
+  "version": "3.1.0",
   "description": "Service manager for bakit framework",
   "type": "module",
   "exports": {