@fuman/bun 0.0.1

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2024 alina sireneva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

package/connection.cjs

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const io = require("@fuman/io");
+const net = require("@fuman/net");
+const utils = require("@fuman/utils");
+class TcpConnection {
+  socket;
+  #error = null;
+  #recvBuffer = io.Bytes.alloc(1024 * 16);
+  #sendBuffer = new utils.Deque();
+  #cv = new utils.ConditionVariable();
+  #endpoint;
+  async connect(endpoint, tls = false) {
+    this.socket = await Bun.connect({
+      hostname: endpoint.address,
+      port: endpoint.port,
+      socket: {
+        data: this._handleData.bind(this),
+        error: this._handleError.bind(this),
+        close: this._handleClose.bind(this),
+        drain: this._handleDrain.bind(this)
+      },
+      tls
+    });
+    this.#endpoint = endpoint;
+  }
+  static from(socket) {
+    const conn = new TcpConnection();
+    conn.socket = socket;
+    return conn;
+  }
+  _handleData(_, data) {
+    this.#recvBuffer.writeSync(data.length).set(data);
+    this.#cv.notify();
+  }
+  _handleError(_, error) {
+    this.#error = error;
+    this.#cv.notify();
+  }
+  _handleClose() {
+    this.#error = new net.ConnectionClosedError();
+    this.#cv.notify();
+    for (const [, deferred] of this.#sendBuffer) {
+      deferred.reject(this.#error);
+    }
+  }
+  _handleDrain() {
+    while (!this.#sendBuffer.isEmpty()) {
+      const [chunk, deferred] = this.#sendBuffer.popFront();
+      const written = this.socket.write(chunk);
+      if (written < chunk.length) {
+        this.#sendBuffer.pushFront([chunk.subarray(written), deferred]);
+        break;
+      }
+      deferred.resolve();
+    }
+  }
+  async read(into) {
+    if (this.#recvBuffer.available > 0) {
+      const size2 = Math.min(this.#recvBuffer.available, into.length);
+      into.set(this.#recvBuffer.readSync(size2));
+      this.#recvBuffer.reclaim();
+      return size2;
+    }
+    if (this.#error != null) throw this.#error;
+    await this.#cv.wait();
+    if (this.#error != null) throw this.#error;
+    const size = Math.min(this.#recvBuffer.available, into.length);
+    into.set(this.#recvBuffer.readSync(size));
+    this.#recvBuffer.reclaim();
+    return size;
+  }
+  async write(bytes) {
+    if (this.#error) throw this.#error;
+    const written = this.socket.write(bytes);
+    if (written < bytes.length) {
+      const deferred = new utils.Deferred();
+      this.#sendBuffer.pushBack([bytes.subarray(written), deferred]);
+      return deferred.promise;
+    }
+  }
+  close() {
+    this.socket.end();
+    this._handleClose();
+  }
+  get localAddress() {
+    const isIpv6 = this.socket.remoteAddress.includes(":");
+    return {
+      address: isIpv6 ? "::1" : "127.0.0.1",
+      port: this.socket.localPort
+    };
+  }
+  get remoteAddress() {
+    if (this.#endpoint) return this.#endpoint;
+    return {
+      address: this.socket.remoteAddress,
+      get port() {
+        throw new Error("Not available in Bun");
+      }
+    };
+  }
+  setKeepAlive(_val) {
+    throw new Error("Not available in Bun");
+  }
+  setNoDelay(_val) {
+    throw new Error("Not available in Bun");
+  }
+  getAlpnProtocol() {
+    throw new Error("Not available in Bun");
+  }
+}
+exports.TcpConnection = TcpConnection;

package/connection.d.ts

@@ -0,0 +1,20 @@
+import { ITcpConnection, ITlsConnection, TcpEndpoint } from '@fuman/net';
+import { Socket } from 'bun';
+export declare class TcpConnection implements ITcpConnection, ITlsConnection {
+    #private;
+    readonly socket: Socket<any>;
+    connect(endpoint: TcpEndpoint, tls?: boolean): Promise<void>;
+    static from(socket: Socket<any>): TcpConnection;
+    _handleData(_: unknown, data: Buffer): void;
+    _handleError(_: unknown, error: Error): void;
+    _handleClose(): void;
+    _handleDrain(): void;
+    read(into: Uint8Array): Promise<number>;
+    write(bytes: Uint8Array): Promise<void>;
+    close(): void;
+    get localAddress(): TcpEndpoint;
+    get remoteAddress(): TcpEndpoint;
+    setKeepAlive(_val: boolean): void;
+    setNoDelay(_val: boolean): void;
+    getAlpnProtocol(): string | null;
+}

package/connection.js

@@ -0,0 +1,112 @@
+import { Bytes } from "@fuman/io";
+import { ConnectionClosedError } from "@fuman/net";
+import { Deque, ConditionVariable, Deferred } from "@fuman/utils";
+class TcpConnection {
+  socket;
+  #error = null;
+  #recvBuffer = Bytes.alloc(1024 * 16);
+  #sendBuffer = new Deque();
+  #cv = new ConditionVariable();
+  #endpoint;
+  async connect(endpoint, tls = false) {
+    this.socket = await Bun.connect({
+      hostname: endpoint.address,
+      port: endpoint.port,
+      socket: {
+        data: this._handleData.bind(this),
+        error: this._handleError.bind(this),
+        close: this._handleClose.bind(this),
+        drain: this._handleDrain.bind(this)
+      },
+      tls
+    });
+    this.#endpoint = endpoint;
+  }
+  static from(socket) {
+    const conn = new TcpConnection();
+    conn.socket = socket;
+    return conn;
+  }
+  _handleData(_, data) {
+    this.#recvBuffer.writeSync(data.length).set(data);
+    this.#cv.notify();
+  }
+  _handleError(_, error) {
+    this.#error = error;
+    this.#cv.notify();
+  }
+  _handleClose() {
+    this.#error = new ConnectionClosedError();
+    this.#cv.notify();
+    for (const [, deferred] of this.#sendBuffer) {
+      deferred.reject(this.#error);
+    }
+  }
+  _handleDrain() {
+    while (!this.#sendBuffer.isEmpty()) {
+      const [chunk, deferred] = this.#sendBuffer.popFront();
+      const written = this.socket.write(chunk);
+      if (written < chunk.length) {
+        this.#sendBuffer.pushFront([chunk.subarray(written), deferred]);
+        break;
+      }
+      deferred.resolve();
+    }
+  }
+  async read(into) {
+    if (this.#recvBuffer.available > 0) {
+      const size2 = Math.min(this.#recvBuffer.available, into.length);
+      into.set(this.#recvBuffer.readSync(size2));
+      this.#recvBuffer.reclaim();
+      return size2;
+    }
+    if (this.#error != null) throw this.#error;
+    await this.#cv.wait();
+    if (this.#error != null) throw this.#error;
+    const size = Math.min(this.#recvBuffer.available, into.length);
+    into.set(this.#recvBuffer.readSync(size));
+    this.#recvBuffer.reclaim();
+    return size;
+  }
+  async write(bytes) {
+    if (this.#error) throw this.#error;
+    const written = this.socket.write(bytes);
+    if (written < bytes.length) {
+      const deferred = new Deferred();
+      this.#sendBuffer.pushBack([bytes.subarray(written), deferred]);
+      return deferred.promise;
+    }
+  }
+  close() {
+    this.socket.end();
+    this._handleClose();
+  }
+  get localAddress() {
+    const isIpv6 = this.socket.remoteAddress.includes(":");
+    return {
+      address: isIpv6 ? "::1" : "127.0.0.1",
+      port: this.socket.localPort
+    };
+  }
+  get remoteAddress() {
+    if (this.#endpoint) return this.#endpoint;
+    return {
+      address: this.socket.remoteAddress,
+      get port() {
+        throw new Error("Not available in Bun");
+      }
+    };
+  }
+  setKeepAlive(_val) {
+    throw new Error("Not available in Bun");
+  }
+  setNoDelay(_val) {
+    throw new Error("Not available in Bun");
+  }
+  getAlpnProtocol() {
+    throw new Error("Not available in Bun");
+  }
+}
+export {
+  TcpConnection
+};

package/functions.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const connection = require("./connection.cjs");
+const listener = require("./listener.cjs");
+const connectTcp = async (endpoint) => {
+  const connection$1 = new connection.TcpConnection();
+  await connection$1.connect(endpoint);
+  return connection$1;
+};
+const connectTls = async (opts) => {
+  if (opts.sni != null) {
+    throw new Error(".sni is not available in Bun");
+  }
+  if (opts.caCerts) {
+    throw new Error(".caCerts is not available in Bun");
+  }
+  if (opts.alpnProtocols) {
+    throw new Error(".alpnProtocols is not available in Bun");
+  }
+  const connection$1 = new connection.TcpConnection();
+  await connection$1.connect(opts, true);
+  return connection$1;
+};
+const listenTcp = async (address) => {
+  const listener$1 = new listener.TcpListener();
+  listener$1.listen(address);
+  return listener$1;
+};
+exports.connectTcp = connectTcp;
+exports.connectTls = connectTls;
+exports.listenTcp = listenTcp;

package/functions.d.ts

@@ -0,0 +1,5 @@
+import { ConnectFunction, IListener, ListenFunction, TcpEndpoint, TlsConnectOptions } from '@fuman/net';
+import { TcpConnection } from './connection.js';
+export declare const connectTcp: ConnectFunction<TcpEndpoint, TcpConnection>;
+export declare const connectTls: ConnectFunction<TlsConnectOptions, TcpConnection>;
+export declare const listenTcp: ListenFunction<TcpEndpoint, IListener<TcpEndpoint>>;

package/functions.js

@@ -0,0 +1,31 @@
+import { TcpConnection } from "./connection.js";
+import { TcpListener } from "./listener.js";
+const connectTcp = async (endpoint) => {
+  const connection = new TcpConnection();
+  await connection.connect(endpoint);
+  return connection;
+};
+const connectTls = async (opts) => {
+  if (opts.sni != null) {
+    throw new Error(".sni is not available in Bun");
+  }
+  if (opts.caCerts) {
+    throw new Error(".caCerts is not available in Bun");
+  }
+  if (opts.alpnProtocols) {
+    throw new Error(".alpnProtocols is not available in Bun");
+  }
+  const connection = new TcpConnection();
+  await connection.connect(opts, true);
+  return connection;
+};
+const listenTcp = async (address) => {
+  const listener = new TcpListener();
+  listener.listen(address);
+  return listener;
+};
+export {
+  connectTcp,
+  connectTls,
+  listenTcp
+};

package/index.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const connection = require("./connection.cjs");
+const functions = require("./functions.cjs");
+const listener = require("./listener.cjs");
+exports.TcpConnection = connection.TcpConnection;
+exports.connectTcp = functions.connectTcp;
+exports.connectTls = functions.connectTls;
+exports.listenTcp = functions.listenTcp;
+exports.TcpListener = listener.TcpListener;

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './connection.js';
+export * from './functions.js';
+export * from './listener.js';

package/index.js

@@ -0,0 +1,10 @@
+import { TcpConnection } from "./connection.js";
+import { connectTcp, connectTls, listenTcp } from "./functions.js";
+import { TcpListener } from "./listener.js";
+export {
+  TcpConnection,
+  TcpListener,
+  connectTcp,
+  connectTls,
+  listenTcp
+};

package/listener.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const connection = require("./connection.cjs");
+class TcpListener {
+  constructor() {
+  }
+  #listener;
+  #waiter;
+  listen(endpoint) {
+    this.#listener = Bun.listen({
+      hostname: endpoint.address,
+      port: endpoint.port,
+      socket: {
+        open: (socket) => {
+          if (!this.#waiter) {
+            socket.end();
+            return;
+          }
+          const conn = connection.TcpConnection.from(socket);
+          socket.data = conn;
+          this.#waiter.resolve(conn);
+          this.#waiter = void 0;
+        },
+        error: (socket, error) => {
+          if (this.#waiter) {
+            this.#waiter.reject(error);
+            this.#waiter = void 0;
+            return;
+          }
+          socket.data?._handleError(socket, error);
+        },
+        data: (socket, data) => {
+          socket.data._handleData(socket, data);
+        },
+        drain: (socket) => {
+          socket.data._handleDrain();
+        },
+        close: (socket) => {
+          socket.data._handleClose();
+        }
+      }
+    });
+  }
+  close() {
+    this.#listener.stop();
+  }
+  get address() {
+    return {
+      address: this.#listener.hostname,
+      port: this.#listener.port
+    };
+  }
+  async accept() {
+    this.#waiter = new utils.Deferred();
+    const connection2 = await this.#waiter.promise;
+    this.#waiter = void 0;
+    return connection2;
+  }
+}
+exports.TcpListener = TcpListener;

package/listener.d.ts

@@ -0,0 +1,10 @@
+import { IListener, TcpEndpoint } from '@fuman/net';
+import { TcpConnection } from './connection.js';
+export declare class TcpListener implements IListener<TcpEndpoint, TcpConnection> {
+    #private;
+    constructor();
+    listen(endpoint: TcpEndpoint): void;
+    close(): void;
+    get address(): TcpEndpoint;
+    accept(): Promise<TcpConnection>;
+}

package/listener.js

@@ -0,0 +1,61 @@
+import { Deferred } from "@fuman/utils";
+import { TcpConnection } from "./connection.js";
+class TcpListener {
+  constructor() {
+  }
+  #listener;
+  #waiter;
+  listen(endpoint) {
+    this.#listener = Bun.listen({
+      hostname: endpoint.address,
+      port: endpoint.port,
+      socket: {
+        open: (socket) => {
+          if (!this.#waiter) {
+            socket.end();
+            return;
+          }
+          const conn = TcpConnection.from(socket);
+          socket.data = conn;
+          this.#waiter.resolve(conn);
+          this.#waiter = void 0;
+        },
+        error: (socket, error) => {
+          if (this.#waiter) {
+            this.#waiter.reject(error);
+            this.#waiter = void 0;
+            return;
+          }
+          socket.data?._handleError(socket, error);
+        },
+        data: (socket, data) => {
+          socket.data._handleData(socket, data);
+        },
+        drain: (socket) => {
+          socket.data._handleDrain();
+        },
+        close: (socket) => {
+          socket.data._handleClose();
+        }
+      }
+    });
+  }
+  close() {
+    this.#listener.stop();
+  }
+  get address() {
+    return {
+      address: this.#listener.hostname,
+      port: this.#listener.port
+    };
+  }
+  async accept() {
+    this.#waiter = new Deferred();
+    const connection = await this.#waiter.promise;
+    this.#waiter = void 0;
+    return connection;
+  }
+}
+export {
+  TcpListener
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "@fuman/bun",
+    "type": "module",
+    "version": "0.0.1",
+    "description": "bun-specific utilities",
+    "license": "MIT",
+    "scripts": {},
+    "dependencies": {
+        "@fuman/io": "^0.0.1",
+        "@fuman/net": "^0.0.1",
+        "@fuman/utils": "^0.0.1"
+    },
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        }
+    },
+    "sideEffects": false,
+    "author": "",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/teidesu/fuman.git"
+    }
+}