@bakit/service 3.0.0 → 3.2.0

package/dist/index.d.ts

@@ -22,6 +22,7 @@ interface BaseClientDriver extends EventBus<BaseClientDriverEvents> {
 	send(message: Serializable): void;
 	connect(): void;
 	disconnect(): void;
+	readonly ready: boolean;
 }
 
 interface BaseServerDriver extends EventBus<BaseServerDriverEvents> {
@@ -85,6 +86,7 @@ interface IPCSocketConnection extends EventBus<IPCClientEvents>, IPCSocketMessag
     reconnect: () => void;
     write: (chunk: Buffer) => void;
     readonly state: SocketState;
+    readonly ready: boolean;
 }
 interface IPCSocketMessageHandler extends BaseClientDriver {
     handleData: (chunk: Buffer) => void;
@@ -166,6 +168,7 @@ interface TransportClient extends TransportClientProtocol, EventBus<TransportCli
     send: BaseServerDriver["send"];
     connect: BaseClientDriver["connect"];
     disconnect: BaseClientDriver["disconnect"];
+    readonly ready: boolean;
 }
 interface TransportServer extends TransportServerProtocol, EventBus<TransportServerEvents> {
     broadcast: BaseServerDriver["broadcast"];
@@ -217,29 +220,37 @@ interface ServiceOptions {
 interface Service {
     readonly name: string;
     readonly role: ServiceRole;
+    initialize?: FunctionLike<[], Awaitable<void>>;
+    onReady?: FunctionLike<[], Awaitable<void>>;
     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";
-    readonly Unknown: "unknown";
 };
 type ServiceRole = ValueOf<typeof ServiceRole>;
-type ServiceRuntime = {
-    role: "unknown";
-} | {
-    role: "client";
+interface ServiceClientRuntime {
+    role: typeof ServiceRole.Client;
     transport: TransportClient;
-} | {
-    role: "server";
+}
+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;
 }
 declare function createService(options: ServiceOptions): Service;
-declare function getInteralService(service: Service): ServiceInteral;
+declare function startServiceServer(service: Service): Promise<void>;
+declare function assertRuntimeClient(service: Service, runtime: MutableRuntime): asserts runtime is ServiceClientRuntime;
+declare function assertRuntimeServer(service: Service, runtime: MutableRuntime): asserts runtime is ServiceServerRuntime;
+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 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 };
+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, assertRuntimeClient, assertRuntimeServer, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, getInternalService, serializeRPCError, startServiceServer };

package/dist/index.js

@@ -104,6 +104,9 @@ function createIPCSocketConnection(socketPath, options = {}) {
     write,
     get state() {
       return state;
+    },
+    get ready() {
+      return state === SocketState.Connected;
     }
   });
   function connect() {
@@ -239,7 +242,10 @@ function createTransportClient(options) {
     ...createTransportClientProtocol(driver),
     send: driver.send,
     connect: driver.connect,
-    disconnect: driver.disconnect
+    disconnect: driver.disconnect,
+    get ready() {
+      return driver.ready;
+    }
   }, self = attachEventBus(base);
   return driver.on("connect", () => self.emit("connect")), driver.on("disconnect", () => self.emit("disconnect")), driver.on("error", (error) => self.emit("error", error)), self;
 }
@@ -343,8 +349,7 @@ function createTransportServerProtocol(driver) {
 }
 var ServiceRole = {
   Client: "client",
-  Server: "server",
-  Unknown: "unknown"
+  Server: "server"
 }, SERVICE_INTERNAL = Symbol("service-internal");
 function createService(options) {
   let handlers = new Collection(), runtime = { role: "unknown" }, service = {
@@ -352,6 +357,8 @@ function createService(options) {
       return options.name;
     },
     get role() {
+      if (runtime.role === "unknown")
+        throw new Error(`Service "${options.name}" is not bound`);
       return runtime.role;
     },
     define
@@ -360,11 +367,14 @@ function createService(options) {
     if (handlers.has(method))
       throw new Error(`Service method "${method}" already defined`);
     return handlers.set(method, handler), (async (...args) => {
-      if (runtime.role === "unknown")
+      if (ensureClientBound(), 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 runtime.role === "server" ? handler(...args) : (assertRuntimeClient(service, runtime), runtime.transport.request(method, ...args));
     });
   }
+  function ensureClientBound() {
+    runtime.role !== "unknown" || process.env.BAKIT_SERVICE_NAME === options.name || (bind(ServiceRole.Client), assertRuntimeClient(service, runtime), runtime.transport.ready || runtime.transport.connect());
+  }
   function bind(role) {
     if (runtime.role !== "unknown")
       throw new Error(`Service "${options.name}" already bound`);
@@ -372,29 +382,41 @@ function createService(options) {
       let server = createTransportServer(options.transport);
       for (let [method, handler] of handlers)
         server.handle(method, handler);
-      runtime = {
-        role,
-        transport: server
-      }, server.listen();
+      runtime.role = "server", runtime.transport = server;
     } else if (role === "client") {
       let client = createTransportClient(options.transport);
-      runtime = {
-        role,
-        transport: client
-      }, client.connect();
+      runtime.role = "client", runtime.transport = client;
     }
   }
   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 getInteralService(service) {
+async function startServiceServer(service) {
+  let internal = getInternalService(service);
+  return internal.bind(ServiceRole.Server), await service.initialize?.(), await new Promise((resolve) => {
+    assertRuntimeServer(service, internal.runtime), internal.runtime.transport.once("listen", async () => {
+      resolve(), await service.onReady?.();
+    }), internal.runtime.transport.listen();
+  });
+}
+function assertRuntimeClient(service, runtime) {
+  if (runtime.role !== "client")
+    throw new Error(`Service "${service.name}" is not a client`);
+}
+function assertRuntimeServer(service, runtime) {
+  if (runtime.role !== "server")
+    throw new Error(`Service "${service.name}" is not a server`);
+}
+function getInternalService(service) {
   return service[SERVICE_INTERNAL];
 }
 
-export { DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, IPCServerState, RPCError, ServiceRole, SocketState, TransportDriver, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, getInteralService, serializeRPCError };
+export { DEFAULT_IPC_SOCKET_CONNECTION_OPTIONS, IPCServerState, RPCError, ServiceRole, SocketState, TransportDriver, assertRuntimeClient, assertRuntimeServer, createIPCClient, createIPCServer, createIPCSocketConnection, createIPCSocketMessageHandler, createService, createTransportClient, createTransportClientProtocol, createTransportServer, createTransportServerProtocol, deserializeRPCError, getIPCPath, getInternalService, serializeRPCError, startServiceServer };

package/package.json

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