@nmtjs/http-client 0.1.8 → 0.9.0

package/README.md

@@ -1 +1,9 @@
-## HTTP transport for [Neemata](https://github.com/neematajs/neemata)
+# NeemataJS - RPC application server for real-time applications (proof of concept)
+
+### Built with following in mind:
+- transport-agnostic (like WebSockets, WebTransport, .etc)
+- format-agnostic (like JSON, MessagePack, BSON, .etc)
+- binary data streaming and event subscriptions
+- contract-based API
+- end-to-end type safety
+- CPU-intensive task execution on separate workers

package/dist/index.js

@@ -1,79 +1,69 @@
-import { ClientTransport } from '@nmtjs/client';
-import { ErrorCode, TransportType } from '@nmtjs/common';
-export class HttpClient extends ClientTransport {
-    options;
-    type;
-    attempts;
-    constructor(options){
-        super(), this.options = options, this.type = TransportType.HTTP, this.attempts = 0;
-    }
-    async healthCheck() {
-        while(true){
-            try {
-                const signal = AbortSignal.timeout(10000);
-                const url = this.getURL('healthy');
-                const { ok } = await fetch(url, {
-                    signal
-                });
-                if (ok) break;
-            } catch (e) {}
-            this.attempts++;
-            const seconds = Math.min(this.attempts, 15);
-            await new Promise((r)=>setTimeout(r, seconds * 1000));
-        }
-    }
-    async connect() {}
-    async disconnect() {}
-    async rpc(params) {
-        const { service, procedure, payload, signal } = params;
-        const url = this.getURL(`api/${service}/${procedure}`);
-        const body = this.client.format.encode(payload);
-        const response = await fetch(url, {
-            method: 'POST',
-            body,
-            signal,
-            keepalive: true,
-            credentials: 'include',
-            cache: 'no-cache',
-            headers: {
-                'Content-Type': this.client.format.contentType,
-                Accept: this.client.format.contentType,
-                ...this.client.auth ? {
-                    Authorization: this.client.auth
-                } : {}
-            }
-        });
-        if (!response.ok) {
-            return {
-                success: false,
-                error: {
-                    code: ErrorCode.InternalServerError,
-                    data: {
-                        status: response.status,
-                        statusText: response.statusText
-                    },
-                    message: await response.text()
-                }
-            };
-        } else {
-            const buf = await response.arrayBuffer();
-            const { error, result } = this.client.format.decode(buf);
-            if (error) {
-                return {
-                    success: false,
-                    error
-                };
-            } else {
-                return {
-                    success: true,
-                    value: result
-                };
-            }
-        }
-    }
-    getURL(path = '', params = '') {
-        const url = new URL(path, this.options.origin);
-        url.search = params;
-        return url;
-    }
+import { ClientError } from "@nmtjs/client";
+import { EventEmitter, ProtocolServerBlobStream } from "@nmtjs/protocol/client";
+import { ErrorCode, ProtocolBlob } from "@nmtjs/protocol/common";
+export class HttpClientTransport extends EventEmitter {
+	#auth = null;
+	constructor(protocol, options) {
+		super();
+		this.protocol = protocol;
+		this.options = options;
+	}
+	async call(namespace, procedure, payload, options, transformer) {
+		const call = this.protocol.createCall(namespace, procedure, options);
+		const headers = new Headers();
+		headers.set("Content-Type", this.protocol.contentType);
+		headers.set("Accept", this.protocol.contentType);
+		if (this.#auth) headers.set("Authorization", this.#auth);
+		const isBlob = payload instanceof ProtocolBlob;
+		if (isBlob) headers.set("x-neemata-blob", "true");
+		const response = fetch(`${this.options.origin}/api/${namespace}/${procedure}`, {
+			method: "POST",
+			headers,
+			credentials: "include",
+			body: isBlob ? payload.source : transformer.encodeRPC(namespace, procedure, payload),
+			signal: call.signal,
+			duplex: "half"
+		});
+		response.catch((error) => Promise.reject(new Error("Network error", { cause: error }))).then((response) => {
+			const isBlob = response.headers.get("x-neemata-blob") === "true";
+			if (isBlob) {
+				const contentLength = response.headers.get("content-length");
+				const size = contentLength ? Number.parseInt(contentLength) || undefined : undefined;
+				const type = response.headers.get("content-type") || "application/octet-stream";
+				const stream = new ProtocolServerBlobStream(-1, {
+					size,
+					type
+				});
+				response.body?.pipeThrough(stream);
+				return stream;
+			} else {
+				const body = response.arrayBuffer();
+				return body.then((buffer) => {
+					if (response.ok) {
+						const decoded = this.protocol.format.decode(buffer);
+						return transformer.decodeRPC(namespace, procedure, decoded);
+					} else {
+						if (buffer.byteLength === 0) {
+							const error = new ClientError(ErrorCode.InternalServerError, `Empty response with ${response.status} status code`);
+							return Promise.reject(error);
+						} else {
+							const payload = this.protocol.format.decode(buffer);
+							const error = new ClientError(payload.code, payload.message, payload.data);
+							return Promise.reject(error);
+						}
+					}
+				});
+			}
+		}).then(call.resolve).catch(call.reject);
+		return call;
+	}
+	async connect(auth) {
+		this.#auth = auth;
+	}
+	async disconnect() {}
+	async send(messageType, buffer, metadata) {
+		throw new Error("Not supported");
+	}
 }
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../index.ts"],"sourcesContent":["import {\n  ClientTransport,\n  type ClientTransportRpcCall,\n  type ClientTransportRpcResult,\n} from '@nmtjs/client'\nimport { ErrorCode, TransportType } from '@nmtjs/common'\n\nexport type ClientOptions = {\n  /**\n   * The origin of the server\n   * @example 'http://localhost:3000'\n   */\n  origin: string\n  debug?: boolean\n}\n\nexport type HttpRpcOptions = {\n  timeout?: number\n  headers?: Record<string, string>\n  signal?: AbortSignal\n}\n\nexport class HttpClient extends ClientTransport {\n  type = TransportType.HTTP\n  private attempts = 0\n\n  constructor(private readonly options: ClientOptions) {\n    super()\n  }\n\n  async healthCheck() {\n    while (true) {\n      try {\n        const signal = AbortSignal.timeout(10000)\n        const url = this.getURL('healthy')\n        const { ok } = await fetch(url, { signal })\n        if (ok) break\n      } catch (e) {}\n      this.attempts++\n      const seconds = Math.min(this.attempts, 15)\n      await new Promise((r) => setTimeout(r, seconds * 1000))\n    }\n  }\n\n  async connect() {}\n  async disconnect() {}\n\n  async rpc(params: ClientTransportRpcCall): Promise<ClientTransportRpcResult> {\n    const { service, procedure, payload, signal } = params\n    const url = this.getURL(`api/${service}/${procedure}`)\n    const body = this.client.format.encode(payload)\n\n    const response = await fetch(url, {\n      method: 'POST',\n      body,\n      signal,\n      keepalive: true,\n      credentials: 'include',\n      cache: 'no-cache',\n      headers: {\n        'Content-Type': this.client.format.contentType,\n        Accept: this.client.format.contentType,\n        ...(this.client.auth ? { Authorization: this.client.auth } : {}),\n      },\n    })\n\n    if (!response.ok) {\n      return {\n        success: false,\n        error: {\n          code: ErrorCode.InternalServerError,\n          data: { status: response.status, statusText: response.statusText },\n          message: await response.text(),\n        },\n      }\n    } else {\n      const buf = await response.arrayBuffer()\n      const { error, result } = this.client.format.decode(buf)\n      if (error) {\n        return { success: false, error }\n      } else {\n        return { success: true, value: result }\n      }\n    }\n  }\n\n  private getURL(path = '', params = '') {\n    const url = new URL(path, this.options.origin)\n    url.search = params\n    return url\n  }\n}\n"],"names":["ClientTransport","ErrorCode","TransportType","HttpClient","type","attempts","constructor","options","HTTP","healthCheck","signal","AbortSignal","timeout","url","getURL","ok","fetch","e","seconds","Math","min","Promise","r","setTimeout","connect","disconnect","rpc","params","service","procedure","payload","body","client","format","encode","response","method","keepalive","credentials","cache","headers","contentType","Accept","auth","Authorization","success","error","code","InternalServerError","data","status","statusText","message","text","buf","arrayBuffer","result","decode","value","path","URL","origin","search"],"mappings":"AAAA,SACEA,eAAe,QAGV,gBAAe;AACtB,SAASC,SAAS,EAAEC,aAAa,QAAQ,gBAAe;AAiBxD,OAAO,MAAMC,mBAAmBH;;IAC9BI,KAAyB;IACjBC,SAAY;IAEpBC,YAAY,AAAiBC,OAAsB,CAAE;QACnD,KAAK,SADsBA,UAAAA,cAH7BH,OAAOF,cAAcM,IAAI,OACjBH,WAAW;IAInB;IAEA,MAAMI,cAAc;QAClB,MAAO,KAAM;YACX,IAAI;gBACF,MAAMC,SAASC,YAAYC,OAAO,CAAC;gBACnC,MAAMC,MAAM,IAAI,CAACC,MAAM,CAAC;gBACxB,MAAM,EAAEC,EAAE,EAAE,GAAG,MAAMC,MAAMH,KAAK;oBAAEH;gBAAO;gBACzC,IAAIK,IAAI;YACV,EAAE,OAAOE,GAAG,CAAC;YACb,IAAI,CAACZ,QAAQ;YACb,MAAMa,UAAUC,KAAKC,GAAG,CAAC,IAAI,CAACf,QAAQ,EAAE;YACxC,MAAM,IAAIgB,QAAQ,CAACC,IAAMC,WAAWD,GAAGJ,UAAU;QACnD;IACF;IAEA,MAAMM,UAAU,CAAC;IACjB,MAAMC,aAAa,CAAC;IAEpB,MAAMC,IAAIC,MAA8B,EAAqC;QAC3E,MAAM,EAAEC,OAAO,EAAEC,SAAS,EAAEC,OAAO,EAAEpB,MAAM,EAAE,GAAGiB;QAChD,MAAMd,MAAM,IAAI,CAACC,MAAM,CAAC,CAAC,IAAI,EAAEc,QAAQ,CAAC,EAAEC,UAAU,CAAC;QACrD,MAAME,OAAO,IAAI,CAACC,MAAM,CAACC,MAAM,CAACC,MAAM,CAACJ;QAEvC,MAAMK,WAAW,MAAMnB,MAAMH,KAAK;YAChCuB,QAAQ;YACRL;YACArB;YACA2B,WAAW;YACXC,aAAa;YACbC,OAAO;YACPC,SAAS;gBACP,gBAAgB,IAAI,CAACR,MAAM,CAACC,MAAM,CAACQ,WAAW;gBAC9CC,QAAQ,IAAI,CAACV,MAAM,CAACC,MAAM,CAACQ,WAAW;gBACtC,GAAI,IAAI,CAACT,MAAM,CAACW,IAAI,GAAG;oBAAEC,eAAe,IAAI,CAACZ,MAAM,CAACW,IAAI;gBAAC,IAAI,CAAC,CAAC;YACjE;QACF;QAEA,IAAI,CAACR,SAASpB,EAAE,EAAE;YAChB,OAAO;gBACL8B,SAAS;gBACTC,OAAO;oBACLC,MAAM9C,UAAU+C,mBAAmB;oBACnCC,MAAM;wBAAEC,QAAQf,SAASe,MAAM;wBAAEC,YAAYhB,SAASgB,UAAU;oBAAC;oBACjEC,SAAS,MAAMjB,SAASkB,IAAI;gBAC9B;YACF;QACF,OAAO;YACL,MAAMC,MAAM,MAAMnB,SAASoB,WAAW;YACtC,MAAM,EAAET,KAAK,EAAEU,MAAM,EAAE,GAAG,IAAI,CAACxB,MAAM,CAACC,MAAM,CAACwB,MAAM,CAACH;YACpD,IAAIR,OAAO;gBACT,OAAO;oBAAED,SAAS;oBAAOC;gBAAM;YACjC,OAAO;gBACL,OAAO;oBAAED,SAAS;oBAAMa,OAAOF;gBAAO;YACxC;QACF;IACF;IAEQ1C,OAAO6C,OAAO,EAAE,EAAEhC,SAAS,EAAE,EAAE;QACrC,MAAMd,MAAM,IAAI+C,IAAID,MAAM,IAAI,CAACpD,OAAO,CAACsD,MAAM;QAC7ChD,IAAIiD,MAAM,GAAGnC;QACb,OAAOd;IACT;AACF"}
+{"mappings":"AAAA,SAAS,mBAAmB,eAAe;AAC3C,SAEE,cAKA,gCAGK,wBAAwB;AAC/B,SAEE,WACA,oBACK,wBAAwB;AAW/B,OAAO,MAAM,4BACH,aAEV;CACE,QAAuB;CAEvB,YACqBA,UACFC,SACjB;AACA,SAAO;OAHY;OACF;CAGlB;CAED,MAAM,KACJC,WACAC,WACAC,SACAC,SACAC,aAC6B;EAC7B,MAAM,OAAO,KAAK,SAAS,WAAW,WAAW,WAAW,QAAQ;EAEpE,MAAM,UAAU,IAAI;AAEpB,UAAQ,IAAI,gBAAgB,KAAK,SAAS,YAAY;AACtD,UAAQ,IAAI,UAAU,KAAK,SAAS,YAAY;AAEhD,MAAI,KAAKC,MAAO,SAAQ,IAAI,iBAAiB,KAAKA,MAAM;EAExD,MAAM,SAAS,mBAAmB;AAClC,MAAI,OAAQ,SAAQ,IAAI,kBAAkB,OAAO;EAEjD,MAAM,WAAW,OACd,EAAE,KAAK,QAAQ,OAAO,OAAO,UAAU,GAAG,UAAU,GACrD;GACE,QAAQ;GACR;GACA,aAAa;GACb,MAAM,SACF,QAAQ,SACR,YAAY,UAAU,WAAW,WAAW,QAAQ;GACxD,QAAQ,KAAK;GAEb,QAAQ;EACT,EACF;AAED,WACG,MAAM,CAAC,UACN,QAAQ,OAAO,IAAI,MAAM,iBAAiB,EAAE,OAAO,MAAO,GAAE,CAC7D,CACA,KAAK,CAAC,aAAa;GAClB,MAAM,SAAS,SAAS,QAAQ,IAAI,iBAAiB,KAAK;AAC1D,OAAI,QAAQ;IACV,MAAM,gBAAgB,SAAS,QAAQ,IAAI,iBAAiB;IAC5D,MAAM,OAAO,gBACT,OAAO,SAAS,cAAc,IAAI,YAClC;IACJ,MAAM,OACJ,SAAS,QAAQ,IAAI,eAAe,IAAI;IAC1C,MAAM,SAAS,IAAI,0BAA0B,GAAG;KAC9C;KACA;IACD;AACD,aAAS,MAAM,YAAY,OAAO;AAClC,WAAO;GACR,OAAM;IACL,MAAM,OAAO,SAAS,aAAa;AACnC,WAAO,KAAK,KAAK,CAAC,WAAW;AAC3B,SAAI,SAAS,IAAI;MACf,MAAM,UAAU,KAAK,SAAS,OAAO,OAAO,OAAO;AACnD,aAAO,YAAY,UAAU,WAAW,WAAW,QAAQ;KAC5D,OAAM;AACL,UAAI,OAAO,eAAe,GAAG;OAC3B,MAAM,QAAQ,IAAI,YAChB,UAAU,sBACT,sBAAsB,SAAS,OAAO;AAEzC,cAAO,QAAQ,OAAO,MAAM;MAC7B,OAAM;OACL,MAAM,UAAU,KAAK,SAAS,OAAO,OAAO,OAAO;OACnD,MAAM,QAAQ,IAAI,YAChB,QAAQ,MACR,QAAQ,SACR,QAAQ;AAEV,cAAO,QAAQ,OAAO,MAAM;MAC7B;KACF;IACF,EAAC;GACH;EACF,EAAC,CACD,KAAK,KAAK,QAAQ,CAClB,MAAM,KAAK,OAAO;AAErB,SAAO;CACR;CAED,MAAM,QAAQC,MAAW;AACvB,OAAKD,QAAQ;CACd;CAED,MAAM,aAAa,CAAE;CAErB,MAAM,KACJE,aACAC,QACAC,UACA;AACA,QAAM,IAAI,MAAM;CACjB;AACF","names":["protocol: BaseProtocol","options: HttpClientTransportOptions","namespace: string","procedure: string","payload: any","options: ProtocolBaseClientCallOptions","transformer: ProtocolBaseTransformer","#auth","auth: any","messageType: ClientMessageType","buffer: ArrayBuffer","metadata: ProtocolSendMetadata"],"sources":["../src/index.ts"],"sourcesContent":["import { ClientError } from '@nmtjs/client'\nimport {\n  type BaseProtocol,\n  EventEmitter,\n  type ProtocolBaseClientCallOptions,\n  type ProtocolBaseTransformer,\n  type ProtocolClientCall,\n  type ProtocolSendMetadata,\n  ProtocolServerBlobStream,\n  type ProtocolTransport,\n  type ProtocolTransportEventMap,\n} from '@nmtjs/protocol/client'\nimport {\n  type ClientMessageType,\n  ErrorCode,\n  ProtocolBlob,\n} from '@nmtjs/protocol/common'\n\nexport type HttpClientTransportOptions = {\n  /**\n   * The origin of the server\n   * @example 'http://localhost:3000'\n   */\n  origin: string\n  debug?: boolean\n}\n\nexport class HttpClientTransport\n  extends EventEmitter<ProtocolTransportEventMap>\n  implements ProtocolTransport\n{\n  #auth: string | null = null\n\n  constructor(\n    protected readonly protocol: BaseProtocol,\n    private readonly options: HttpClientTransportOptions,\n  ) {\n    super()\n  }\n\n  async call(\n    namespace: string,\n    procedure: string,\n    payload: any,\n    options: ProtocolBaseClientCallOptions,\n    transformer: ProtocolBaseTransformer,\n  ): Promise<ProtocolClientCall> {\n    const call = this.protocol.createCall(namespace, procedure, options)\n\n    const headers = new Headers()\n\n    headers.set('Content-Type', this.protocol.contentType)\n    headers.set('Accept', this.protocol.contentType)\n\n    if (this.#auth) headers.set('Authorization', this.#auth)\n\n    const isBlob = payload instanceof ProtocolBlob\n    if (isBlob) headers.set('x-neemata-blob', 'true')\n\n    const response = fetch(\n      `${this.options.origin}/api/${namespace}/${procedure}`,\n      {\n        method: 'POST',\n        headers,\n        credentials: 'include',\n        body: isBlob\n          ? payload.source\n          : transformer.encodeRPC(namespace, procedure, payload),\n        signal: call.signal,\n        // @ts-expect-error\n        duplex: 'half',\n      },\n    )\n\n    response\n      .catch((error) =>\n        Promise.reject(new Error('Network error', { cause: error })),\n      )\n      .then((response) => {\n        const isBlob = response.headers.get('x-neemata-blob') === 'true'\n        if (isBlob) {\n          const contentLength = response.headers.get('content-length')\n          const size = contentLength\n            ? Number.parseInt(contentLength) || undefined\n            : undefined\n          const type =\n            response.headers.get('content-type') || 'application/octet-stream'\n          const stream = new ProtocolServerBlobStream(-1, {\n            size,\n            type,\n          })\n          response.body?.pipeThrough(stream)\n          return stream\n        } else {\n          const body = response.arrayBuffer()\n          return body.then((buffer) => {\n            if (response.ok) {\n              const decoded = this.protocol.format.decode(buffer)\n              return transformer.decodeRPC(namespace, procedure, decoded)\n            } else {\n              if (buffer.byteLength === 0) {\n                const error = new ClientError(\n                  ErrorCode.InternalServerError,\n                  `Empty response with ${response.status} status code`,\n                )\n                return Promise.reject(error)\n              } else {\n                const payload = this.protocol.format.decode(buffer)\n                const error = new ClientError(\n                  payload.code,\n                  payload.message,\n                  payload.data,\n                )\n                return Promise.reject(error)\n              }\n            }\n          })\n        }\n      })\n      .then(call.resolve)\n      .catch(call.reject)\n\n    return call\n  }\n\n  async connect(auth: any) {\n    this.#auth = auth\n  }\n\n  async disconnect() {}\n\n  async send(\n    messageType: ClientMessageType,\n    buffer: ArrayBuffer,\n    metadata: ProtocolSendMetadata,\n  ) {\n    throw new Error('Not supported')\n  }\n}\n"],"version":3,"file":"index.js"}

package/package.json

@@ -3,28 +3,29 @@
   "type": "module",
   "exports": {
     ".": {
-      "module": "./dist/index.js",
-      "types": "./index.ts"
+      "types": "./src/index.ts",
+      "import": "./dist/index.js"
     }
   },
-  "peerDependencies": {
-    "@nmtjs/common": "^0.4.2",
-    "@nmtjs/client": "^0.4.2"
+  "dependencies": {
+    "@nmtjs/common": "0.9.0",
+    "@nmtjs/protocol": "0.9.0",
+    "@nmtjs/client": "0.9.0"
   },
-  "devDependencies": {
-    "@nmtjs/common": "^0.4.2",
-    "@nmtjs/client": "^0.4.2"
+  "peerDependencies": {
+    "@nmtjs/client": "0.9.0",
+    "@nmtjs/common": "0.9.0",
+    "@nmtjs/protocol": "0.9.0"
   },
   "files": [
-    "index.ts",
+    "src",
     "dist",
-    "tsconfig.json",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.1.8",
+  "version": "0.9.0",
   "scripts": {
-    "build": "neemata-build -p neutral ./index.ts",
+    "build": "neemata-build --root=./src './*.ts'",
     "type-check": "tsc --noEmit"
   }
 }

package/src/index.ts

@@ -0,0 +1,139 @@
+import { ClientError } from '@nmtjs/client'
+import {
+  type BaseProtocol,
+  EventEmitter,
+  type ProtocolBaseClientCallOptions,
+  type ProtocolBaseTransformer,
+  type ProtocolClientCall,
+  type ProtocolSendMetadata,
+  ProtocolServerBlobStream,
+  type ProtocolTransport,
+  type ProtocolTransportEventMap,
+} from '@nmtjs/protocol/client'
+import {
+  type ClientMessageType,
+  ErrorCode,
+  ProtocolBlob,
+} from '@nmtjs/protocol/common'
+
+export type HttpClientTransportOptions = {
+  /**
+   * The origin of the server
+   * @example 'http://localhost:3000'
+   */
+  origin: string
+  debug?: boolean
+}
+
+export class HttpClientTransport
+  extends EventEmitter<ProtocolTransportEventMap>
+  implements ProtocolTransport
+{
+  #auth: string | null = null
+
+  constructor(
+    protected readonly protocol: BaseProtocol,
+    private readonly options: HttpClientTransportOptions,
+  ) {
+    super()
+  }
+
+  async call(
+    namespace: string,
+    procedure: string,
+    payload: any,
+    options: ProtocolBaseClientCallOptions,
+    transformer: ProtocolBaseTransformer,
+  ): Promise<ProtocolClientCall> {
+    const call = this.protocol.createCall(namespace, procedure, options)
+
+    const headers = new Headers()
+
+    headers.set('Content-Type', this.protocol.contentType)
+    headers.set('Accept', this.protocol.contentType)
+
+    if (this.#auth) headers.set('Authorization', this.#auth)
+
+    const isBlob = payload instanceof ProtocolBlob
+    if (isBlob) headers.set('x-neemata-blob', 'true')
+
+    const response = fetch(
+      `${this.options.origin}/api/${namespace}/${procedure}`,
+      {
+        method: 'POST',
+        headers,
+        credentials: 'include',
+        body: isBlob
+          ? payload.source
+          : transformer.encodeRPC(namespace, procedure, payload),
+        signal: call.signal,
+        // @ts-expect-error
+        duplex: 'half',
+      },
+    )
+
+    response
+      .catch((error) =>
+        Promise.reject(new Error('Network error', { cause: error })),
+      )
+      .then((response) => {
+        const isBlob = response.headers.get('x-neemata-blob') === 'true'
+        if (isBlob) {
+          const contentLength = response.headers.get('content-length')
+          const size = contentLength
+            ? Number.parseInt(contentLength) || undefined
+            : undefined
+          const type =
+            response.headers.get('content-type') || 'application/octet-stream'
+          const stream = new ProtocolServerBlobStream(-1, {
+            size,
+            type,
+          })
+          response.body?.pipeThrough(stream)
+          return stream
+        } else {
+          const body = response.arrayBuffer()
+          return body.then((buffer) => {
+            if (response.ok) {
+              const decoded = this.protocol.format.decode(buffer)
+              return transformer.decodeRPC(namespace, procedure, decoded)
+            } else {
+              if (buffer.byteLength === 0) {
+                const error = new ClientError(
+                  ErrorCode.InternalServerError,
+                  `Empty response with ${response.status} status code`,
+                )
+                return Promise.reject(error)
+              } else {
+                const payload = this.protocol.format.decode(buffer)
+                const error = new ClientError(
+                  payload.code,
+                  payload.message,
+                  payload.data,
+                )
+                return Promise.reject(error)
+              }
+            }
+          })
+        }
+      })
+      .then(call.resolve)
+      .catch(call.reject)
+
+    return call
+  }
+
+  async connect(auth: any) {
+    this.#auth = auth
+  }
+
+  async disconnect() {}
+
+  async send(
+    messageType: ClientMessageType,
+    buffer: ArrayBuffer,
+    metadata: ProtocolSendMetadata,
+  ) {
+    throw new Error('Not supported')
+  }
+}

package/index.ts

@@ -1,92 +0,0 @@
-import {
-  ClientTransport,
-  type ClientTransportRpcCall,
-  type ClientTransportRpcResult,
-} from '@nmtjs/client'
-import { ErrorCode, TransportType } from '@nmtjs/common'
-
-export type ClientOptions = {
-  /**
-   * The origin of the server
-   * @example 'http://localhost:3000'
-   */
-  origin: string
-  debug?: boolean
-}
-
-export type HttpRpcOptions = {
-  timeout?: number
-  headers?: Record<string, string>
-  signal?: AbortSignal
-}
-
-export class HttpClient extends ClientTransport {
-  type = TransportType.HTTP
-  private attempts = 0
-
-  constructor(private readonly options: ClientOptions) {
-    super()
-  }
-
-  async healthCheck() {
-    while (true) {
-      try {
-        const signal = AbortSignal.timeout(10000)
-        const url = this.getURL('healthy')
-        const { ok } = await fetch(url, { signal })
-        if (ok) break
-      } catch (e) {}
-      this.attempts++
-      const seconds = Math.min(this.attempts, 15)
-      await new Promise((r) => setTimeout(r, seconds * 1000))
-    }
-  }
-
-  async connect() {}
-  async disconnect() {}
-
-  async rpc(params: ClientTransportRpcCall): Promise<ClientTransportRpcResult> {
-    const { service, procedure, payload, signal } = params
-    const url = this.getURL(`api/${service}/${procedure}`)
-    const body = this.client.format.encode(payload)
-
-    const response = await fetch(url, {
-      method: 'POST',
-      body,
-      signal,
-      keepalive: true,
-      credentials: 'include',
-      cache: 'no-cache',
-      headers: {
-        'Content-Type': this.client.format.contentType,
-        Accept: this.client.format.contentType,
-        ...(this.client.auth ? { Authorization: this.client.auth } : {}),
-      },
-    })
-
-    if (!response.ok) {
-      return {
-        success: false,
-        error: {
-          code: ErrorCode.InternalServerError,
-          data: { status: response.status, statusText: response.statusText },
-          message: await response.text(),
-        },
-      }
-    } else {
-      const buf = await response.arrayBuffer()
-      const { error, result } = this.client.format.decode(buf)
-      if (error) {
-        return { success: false, error }
-      } else {
-        return { success: true, value: result }
-      }
-    }
-  }
-
-  private getURL(path = '', params = '') {
-    const url = new URL(path, this.options.origin)
-    url.search = params
-    return url
-  }
-}

package/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "lib": ["ESNEXT", "DOM"]
-  }
-}