uws-react-native 0.0.1-alpha.1

package/src/types/TemplatedApp.ts

@@ -0,0 +1,285 @@
+import type {
+	ListenOptions,
+} from "../modules/ListenOptions"
+
+// import type {
+// 	AppDescriptor,
+// } from "./AppDescriptor"
+
+// import type {
+// 	AppOptions,
+// } from "./AppOptions"
+
+import type {
+	HttpRequest,
+} from "./HttpRequest"
+
+import type {
+	HttpResponse,
+} from "./HttpResponse"
+
+import type {
+	HttpRouterOptions,
+} from "./HttpRouterOptions"
+
+import type {
+	RecognizedString,
+} from "./RecognizedString"
+
+// import type {
+// 	WebSocketBehavior,
+// } from "./WebSocketBehaviour"
+
+// import type {
+// 	us_listen_socket,
+// } from "./us_listen_socket"
+
+/**
+ * Definitions of the `App` and `SSLApp`. This is entirely copied from uWebSockets.js
+ */
+export interface TemplatedApp {
+	// Can't figure it out how to implement it in React Native
+	/**
+	 * Add a child app descriptor for worker thread distribution.
+	 */
+	// addChildAppDescriptor(
+	// 	descriptor: AppDescriptor,
+	// ): void,
+
+	// TODO
+	// Need the SSL implementation
+	/**
+	 * Adds a server name.
+	 */
+	// addServerName(
+	// 	hostname: string,
+	// 	options: AppOptions,
+	// ) : TemplatedApp,
+
+	/**
+	 * Closes all sockets including listen sockets. This will forcefully terminate all connections.
+	 */
+	close() : void,
+
+	/**
+	 * Browse to SNI domain. Used together with .get, .post and similar to attach routes under SNI domains.
+	 */
+	domain(
+		domain: string,
+	) : TemplatedApp,
+
+	/**
+	 * Attaches a "filter" function to track socket connections / disconnections.
+	 */
+	filter(
+		cb: (res: HttpResponse, count: number) => void | Promise<void>,
+	) : TemplatedApp,
+
+	// Can't figure it out how to implement it in React Native
+	/**
+	 * Returns the app descriptor for worker thread distribution.
+	 */
+	// getDescriptor(): AppDescriptor,
+
+	/**
+	 * Listens to hostname & port and sets Listen Options. Callback hands either false or a listen socket.
+	 */
+	listen(
+		host: RecognizedString,
+		port: number,
+		options: ListenOptions,
+		cb: (
+			id: number,
+			// listenSocket: us_listen_socket | false,
+		) => void | Promise<void>,
+	) : TemplatedApp,
+
+	/**
+	 * Listens to hostname & port. Callback hands either false or a listen socket.
+	 */
+	listen(
+		host: RecognizedString,
+		port: number,
+		cb: (
+			token: number,
+			// listenSocket: us_listen_socket | false,
+		) => void | Promise<void>,
+	) : TemplatedApp,
+
+	/**
+	 * Listens to port and sets Listen Options. Callback hands either false or a listen socket.
+	 */
+	listen(
+		port: number,
+		options: ListenOptions,
+		cb: (
+			token: number,
+			// listenSocket: us_listen_socket | false,
+		) => void | Promise<void>,
+	) : TemplatedApp,
+
+	/**
+	 * Listens to port. Callback hands either false or a listen socket.
+	 */
+	listen(
+		port: number,
+		cb: (
+			token: number,
+			// listenSocket: us_listen_socket | false,
+		) => void | Promise<void>,
+	) : TemplatedApp,
+
+	// TODO
+	// Need the SSL implementation
+	/**
+	 * Registers a synchronous callback on missing server names. See /examples/ServerName.js.
+	 */
+	// missingServerName(
+	// 	cb: (hostname: string) => void,
+	// ) : TemplatedApp,
+
+	/**
+	 * Returns number of subscribers for this topic.
+	 */
+	numSubscribers(
+		topic: RecognizedString,
+	) : number,
+
+	/**
+	 * Publishes a message under topic, for all WebSockets under this app. See WebSocket.publish.
+	 */
+	publish(
+		topic: RecognizedString,
+		message: RecognizedString,
+		isBinary?: boolean,
+		compress?: boolean,
+	) : boolean,
+
+	// Can't figure it out how to implement it in React Native
+	/**
+	 * Remove a child app descriptor.
+	 */
+	// removeChildAppDescriptor(
+	// 	descriptor: AppDescriptor,
+	// ): void,
+
+	// TODO
+	// Need the SSL implementation
+	/**
+	 * Removes a server name.
+	 */
+	// removeServerName(
+	// 	hostname: string,
+	// ) : TemplatedApp,
+
+	// /**
+	//  * Registers a handler matching specified URL pattern where WebSocket upgrade requests are caught.
+	//  */
+	// ws/* <UserData> */(
+	// 	pattern: RecognizedString,
+	// 	behavior: WebSocketBehavior/* <UserData> */,
+	// ) : TemplatedApp,
+
+	// we can't provide this in Reaact Native
+	/**
+	 * Listens to unix socket. Callback hands either false or a listen socket.
+	 */
+	// listen_unix(
+	// 	cb: (listenSocket: us_listen_socket) => void | Promise<void>,
+	// 	path: RecognizedString,
+	// ) : TemplatedApp,
+
+	// +++++ ROUTER +++++
+
+	/**
+	 * Registers an HTTP handler matching specified URL pattern on any HTTP method.
+	 */
+	any(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	/**
+	 * Registers an HTTP CONNECT handler matching specified URL pattern.
+	 */
+	connect(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	/**
+	 * Registers an HTTP DELETE handler matching specified URL pattern.
+	 */
+	del(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	/**
+	 * Registers an HTTP GET handler matching specified URL pattern.
+	 */
+	get(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	/**
+	 * Registers an HTTP HEAD handler matching specified URL pattern.
+	 */
+	head(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	/**
+	 * Registers an HTTP OPTIONS handler matching specified URL pattern.
+	 */
+	options(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	/**
+	 * Registers an HTTP PATCH handler matching specified URL pattern.
+	 */
+	patch(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	/**
+	 * Registers an HTTP POST handler matching specified URL pattern.
+	 */
+	post(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	/**
+	 * Registers an HTTP PUT handler matching specified URL pattern.
+	 */
+	put(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	/**
+	 * Registers an HTTP TRACE handler matching specified URL pattern.
+	 */
+	trace(
+		pattern: RecognizedString,
+		handler: (res: HttpResponse, req: HttpRequest) => void | Promise<void>,
+		options?: HttpRouterOptions,
+	) : TemplatedApp,
+
+	// ----- ROUTER -----
+}

package/src/types/WebSocket.ts

@@ -0,0 +1,147 @@
+import type {
+	RecognizedString,
+} from "./RecognizedString"
+
+/**
+ * A WebSocket connection that is valid from open to close event.
+ * Read more about this in the user manual.
+ */
+export interface WebSocket/* <UserData> */ {
+	/**
+	 * Sends a message. Returns 1 for success, 2 for dropped due to backpressure limit, and 0 for built up backpressure that will drain over time. You can check backpressure before or after sending by calling getBufferedAmount().
+     *
+     * Make sure you properly understand the concept of backpressure. Check the backpressure example file.
+     */
+	send(
+		message: RecognizedString,
+		isBinary?: boolean,
+		compress?: boolean,
+	) : number,
+
+	/**
+	 * Returns the bytes buffered in backpressure. This is similar to the bufferedAmount property in the browser counterpart.
+     * Check backpressure example.
+     */
+	getBufferedAmount() : number,
+
+	/**
+	 * Gracefully closes this WebSocket. Immediately calls the close handler.
+     * A WebSocket close message is sent with code and shortMessage.
+     */
+	end(
+		code?: number,
+		shortMessage?: RecognizedString,
+	) : void,
+
+	/**
+	 * Forcefully closes this WebSocket. Immediately calls the close handler.
+     * No WebSocket close message is sent.
+     */
+	close() : void,
+
+	/**
+	 * Sends a ping control message. Returns sendStatus similar to WebSocket.send (regarding backpressure). This helper function correlates to WebSocket::send(message, uWS::OpCode::PING, ...) in C++.
+	 */
+	ping(
+		message?: RecognizedString,
+	) : number,
+
+	/**
+	 * Subscribe to a topic.
+	 */
+	subscribe(
+		topic: RecognizedString,
+	) : boolean,
+
+	/**
+	 * Unsubscribe from a topic. Returns true on success, if the WebSocket was subscribed.
+	 */
+	unsubscribe(
+		topic: RecognizedString,
+	) : boolean,
+
+	/**
+	 * Returns whether this websocket is subscribed to topic.
+	 */
+	isSubscribed(
+		topic: RecognizedString,
+	) : boolean,
+
+	/**
+	 * Returns a list of topics this websocket is subscribed to.
+	 */
+	getTopics() : string[],
+
+	/**
+	 * Publish a message under topic. Backpressure is managed according to maxBackpressure, closeOnBackpressureLimit settings.
+     * Order is guaranteed since v20.
+     */
+	publish(
+		topic: RecognizedString,
+		message: RecognizedString,
+		isBinary?: boolean,
+		compress?: boolean,
+	) : boolean,
+
+	/**
+	 * See `HttpResponse.cork`. Takes a function in which the socket is corked (packing many sends into one single syscall/SSL block)
+	 */
+	cork(
+		cb: () => void,
+	) : WebSocket/* <UserData> */,
+
+	/**
+	 * Returns the remote IP address. Note that the returned IP is binary, not text.
+     *
+     * IPv4 is 4 byte long and can be converted to text by printing every byte as a digit between 0 and 255.
+     * IPv6 is 16 byte long and can be converted to text in similar ways, but you typically print digits in HEX.
+     *
+     * See getRemoteAddressAsText() for a text version.
+	 * 
+	 * @experimental It's an experimental due to unstable of ArrayBuffer support from React Native.
+     */
+	getRemoteAddress() : ArrayBuffer,
+
+	/**
+	 * Returns the remote IP address as text.
+	 */
+	getRemoteAddressAsText() : /* ArrayBuffer */string,
+
+	/**
+	 * Returns the remote port number.
+	 */
+	getRemotePort() : number,
+
+	/**
+	 * Returns the UserData ~object~ string.
+	 */
+	getUserData() : /* UserData */string,
+
+	/**
+	 * Sends the first fragment of a fragmented message. Use for sending large messages in chunks.
+     * Returns 1 for success, 2 for dropped due to backpressure limit, and 0 for built up backpressure.
+     */
+	sendFirstFragment(
+		message: RecognizedString,
+		isBinary?: boolean,
+		compress?: boolean,
+	) : number,
+
+	/**
+	 * Sends a middle fragment of a fragmented message.
+     * Returns 1 for success, 2 for dropped due to backpressure limit, and 0 for built up backpressure.
+     */
+	sendFragment(
+		message: RecognizedString,
+		compress?: boolean,
+	) : number,
+
+	/**
+	 * Sends the last fragment of a fragmented message.
+     * Returns 1 for success, 2 for dropped due to backpressure limit, and 0 for built up backpressure.
+     */
+	sendLastFragment(
+		message: RecognizedString,
+		compress?: boolean,
+	) : number,
+}

package/src/types/WebSocketBehaviour.ts

@@ -0,0 +1,137 @@
+// import type {
+// 	CompressOptions,
+// } from "../modules/CompressOptions"
+
+// import type {
+// 	HttpRequest,
+// } from "./HttpRequest"
+
+// import type {
+// 	HttpResponse,
+// } from "./HttpResponse"
+
+// import type {
+// 	WebSocket,
+// } from "./WebSocket"
+
+// import type {
+// 	us_socket_context_t,
+// } from "./us_socket_context_t"
+
+// /**
+//  * A structure holding settings and handlers for a WebSocket URL route handler.
+//  */
+// export interface WebSocketBehavior/* <UserData> */ {
+// 	/**
+// 	 * Maximum length of received message. If a client tries to send you a message larger than this, the connection is immediately closed. Defaults to 16 * 1024.
+// 	 */
+// 	maxPayloadLength?: number,
+
+// 	/**
+// 	 * Whether or not we should automatically close the socket when a message is dropped due to backpressure. Defaults to false.
+// 	 */
+// 	closeOnBackpressureLimit?: boolean,
+
+// 	/**
+// 	 * Maximum number of minutes a WebSocket may be connected before being closed by the server. 0 disables the feature. Valid values are 0 and 1-239.
+// 	 */
+// 	maxLifetime?: number,
+
+// 	/**
+// 	 * Maximum amount of seconds that may pass without sending or getting a message. Connection is closed if this timeout passes. Resolution (granularity) for timeouts are typically 4 seconds, rounded to closest.
+//      * Disable by using 0. Defaults to 120.
+// 	 */
+// 	idleTimeout?: number,
+
+// 	/**
+// 	 * What permessage-deflate compression to use. uWS.DISABLED, uWS.SHARED_COMPRESSOR or any of the uWS.DEDICATED_COMPRESSOR_xxxKB. Defaults to uWS.DISABLED.
+// 	 */
+// 	compression?: CompressOptions,
+
+// 	/**
+// 	 * Maximum length of allowed backpressure per socket when publishing or sending messages. Slow receivers with too high backpressure will be skipped until they catch up or timeout. Defaults to 64 * 1024.
+// 	 */
+// 	maxBackpressure?: number,
+
+// 	/**
+// 	 * Whether or not we should automatically send pings to uphold a stable connection given whatever idleTimeout.
+// 	 */
+// 	sendPingsAutomatically?: boolean,
+
+// 	/**
+// 	 * Upgrade handler used to intercept HTTP upgrade requests and potentially upgrade to WebSocket.
+//      * See UpgradeAsync and UpgradeSync example files.
+// 	 */
+// 	upgrade?: (
+// 		res: HttpResponse,
+// 		req: HttpRequest,
+// 		context: us_socket_context_t,
+// 	) => void | Promise<void>,
+
+// 	/**
+// 	 * Handler for new WebSocket connection. WebSocket is valid from open to close, no errors.
+// 	 */
+// 	open?: (
+// 		ws: WebSocket/* <UserData> */,
+// 	) => void | Promise<void>,
+
+// 	/**
+// 	 * Handler for a WebSocket message. Messages are given as ArrayBuffer no matter if they are binary or not. Given ArrayBuffer is valid during the lifetime of this callback (until first await or return) and will be neutered.
+// 	 */
+// 	message?: (
+// 		ws: WebSocket/* <UserData> */,
+// 		message: ArrayBuffer,
+// 		isBinary: boolean,
+// 	) => void | Promise<void>,
+
+// 	/**
+// 	 * Handler for a dropped WebSocket message. Messages can be dropped due to specified backpressure settings. Messages are given as ArrayBuffer no matter if they are binary or not. Given ArrayBuffer is valid during the lifetime of this callback (until first await or return) and will be neutered.
+// 	 */
+// 	dropped?: (
+// 		ws: WebSocket/* <UserData> */,
+// 		message: ArrayBuffer,
+// 		isBinary: boolean,
+// 	) => void | Promise<void>,
+
+// 	/**
+// 	 * Handler for when WebSocket backpressure drains. Check ws.getBufferedAmount(). Use this to guide / drive your backpressure throttling.
+// 	 */
+// 	drain?: (
+// 		ws: WebSocket/* <UserData> */,
+// 	) => void,
+
+// 	/**
+// 	 * Handler for close event, no matter if error, timeout or graceful close. You may not use WebSocket after this event. Do not send on this WebSocket from within here, it is closed.
+// 	 */
+// 	close?: (
+// 		ws: WebSocket/* <UserData> */,
+// 		code: number,
+// 		message: ArrayBuffer,
+// 	) => void,
+
+// 	/**
+// 	 * Handler for received ping control message. You do not need to handle this, pong messages are automatically sent as per the standard.
+// 	 */
+// 	ping?: (
+// 		ws: WebSocket/* <UserData> */,
+// 		message: ArrayBuffer,
+// 	) => void,
+
+// 	/**
+// 	 * Handler for received pong control message.
+// 	 */
+// 	pong?: (
+// 		ws: WebSocket/* <UserData> */,
+// 		message: ArrayBuffer,
+// 	) => void,
+
+// 	/**
+// 	 * Handler for subscription changes.
+// 	 */
+// 	subscription?: (
+// 		ws: WebSocket/* <UserData> */,
+// 		topic: ArrayBuffer,
+// 		newCount: number,
+// 		oldCount: number,
+// 	) => void,
+// }

package/src/types/index.ts

@@ -0,0 +1,12 @@
+// export type * from "./AppDescriptor"
+// export type * from "./AppOptions"
+export type * from "./HttpRequest"
+export type * from "./HttpResponse"
+export type * from "./MultipartField"
+export type * from "./RecognizedString"
+export type * from "./TemplatedApp"
+// export type * from "./WebSocket"
+// export type * from "./WebSocketBehaviour"
+// export type * from "./us_listen_socket"
+// export type * from "./us_socket"
+// export type * from "./us_socket_context_t"

package/src/types/us_listen_socket.ts

@@ -0,0 +1,6 @@
+/**
+ * Native type representing a raw uSockets struct us_listen_socket_t.
+ * Careful with this one, it is entirely unchecked and native so invalid usage will blow up.
+ */
+export interface us_listen_socket {
+}

package/src/types/us_socket.ts

@@ -0,0 +1,6 @@
+/**
+ * Native type representing a raw uSockets struct us_socket_t.
+ * Careful with this one, it is entirely unchecked and native so invalid usage will blow up.
+ */
+export interface us_socket {
+}

package/src/types/us_socket_context_t.ts

@@ -0,0 +1,6 @@
+/**
+ * Native type representing a raw uSockets struct us_socket_context_t.
+ * Used while upgrading a WebSocket manually.
+ */
+export interface us_socket_context_t {
+}