@cmmd-center/forge 0.9.0 → 0.9.1

package/dist/NodeHttpServer-D5-EtRwc.mjs

@@ -0,0 +1,605 @@
+#!/usr/bin/env node
+
+import { $r as scope, Da as addFinalizer, Dr as matchCauseEffect, Ei as void_, Hn as die, Jr as runForkWith, Js as seconds, Kn as fail, Oa as addFinalizerExit, On as cached, Pa as provide$1, Qn as flatMap, Qr as runSync, Rc as makeUnsafe, Sa as succeed$1, Sr as map, Wc as fromNullishOr, Yl as flow, Zl as pipe, _i as tryPromise, _n as acquireRelease, ai as succeed, ba as provide, ci as suspend, di as tapCause, fa as effect, ga as fresh, gi as timeoutOrElse, ja as forkUnsafe, ki as withFiber, kn as callback, li as sync, lo as combine, nr as fnUntraced, pr as interruptible, qn as failCause, uo as die$1, vi as try_, vl as Class, xa as provideMerge, ya as mergeAll } from "./Schema-CTXk8IgN.mjs";
+import { Ht as makeUnsafe$1, M as map$1, q as runForEachArray, qt as runIn, rt as unwrap, z as orDie } from "./Path-Bwl3ltR5.mjs";
+import { f as fromReadable, h as toUint8Array, m as toString, p as toArrayBuffer } from "./NodeTerminal-_XekCzf-.mjs";
+import { n as layer$3, r as layer$2 } from "./NodeServices-Bqqy4DuH.mjs";
+import { $ as raw, At as toSetCookieHeaders, B as causeResponse, C as toPersisted, Ct as fromInput$1, Dt as merge, Et as fromRecordUnsafe, F as HttpServerError, H as layer$5, I as RequestParseError, K as layer$4, L as ResponseError, M as fromWebSocket, Ot as isEmpty, P as ClientAbort, S as makeConfig, T as make$4, Tt as fromInput, V as RequestInit, b as TypeId$1, dt as TypeId, ft as inspect, h as TypeId$2, kt as parseHeader, l as toHandled, n as layerTestClient, o as HttpPlatform, p as HttpServerRequest, q as layerWeak, r as make$5, s as make$3, t as HttpServer, ut as MaxBodySize, w as decodeField, y as MultipartError, z as ServeError } from "./HttpServer-ByyNdEXm.mjs";
+import { h as unwrap$1 } from "./Config-DrOyN3WS.mjs";
+import { n as import_websocket_server, t as Mime_default } from "./Mime-B75_d9aw.mjs";
+import { Duplex, Readable } from "node:stream";
+import * as Fs from "node:fs";
+import * as Http from "node:http";
+import * as NodeStreamP from "node:stream/promises";
+import { pipeline } from "node:stream/promises";
+//#region ../../node_modules/.bun/@effect+platform-node@4.0.0-beta.45+6a386fbfc71a3ef3/node_modules/@effect/platform-node/dist/NodeHttpIncomingMessage.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+var NodeHttpIncomingMessage = class extends Class {
+	/**
+	* @since 1.0.0
+	*/
+	[TypeId];
+	source;
+	onError;
+	remoteAddressOverride;
+	constructor(source, onError, remoteAddressOverride) {
+		super();
+		this[TypeId] = TypeId;
+		this.source = source;
+		this.onError = onError;
+		this.remoteAddressOverride = remoteAddressOverride;
+	}
+	get headers() {
+		return fromInput(this.source.headers);
+	}
+	get remoteAddress() {
+		return this.remoteAddressOverride ?? fromNullishOr(this.source.socket.remoteAddress);
+	}
+	textEffect;
+	get text() {
+		if (this.textEffect) return this.textEffect;
+		this.textEffect = runSync(cached(flatMap(MaxBodySize.asEffect(), (maxBodySize) => toString(() => this.source, {
+			onError: this.onError,
+			maxBytes: maxBodySize
+		}))));
+		return this.textEffect;
+	}
+	get textUnsafe() {
+		return runSync(this.text);
+	}
+	get json() {
+		return flatMap(this.text, (text) => try_({
+			try: () => text === "" ? null : JSON.parse(text),
+			catch: this.onError
+		}));
+	}
+	get jsonUnsafe() {
+		return runSync(this.json);
+	}
+	get urlParamsBody() {
+		return flatMap(this.text, (_) => try_({
+			try: () => fromInput$1(new URLSearchParams(_)),
+			catch: this.onError
+		}));
+	}
+	get stream() {
+		return fromReadable({
+			evaluate: () => this.source,
+			onError: this.onError
+		});
+	}
+	get arrayBuffer() {
+		return withFiber((fiber) => toArrayBuffer(() => this.source, {
+			onError: this.onError,
+			maxBytes: fiber.getRef(MaxBodySize)
+		}));
+	}
+};
+//#endregion
+//#region ../../node_modules/.bun/@effect+platform-node@4.0.0-beta.45+6a386fbfc71a3ef3/node_modules/@effect/platform-node/dist/NodeHttpPlatform.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category Constructors
+*/
+const make$2 = /* @__PURE__ */ make$3({
+	fileResponse(path, status, statusText, headers, start, end, contentLength) {
+		return raw(contentLength === 0 ? Readable.from([]) : Fs.createReadStream(path, {
+			start,
+			end: end === void 0 ? void 0 : end - 1
+		}), {
+			headers: {
+				...headers,
+				"content-type": headers["content-type"] ?? Mime_default.getType(path) ?? "application/octet-stream",
+				"content-length": contentLength.toString()
+			},
+			status,
+			statusText
+		});
+	},
+	fileWebResponse(file, status, statusText, headers, _options) {
+		return raw(Readable.fromWeb(file.stream()), {
+			headers: merge(headers, fromRecordUnsafe({
+				"content-type": headers["content-type"] ?? Mime_default.getType(file.name) ?? "application/octet-stream",
+				"content-length": file.size.toString()
+			})),
+			status,
+			statusText
+		});
+	}
+});
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layer$1 = /* @__PURE__ */ pipe(/* @__PURE__ */ effect(HttpPlatform)(make$2), /* @__PURE__ */ provide(layer$2), /* @__PURE__ */ provide(layer$4));
+//#endregion
+//#region ../../node_modules/.bun/multipasta@0.2.7/node_modules/multipasta/dist/esm/node.js
+var MultipastaStream = class extends Duplex {
+	_parser;
+	_canWrite = true;
+	_writeCallback;
+	constructor(config) {
+		super({ readableObjectMode: true });
+		let currentError;
+		let currentFile;
+		this._parser = make$4({
+			...config,
+			onField: (info, value) => {
+				if (currentError !== void 0) return;
+				const field = {
+					_tag: "Field",
+					info,
+					value
+				};
+				this.push(field);
+				this.emit("field", field);
+			},
+			onFile: (info) => {
+				if (currentError !== void 0) return (_) => {};
+				const file = new FileStream(info, this);
+				currentFile = file;
+				this.push(file);
+				this.emit("file", file);
+				return (chunk) => {
+					this._canWrite = file.push(chunk);
+					if (chunk === null && !this._canWrite) {
+						currentFile = void 0;
+						this._resume();
+					}
+				};
+			},
+			onError: (error) => {
+				this.emit("error", error);
+				currentFile?.emit("error", error);
+				currentError = error;
+			},
+			onDone: () => {
+				this.push(null);
+			}
+		});
+	}
+	_resume() {
+		this._canWrite = true;
+		if (this._writeCallback !== void 0) {
+			const callback = this._writeCallback;
+			this._writeCallback = void 0;
+			callback();
+		}
+	}
+	_read(_size) {}
+	_write(chunk, encoding, callback) {
+		this._parser.write(chunk instanceof Uint8Array ? chunk : Buffer.from(chunk, encoding));
+		if (this._canWrite) callback();
+		else this._writeCallback = callback;
+	}
+	_final(callback) {
+		this._parser.end();
+		callback();
+	}
+};
+const make$1 = (config) => new MultipastaStream(config);
+var FileStream = class extends Readable {
+	info;
+	_parent;
+	_tag = "File";
+	filename;
+	constructor(info, _parent) {
+		super();
+		this.info = info;
+		this._parent = _parent;
+		this.filename = info.filename;
+	}
+	_read(_size) {
+		if (this._parent._canWrite === false) this._parent._resume();
+	}
+};
+//#endregion
+//#region ../../node_modules/.bun/@effect+platform-node@4.0.0-beta.45+6a386fbfc71a3ef3/node_modules/@effect/platform-node/dist/NodeMultipart.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category constructors
+*/
+const stream = (source, headers) => makeConfig(headers).pipe(map((config) => fromReadable({
+	evaluate() {
+		const parser = make$1(config);
+		source.pipe(parser);
+		return parser;
+	},
+	onError: (error) => convertError(error)
+})), unwrap, map$1(convertPart));
+/**
+* @since 1.0.0
+* @category constructors
+*/
+const persisted = (source, headers) => toPersisted(stream(source, headers), (path, file) => tryPromise({
+	try: (signal) => NodeStreamP.pipeline(file.file, Fs.createWriteStream(path), { signal }),
+	catch: (cause) => MultipartError.fromReason("InternalError", cause)
+}));
+const convertPart = (part) => part._tag === "Field" ? new FieldImpl(part.info, part.value) : new FileImpl(part);
+var PartBase = class extends Class {
+	[TypeId$1];
+	constructor() {
+		super();
+		this[TypeId$1] = TypeId$1;
+	}
+};
+var FieldImpl = class extends PartBase {
+	_tag = "Field";
+	key;
+	contentType;
+	value;
+	constructor(info, value) {
+		super();
+		this.key = info.name;
+		this.contentType = info.contentType;
+		this.value = decodeField(info, value);
+	}
+	toJSON() {
+		return {
+			_id: "@effect/platform/Multipart/Part",
+			_tag: "Field",
+			key: this.key,
+			value: this.value,
+			contentType: this.contentType
+		};
+	}
+};
+var FileImpl = class extends PartBase {
+	_tag = "File";
+	key;
+	name;
+	contentType;
+	content;
+	contentEffect;
+	file;
+	constructor(file) {
+		super();
+		this.file = file;
+		this.key = file.info.name;
+		this.name = file.filename ?? file.info.name;
+		this.contentType = file.info.contentType;
+		this.content = fromReadable({
+			evaluate: () => file,
+			onError: (cause) => MultipartError.fromReason("InternalError", cause)
+		});
+		this.contentEffect = toUint8Array(() => file, { onError: (cause) => MultipartError.fromReason("InternalError", cause) });
+	}
+	toJSON() {
+		return {
+			_id: "@effect/platform/Multipart/Part",
+			_tag: "File",
+			key: this.key,
+			name: this.name,
+			contentType: this.contentType
+		};
+	}
+};
+function convertError(cause) {
+	switch (cause._tag) {
+		case "ReachedLimit": switch (cause.limit) {
+			case "MaxParts": return MultipartError.fromReason("TooManyParts", cause);
+			case "MaxFieldSize": return MultipartError.fromReason("FieldTooLarge", cause);
+			case "MaxPartSize": return MultipartError.fromReason("FileTooLarge", cause);
+			case "MaxTotalSize": return MultipartError.fromReason("BodyTooLarge", cause);
+		}
+		default: return MultipartError.fromReason("Parse", cause);
+	}
+}
+//#endregion
+//#region ../../node_modules/.bun/@effect+platform-node@4.0.0-beta.45+6a386fbfc71a3ef3/node_modules/@effect/platform-node/dist/NodeHttpServer.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category constructors
+*/
+const make = /* @__PURE__ */ fnUntraced(function* (evaluate, options) {
+	const scope$1 = yield* scope;
+	const server = evaluate();
+	const shutdown = yield* callback((resume) => {
+		if (!server.listening) return resume(void_);
+		server.close((error) => {
+			if (error) resume(die(error));
+			else resume(void_);
+		});
+	}).pipe(cached);
+	const preemptiveShutdown = options.disablePreemptiveShutdown ? void_ : timeoutOrElse(shutdown, {
+		duration: options.gracefulShutdownTimeout ?? seconds(20),
+		orElse: () => void_
+	});
+	yield* addFinalizer(scope$1, shutdown);
+	yield* callback((resume) => {
+		function onError(cause) {
+			resume(fail(new ServeError({ cause })));
+		}
+		server.on("error", onError);
+		server.listen(options, () => {
+			server.off("error", onError);
+			resume(void_);
+		});
+	});
+	const address = server.address();
+	const wss = yield* acquireRelease(sync(() => new import_websocket_server.default({ noServer: true })), (wss) => callback((resume) => {
+		wss.close(() => resume(void_));
+	})).pipe(provide$1(scope$1), cached);
+	return make$5({
+		address: typeof address === "string" ? {
+			_tag: "UnixAddress",
+			path: address
+		} : {
+			_tag: "TcpAddress",
+			hostname: address.address === "::" ? "0.0.0.0" : address.address,
+			port: address.port
+		},
+		serve: fnUntraced(function* (httpApp, middleware) {
+			const serveScope = yield* scope;
+			const scope$2 = forkUnsafe(serveScope, "parallel");
+			const handler = yield* makeHandler(httpApp, {
+				middleware,
+				scope: scope$2
+			});
+			const upgradeHandler = yield* makeUpgradeHandler(wss, httpApp, {
+				middleware,
+				scope: scope$2
+			});
+			yield* addFinalizerExit(serveScope, () => {
+				server.off("request", handler);
+				server.off("upgrade", upgradeHandler);
+				return preemptiveShutdown;
+			});
+			server.on("request", handler);
+			server.on("upgrade", upgradeHandler);
+		})
+	});
+});
+/**
+* @since 1.0.0
+* @category Handlers
+*/
+const makeHandler = (httpEffect, options) => {
+	const handled = toHandled(httpEffect, handleResponse, options.middleware);
+	return withFiber((parent) => {
+		const services = parent.context;
+		return succeed(function handler(nodeRequest, nodeResponse) {
+			const map = new Map(services.mapUnsafe);
+			map.set(HttpServerRequest.key, new ServerRequestImpl(nodeRequest, nodeResponse));
+			const fiber = runIn(runForkWith(makeUnsafe(map))(handled), options.scope);
+			nodeResponse.on("close", () => {
+				if (!nodeResponse.writableEnded) fiber.interruptUnsafe(parent.id, ClientAbort.annotation);
+			});
+		});
+	});
+};
+/**
+* @since 1.0.0
+* @category Handlers
+*/
+const makeUpgradeHandler = (lazyWss, httpEffect, options) => {
+	const handledApp = toHandled(httpEffect, handleResponse, options.middleware);
+	return withFiber((parent) => {
+		const services = parent.context;
+		return succeed(function handler(nodeRequest, socket, head) {
+			let nodeResponse_ = void 0;
+			const nodeResponse = () => {
+				if (nodeResponse_ === void 0) {
+					nodeResponse_ = new Http.ServerResponse(nodeRequest);
+					nodeResponse_.assignSocket(socket);
+					nodeResponse_.on("finish", () => {
+						socket.end();
+					});
+				}
+				return nodeResponse_;
+			};
+			const upgradeEffect = fromWebSocket(flatMap(lazyWss, (wss) => acquireRelease(callback((resume) => wss.handleUpgrade(nodeRequest, socket, head, (ws) => {
+				resume(succeed(ws));
+			})), (ws) => sync(() => ws.close()))));
+			const map = new Map(services.mapUnsafe);
+			map.set(HttpServerRequest.key, new ServerRequestImpl(nodeRequest, nodeResponse, upgradeEffect));
+			const fiber = runIn(runForkWith(makeUnsafe(map))(handledApp), options.scope);
+			socket.on("close", () => {
+				if (!socket.writableEnded) fiber.interruptUnsafe(parent.id, ClientAbort.annotation);
+			});
+		});
+	});
+};
+var ServerRequestImpl = class ServerRequestImpl extends NodeHttpIncomingMessage {
+	[TypeId$2];
+	response;
+	upgradeEffect;
+	url;
+	headersOverride;
+	constructor(source, response, upgradeEffect, url = source.url, headersOverride, remoteAddressOverride) {
+		super(source, (cause) => new HttpServerError({ reason: new RequestParseError({
+			request: this,
+			cause
+		}) }), remoteAddressOverride);
+		this[TypeId$2] = TypeId$2;
+		this.response = response;
+		this.upgradeEffect = upgradeEffect;
+		this.url = url;
+		this.headersOverride = headersOverride;
+	}
+	cachedCookies;
+	get cookies() {
+		if (this.cachedCookies) return this.cachedCookies;
+		return this.cachedCookies = parseHeader(this.headers.cookie ?? "");
+	}
+	get resolvedResponse() {
+		return typeof this.response === "function" ? this.response() : this.response;
+	}
+	modify(options) {
+		return new ServerRequestImpl(this.source, this.response, this.upgradeEffect, options.url ?? this.url, options.headers ?? this.headersOverride, "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride);
+	}
+	get originalUrl() {
+		return this.source.url;
+	}
+	get method() {
+		return this.source.method.toUpperCase();
+	}
+	get headers() {
+		this.headersOverride ??= this.source.headers;
+		return this.headersOverride;
+	}
+	multipartEffect;
+	get multipart() {
+		if (this.multipartEffect) return this.multipartEffect;
+		this.multipartEffect = runSync(cached(persisted(this.source, this.source.headers)));
+		return this.multipartEffect;
+	}
+	get multipartStream() {
+		return stream(this.source, this.source.headers);
+	}
+	get upgrade() {
+		return this.upgradeEffect ?? fail(new HttpServerError({ reason: new RequestParseError({
+			request: this,
+			description: "not an upgradeable ServerRequest"
+		}) }));
+	}
+	toString() {
+		return `ServerRequest(${this.method} ${this.url})`;
+	}
+	toJSON() {
+		return inspect(this, {
+			_id: "HttpServerRequest",
+			method: this.method,
+			url: this.originalUrl
+		});
+	}
+};
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerServer = /* @__PURE__ */ flow(make, /* @__PURE__ */ effect(HttpServer));
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerHttpServices = /* @__PURE__ */ mergeAll(layer$1, layerWeak, layer$3);
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layer = (evaluate, options) => mergeAll(layerServer(evaluate, options), layerHttpServices);
+/**
+* @since 1.0.0
+* @category Layers
+*/
+const layerConfig = (evaluate, options) => mergeAll(effect(HttpServer)(flatMap(unwrap$1(options).asEffect(), (options) => make(evaluate, options))), layerHttpServices);
+/**
+* @since 1.0.0
+* @category Testing
+*/
+const layerTest = /* @__PURE__ */ layerTestClient.pipe(/* @__PURE__ */ provide(/* @__PURE__ */ fresh(layer$5).pipe(/* @__PURE__ */ provide(/* @__PURE__ */ succeed$1(RequestInit)({ keepalive: false })))), /* @__PURE__ */ provideMerge(/* @__PURE__ */ layer(Http.createServer, { port: 0 })));
+const handleResponse = (request, response) => {
+	const nodeResponse = request.resolvedResponse;
+	if (nodeResponse.writableEnded) return void_;
+	let headers = response.headers;
+	if (!isEmpty(response.cookies)) {
+		headers = { ...headers };
+		const toSet = toSetCookieHeaders(response.cookies);
+		if (headers["set-cookie"] !== void 0) toSet.push(headers["set-cookie"]);
+		headers["set-cookie"] = toSet;
+	}
+	if (request.method === "HEAD") {
+		nodeResponse.writeHead(response.status, headers);
+		return callback((resume) => {
+			nodeResponse.end(() => resume(void_));
+		});
+	}
+	const body = response.body;
+	switch (body._tag) {
+		case "Empty":
+			nodeResponse.writeHead(response.status, headers);
+			nodeResponse.end();
+			return void_;
+		case "Raw":
+			nodeResponse.writeHead(response.status, headers);
+			if (typeof body.body === "object" && body.body !== null && "pipe" in body.body && typeof body.body.pipe === "function") return tryPromise({
+				try: (signal) => pipeline(body.body, nodeResponse, {
+					signal,
+					end: true
+				}),
+				catch: (cause) => new HttpServerError({ reason: new ResponseError({
+					request,
+					response,
+					description: "Error writing raw response",
+					cause
+				}) })
+			}).pipe(interruptible, tapCause(handleCause(nodeResponse, response)));
+			return callback((resume) => {
+				nodeResponse.end(body.body, () => resume(void_));
+			});
+		case "Uint8Array":
+			nodeResponse.writeHead(response.status, headers);
+			if (body.body.length < 1024 * 1024) {
+				nodeResponse.end(body.body);
+				return void_;
+			}
+			return callback((resume) => {
+				nodeResponse.end(body.body, () => resume(void_));
+			});
+		case "FormData": return suspend(() => {
+			const r = new globalThis.Response(body.formData);
+			nodeResponse.writeHead(response.status, {
+				...headers,
+				...Object.fromEntries(r.headers)
+			});
+			return callback((resume, signal) => {
+				Readable.fromWeb(r.body, { signal }).pipe(nodeResponse).on("error", (cause) => {
+					resume(fail(new HttpServerError({ reason: new ResponseError({
+						request,
+						response,
+						description: "Error writing FormData response",
+						cause
+					}) })));
+				}).once("finish", () => {
+					resume(void_);
+				});
+			}).pipe(interruptible, tapCause(handleCause(nodeResponse, response)));
+		});
+		case "Stream": {
+			nodeResponse.writeHead(response.status, headers);
+			const drainLatch = makeUnsafe$1();
+			nodeResponse.on("drain", () => drainLatch.openUnsafe());
+			return body.stream.pipe(orDie, runForEachArray((array) => {
+				let needDrain = false;
+				for (let i = 0; i < array.length; i++) {
+					const written = nodeResponse.write(array[i]);
+					if (!written && !needDrain) {
+						needDrain = true;
+						drainLatch.closeUnsafe();
+					} else if (written && needDrain) needDrain = false;
+				}
+				if (!needDrain) return void_;
+				return drainLatch.await;
+			}), interruptible, matchCauseEffect({
+				onSuccess: () => sync(() => nodeResponse.end()),
+				onFailure: handleCause(nodeResponse, response)
+			}));
+		}
+	}
+};
+const handleCause = (nodeResponse, originalResponse) => (originalCause) => flatMap(causeResponse(originalCause), ([response, cause]) => {
+	const headersSent = nodeResponse.headersSent;
+	if (!headersSent) nodeResponse.writeHead(response.status);
+	if (!nodeResponse.writableEnded) nodeResponse.end();
+	return failCause(headersSent ? combine(originalCause, die$1(originalResponse)) : cause);
+});
+//#endregion
+export { layer, layerConfig, layerHttpServices, layerServer, layerTest, make, makeHandler, makeUpgradeHandler };
+
+//# sourceMappingURL=NodeHttpServer-D5-EtRwc.mjs.map