@fncts/node 0.0.33 → 0.0.35

package/http/Server.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Lazy } from "@fncts/base/data/function/definition";
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { HttpApp } from "@fncts/http/HttpApp";
+import type { Middleware } from "@fncts/http/Middleware";
+import type { ServerResponse } from "@fncts/http/ServerResponse";
+import type * as Net from "node:net";
+import type { Duplex } from "node:stream";
+import { IncomingMessage } from "@fncts/http/IncomingMessage";
+import { ResponseError } from "@fncts/http/ResponseError";
+import { Server } from "@fncts/http/Server";
+import { ServeError } from "@fncts/http/ServerError";
+import { ServerRequest } from "@fncts/http/ServerRequest";
+import * as Http from "node:http";
+import * as ws from "ws";
+export declare function make(evaluate: Lazy<Http.Server>, options: Net.ListenOptions): IO<Scope, ServeError, Server>;
+export declare function makeHandler<R, E>(httpApp: HttpApp.Default<R, E>): IO<Exclude<R, ServerRequest | Scope>, never, (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void>;
+export declare function makeHandler<R, E, App extends HttpApp.Default<any, any>>(httpApp: HttpApp.Default<R, E>, middleware: Middleware.Applied<R, E | ResponseError, App>): IO<Exclude<R, ServerRequest | Scope>, never, (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void>;
+export declare function makeUpgradeHandler<R, E>(wss: UIO<ws.WebSocketServer>, httpApp: HttpApp.Default<R, E>, middleware?: Middleware): import("@fncts/io/IO").IO<import("@fncts/io/Scope").Scope | R, never, (nodeRequest: Http.IncomingMessage, socket: Duplex, head: Buffer) => void>;
+export declare function handleResponse(request: ServerRequest, response: ServerResponse): import("@fncts/io/IO").IO<never, ResponseError, void>;

package/http/ServerRequest.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { Lazy } from "@fncts/base/data/function/definition";
+import { IO } from "@fncts/io/IO/definition";
+import type { Headers } from "@fncts/http/Headers";
+import type { Method } from "@fncts/http/Method";
+import type { ServerRequest } from "@fncts/http/ServerRequest";
+import type { Socket } from "@fncts/http/Socket";
+import type * as Http from "node:http";
+import { RequestError } from "@fncts/http/RequestError";
+import { ServerRequestTypeId } from "@fncts/http/ServerRequest";
+import { IncomingMessageImpl } from "@fncts/node/http/IncomingMessage";
+export declare class ServerRequestImpl extends IncomingMessageImpl<RequestError> implements ServerRequest {
+    readonly source: Http.IncomingMessage;
+    readonly response: Http.ServerResponse | Lazy<Http.ServerResponse>;
+    private upgradeEffect?;
+    readonly url: string;
+    private headersOverride?;
+    readonly [ServerRequestTypeId]: ServerRequestTypeId;
+    constructor(source: Http.IncomingMessage, response: Http.ServerResponse | Lazy<Http.ServerResponse>, upgradeEffect?: import("@fncts/io/IO").IO<never, RequestError, Socket> | undefined, url?: string, headersOverride?: Headers | undefined, remoteAddressOverride?: string);
+    get resolvedResponse(): Http.ServerResponse;
+    modify(options: {
+        readonly url?: string | undefined;
+        readonly headers?: Headers | undefined;
+        readonly remoteAddress?: string | undefined;
+    }): ServerRequest;
+    get originalUrl(): string;
+    get method(): Method;
+    get upgrade(): IO<never, RequestError, Socket>;
+}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@fncts/node",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "dependencies": {
-    "@fncts/io": "0.0.40"
+    "@fncts/io": "0.0.42",
+    "ws": "^8.17.0"
   },
   "exports": {
     "./*": {

package/stream/api.d.ts

@@ -1,9 +1,17 @@
 /// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import { Lazy } from "@fncts/base/data/function/definition";
-import { Byte } from "@fncts/base/data/Byte";
-import { Sink } from "@fncts/io/Sink/definition";
 import { Channel } from "@fncts/io/Channel";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Queue } from "@fncts/io/Queue/definition";
+import { Sink } from "@fncts/io/Sink/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Future } from "@fncts/io/Future";
+import { Byte } from "@fncts/base/data/Byte";
 import type stream from "node:stream";
 import { Stream } from "@fncts/io/Stream";
 export declare class ReadableError {
@@ -11,13 +19,13 @@ export declare class ReadableError {
     readonly _tag = "ReadableError";
     constructor(error: Error);
 }
-export declare function fromReadable(readable: Lazy<stream.Readable>): Stream<never, ReadableError, Byte>;
-export declare class WritableError {
-    readonly error: Error;
-    readonly _tag = "ReadableError";
-    constructor(error: Error);
+export declare function fromReadable<E, A = Uint8Array>(readable: Lazy<stream.Readable | NodeJS.ReadableStream>, onError: (error: unknown) => E, chunkSize?: number): Stream<never, E, A>;
+export interface FromWritableOptions {
+    readonly endOnDone?: boolean;
+    readonly encoding?: BufferEncoding;
 }
-export declare function fromWritable(writable: Lazy<stream.Writable>): Sink<never, WritableError, Byte, never, void>;
+export declare function fromWritable<E, A = Uint8Array | string>(writable: Lazy<stream.Writable | NodeJS.WritableStream>, onError: (error: unknown) => E, options?: FromWritableOptions): Sink<never, E, A, never, void>;
+export declare function fromWritableChannel<IE, OE, A>(writable: Lazy<stream.Writable | NodeJS.WritableStream>, onError: (error: unknown) => OE, options?: FromWritableOptions): Channel<never, IE, Conc<A>, unknown, IE | OE, never, void>;
 export declare class TransformError {
     readonly error: Error;
     readonly _tag = "TransformError";
@@ -28,3 +36,10 @@ export declare class TransformError {
  * @tsplus location "@fncts/node/stream/api"
  */
 export declare function transform(transform: Lazy<stream.Transform>): <R, E>(self: Stream<R, E, Byte>) => Stream<R, E | TransformError, Byte>;
+export declare function toString<E>(readable: Lazy<stream.Readable | NodeJS.ReadableStream>, onFailure: (error: unknown) => E, options?: {
+    encoding?: BufferEncoding;
+    maxBytes?: number;
+}): IO<never, E, string>;
+export declare function toUint8Array<E>(readable: Lazy<stream.Readable | NodeJS.ReadableStream>, onFailure: (error: unknown) => E, options?: {
+    maxBytes?: number;
+}): IO<never, E, Uint8Array>;