open-nest 0.0.1 → 0.0.2

package/dist/fetch.d.mts

@@ -0,0 +1,2 @@
+import { a as createFetcher, c as FilesInterceptor, i as Fetcher, l as MultipartLimits, n as CreateHandlerOptions, o as AnyFilesInterceptor, r as FetchAdapter, s as FileInterceptor, t as CorsOptions, u as MultipartOptions } from "./index-DCLeOkkF.mjs";
+export { AnyFilesInterceptor, CorsOptions, CreateHandlerOptions, FetchAdapter, Fetcher, FileInterceptor, FilesInterceptor, type MultipartLimits, type MultipartOptions, createFetcher };

package/dist/fetch.mjs

@@ -0,0 +1,2 @@
+import { a as FilesInterceptor, i as FileInterceptor, n as createFetcher, r as AnyFilesInterceptor, t as FetchAdapter } from "./fetch-Bmr9TEe3.mjs";
+export { AnyFilesInterceptor, FetchAdapter, FileInterceptor, FilesInterceptor, createFetcher };

package/dist/gateway-CrNeg78D.d.mts

@@ -0,0 +1,45 @@
+//#region src/lib/gateway.d.ts
+interface GatewayClient {
+  send(data: string): void;
+  data: {
+    path: string;
+  };
+}
+interface Gateway {
+  path: string;
+  connect?: (client: GatewayClient) => void;
+}
+interface MessageHandler {
+  message: string;
+  callback: (data: unknown) => unknown;
+}
+interface Subscription {
+  unsubscribe(): void;
+}
+interface ResultStream {
+  subscribe(observer: {
+    next: (value: unknown) => void;
+    error?: (error: unknown) => void;
+  }): Subscription;
+}
+/**
+ * Records Nest gateways during `init`. The runtime server performs the upgrade.
+ */
+declare class WsGateway<T extends GatewayClient = GatewayClient> {
+  private readonly gateways;
+  private readonly clients;
+  create(_port: number, options?: {
+    path?: string;
+  }): Gateway;
+  bindClientConnect(server: Gateway, callback: (client: T) => void): void;
+  bindMessageHandlers(client: T, handlers: MessageHandler[], transform: (result: unknown) => ResultStream): void;
+  bindClientDisconnect(client: T, callback: () => void): void;
+  close(): void;
+  matches(pathname: string): boolean;
+  hasGateways(): boolean;
+  open(client: T): void;
+  receive(client: T, raw: string | Uint8Array): void;
+  closed(client: T): void;
+}
+//#endregion
+export { WsGateway as n, GatewayClient as t };

package/dist/gateway-D7PGV2DW.mjs

@@ -0,0 +1,89 @@
+//#region src/lib/gateway.ts
+function gatewayPath(path) {
+	if (!path.startsWith("/")) path = `/${path}`;
+	if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
+	return path;
+}
+/**
+* Records Nest gateways during `init`. The runtime server performs the upgrade.
+*/
+var WsGateway = class {
+	gateways = [];
+	clients = /* @__PURE__ */ new WeakMap();
+	create(_port, options) {
+		const gateway = { path: gatewayPath(options?.path ?? "/") };
+		this.gateways.push(gateway);
+		return gateway;
+	}
+	bindClientConnect(server, callback) {
+		server.connect = callback;
+	}
+	bindMessageHandlers(client, handlers, transform) {
+		const prev = this.clients.get(client);
+		this.clients.set(client, {
+			handlers,
+			transform,
+			subscriptions: prev?.subscriptions ?? [],
+			onClose: prev?.onClose
+		});
+	}
+	bindClientDisconnect(client, callback) {
+		const state = this.clients.get(client);
+		if (!state) return;
+		state.onClose = callback;
+	}
+	close() {}
+	matches(pathname) {
+		const path = gatewayPath(pathname);
+		return this.gateways.some((gateway) => gateway.path === path);
+	}
+	hasGateways() {
+		return this.gateways.length > 0;
+	}
+	open(client) {
+		this.gateways.find((item) => item.path === client.data.path)?.connect?.(client);
+	}
+	receive(client, raw) {
+		const state = this.clients.get(client);
+		if (!state) return;
+		let event;
+		let data;
+		try {
+			const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+			const parsed = JSON.parse(text);
+			if (typeof parsed.event !== "string") return;
+			event = parsed.event;
+			data = parsed.data;
+		} catch {
+			return;
+		}
+		const handler = state.handlers.find((item) => item.message === event);
+		if (!handler) return;
+		let stream;
+		try {
+			stream = state.transform(handler.callback(data));
+		} catch {
+			return;
+		}
+		const subscription = stream.subscribe({
+			next: (value) => {
+				if (value === void 0) return;
+				client.send(JSON.stringify({
+					event,
+					data: value
+				}));
+			},
+			error: () => {}
+		});
+		state.subscriptions.push(subscription);
+	}
+	closed(client) {
+		const state = this.clients.get(client);
+		if (!state) return;
+		for (const subscription of state.subscriptions) subscription.unsubscribe();
+		state.onClose?.();
+		this.clients.delete(client);
+	}
+};
+//#endregion
+export { gatewayPath as n, WsGateway as t };

package/dist/index-DCLeOkkF.d.mts

@@ -0,0 +1,217 @@
+import { INestApplication, NestApplicationOptions, NestInterceptor, RequestMethod, Type, VersioningOptions } from "@nestjs/common";
+import { AbstractHttpAdapter } from "@nestjs/core";
+import { VersionValue } from "@nestjs/common/interfaces/version-options.interface";
+//#region src/lib/events.d.ts
+type Listener = (...args: unknown[]) => void;
+declare class Emitter {
+  private listeners;
+  on(event: string, fn: Listener): this;
+  once(event: string, fn: Listener): this;
+  removeListener(event: string, fn: Listener): this;
+  emit(event: string, ...args: unknown[]): void;
+}
+//#endregion
+//#region src/lib/request.d.ts
+declare class FetchSocket extends Emitter {
+  destroyed: boolean;
+  readable: boolean;
+  writable: boolean;
+  setKeepAlive(): void;
+  setNoDelay(): void;
+  setTimeout(): void;
+  close(): void;
+}
+interface UploadedFile {
+  fieldname: string;
+  originalname: string;
+  encoding: string;
+  mimetype: string;
+  buffer: Uint8Array;
+  size: number;
+}
+interface FetchRequest {
+  raw: Request;
+  method: string;
+  url: string;
+  originalUrl: string;
+  path: string;
+  headers: Record<string, string | string[]>;
+  query: Record<string, string | string[]>;
+  params: Record<string, string>;
+  body: unknown;
+  /**
+   * Set when a parser has consumed the body, or when a middleware wants later
+   * parsers to leave the stream unread.
+   */
+  _body?: boolean;
+  rawBody?: Uint8Array;
+  ip: string;
+  hostname: string;
+  socket: FetchSocket;
+  file?: UploadedFile;
+  files?: UploadedFile[];
+}
+//#endregion
+//#region src/lib/response.d.ts
+declare class FetchResponse extends Emitter {
+  statusCode: number;
+  headersSent: boolean;
+  writableEnded: boolean;
+  destroyed: boolean;
+  writable: boolean;
+  readonly socket: FetchSocket;
+  private readonly headers;
+  private controller;
+  private wrote;
+  private streamClosed;
+  private readonly drainWaiters;
+  private resolveReady;
+  private readonly readyPromise;
+  readonly stream: ReadableStream<Uint8Array<ArrayBufferLike>>;
+  constructor(socket: FetchSocket);
+  ready(): Promise<Response>;
+  setHeader(name: string, value: string): void;
+  appendHeader(name: string, value: string): void;
+  getHeader(name: string): string | null;
+  removeHeader(name: string): void;
+  getHeaders(): Record<string, string>;
+  status(code: number): this;
+  writeHead(status: number, headers?: Record<string, string | number | readonly string[]>): void;
+  flushHeaders(): void;
+  write(chunk: unknown, encoding?: BufferEncoding | ((error?: Error | null) => void), cb?: (error?: Error | null) => void): boolean;
+  end(chunk?: unknown, encoding?: BufferEncoding | (() => void), cb?: () => void): void;
+  private closeStream;
+  send(body?: string): void;
+  json(body: unknown): void;
+  destroy(): void;
+  private commit;
+}
+//#endregion
+//#region src/lib/router.d.ts
+type Next = (err?: unknown) => void;
+type Handler = (req: FetchRequest, res: FetchResponse, next: Next) => unknown;
+type ErrorHandler = (err: unknown, req: FetchRequest, res: FetchResponse, next: Next) => unknown;
+type Callback = Handler | ErrorHandler;
+declare class Router {
+  private layers;
+  use(handler: Handler): void;
+  use(path: string | string[], handler: Handler): void;
+  use(handler: ErrorHandler): void;
+  use(path: string | string[], handler: ErrorHandler): void;
+  get(path: string | Handler, handler?: Handler): void;
+  post(path: string | Handler, handler?: Handler): void;
+  head(path: string | Handler, handler?: Handler): void;
+  delete(path: string | Handler, handler?: Handler): void;
+  put(path: string | Handler, handler?: Handler): void;
+  patch(path: string | Handler, handler?: Handler): void;
+  options(path: string | Handler, handler?: Handler): void;
+  all(path: string | Handler, handler?: Handler): void;
+  propfind(path: string | Handler, handler?: Handler): void;
+  proppatch(path: string | Handler, handler?: Handler): void;
+  mkcol(path: string | Handler, handler?: Handler): void;
+  copy(path: string | Handler, handler?: Handler): void;
+  move(path: string | Handler, handler?: Handler): void;
+  lock(path: string | Handler, handler?: Handler): void;
+  unlock(path: string | Handler, handler?: Handler): void;
+  search(path: string | Handler, handler?: Handler): void;
+  query(path: string | Handler, handler?: Handler): void;
+  add(method: string | null, path: string | Callback, handler: Callback | undefined, kind: "exact" | "prefix"): void;
+  handle(req: FetchRequest, res: FetchResponse): void;
+}
+//#endregion
+//#region src/lib/multipart/index.d.ts
+interface MultipartLimits {
+  fileSize?: number;
+  files?: number;
+  fields?: number;
+}
+interface MultipartOptions {
+  limits?: MultipartLimits;
+}
+declare function FileInterceptor(field: string, options?: MultipartOptions): Type<NestInterceptor>;
+declare function FilesInterceptor(field: string, maxCount?: number, options?: MultipartOptions): Type<NestInterceptor>;
+declare function AnyFilesInterceptor(options?: MultipartOptions): Type<NestInterceptor>;
+//#endregion
+//#region src/fetch/index.d.ts
+interface CorsOptions {
+  origin?: boolean | string | RegExp | Array<string | RegExp> | ((origin: string) => boolean);
+  methods?: string | string[];
+  allowedHeaders?: string | string[];
+  exposedHeaders?: string | string[];
+  credentials?: boolean;
+  maxAge?: number;
+}
+/**
+ * Options for {@link createFetcher}.
+ */
+interface CreateHandlerOptions {
+  /**
+   * Root Nest module.
+   */
+  module: Type<unknown>;
+  /**
+   * Runs after the app is created and before init.
+   */
+  configure?: (app: INestApplication) => void | Promise<void>;
+  /**
+   * Forwarded to `NestFactory.create`.
+   */
+  opts?: NestApplicationOptions;
+  /**
+   * Max JSON or urlencoded body size in bytes. Defaults to 1 MiB.
+   */
+  bodyLimit?: number;
+}
+interface Fetcher {
+  (request: Request): Promise<Response>;
+  /**
+   * Resolves the underlying Nest app instance.
+   */
+  app(): Promise<INestApplication>;
+  /**
+   * Closes the underlying Nest app.
+   */
+  close(): Promise<void>;
+}
+declare class FetchAdapter extends AbstractHttpAdapter<undefined, FetchRequest, FetchResponse> {
+  private bodyLimit;
+  private rawBody;
+  private shuttingDown;
+  private parsersReady;
+  constructor();
+  protected get router(): Router;
+  handle(input: Request): Promise<Response>;
+  listen(): never;
+  initHttpServer(options: NestApplicationOptions): void;
+  beforeClose(): void;
+  close(): void;
+  useStaticAssets(_root?: string, _options?: {
+    prefix?: string;
+    index?: string | false;
+  }): this;
+  setViewEngine(): this;
+  getRequestHostname(request: FetchRequest): string;
+  getRequestMethod(request: FetchRequest): string;
+  getRequestUrl(request: FetchRequest): string;
+  status(response: FetchResponse, statusCode: number): FetchResponse;
+  reply(response: FetchResponse, body: unknown, statusCode?: number): void;
+  end(response: FetchResponse, message?: string): void;
+  render(): never;
+  redirect(response: FetchResponse, statusCode: number, url: string): void;
+  isHeadersSent(response: FetchResponse): boolean;
+  getHeader(response: FetchResponse, name: string): string | null;
+  setHeader(response: FetchResponse, name: string, value: string): void;
+  appendHeader(response: FetchResponse, name: string, value: string): void;
+  setErrorHandler(handler: Function): void;
+  setNotFoundHandler(handler: Function): void;
+  getType(): string;
+  isRouteOrderSensitive(): boolean;
+  applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): (req: FetchRequest, res: FetchResponse, next: () => void) => Function;
+  createMiddlewareFactory(method: RequestMethod): (path: string, callback: Function) => void;
+  registerParserMiddleware(): void;
+  enableCors(options?: CorsOptions): void;
+  setBodyLimit(limit: number): void;
+}
+declare function createFetcher({ module, configure, opts, bodyLimit }: CreateHandlerOptions, adapter?: FetchAdapter): Fetcher;
+//#endregion
+export { createFetcher as a, FilesInterceptor as c, Fetcher as i, MultipartLimits as l, CreateHandlerOptions as n, AnyFilesInterceptor as o, FetchAdapter as r, FileInterceptor as s, CorsOptions as t, MultipartOptions as u };

package/dist/node.d.mts

@@ -0,0 +1,53 @@
+import { i as Fetcher, r as FetchAdapter } from "./index-DCLeOkkF.mjs";
+import { n as WsGateway, t as GatewayClient } from "./gateway-CrNeg78D.mjs";
+import { INestApplication, NestApplicationOptions, Type } from "@nestjs/common";
+//#region src/adapters/node/index.d.ts
+interface NodeSocket extends GatewayClient {
+  data: {
+    path: string;
+  };
+}
+/**
+ * Records Nest gateways during `init`. `node:http` performs the upgrade.
+ */
+export declare class NodeWsAdapter extends WsGateway<NodeSocket> {
+  constructor();
+  dispose(): Promise<void>;
+}
+/**
+ * Fetch adapter plus static files via `node:fs`.
+ */
+export declare class NodeAdapter extends FetchAdapter {
+  useStaticAssets(root?: string, options?: {
+    prefix?: string;
+    index?: string | false;
+  }): this;
+}
+export interface CreateNodeServerOptions {
+  /**
+   * Root Nest module.
+   */
+  module: Type<unknown>;
+  /**
+   * Port passed to `node:http`. `0` asks the OS for a free port.
+   */
+  port?: number;
+  /**
+   * Runs after the app is created and before init.
+   */
+  configure?: (app: INestApplication) => void | Promise<void>;
+  /**
+   * Forwarded to `NestFactory.create`.
+   */
+  opts?: NestApplicationOptions;
+}
+export interface NodeServer {
+  port: number;
+  fetch: Fetcher;
+  close(): Promise<void>;
+}
+/**
+ * Boots a Nest app and serves it with `node:http`, including WebSocket upgrades.
+ */
+export declare function createNodeServer({ module, port, configure, opts }: CreateNodeServerOptions): Promise<NodeServer>;
+//#endregion

package/dist/node.mjs

@@ -0,0 +1,190 @@
+import { n as createFetcher, t as FetchAdapter } from "./fetch-Bmr9TEe3.mjs";
+import { n as gatewayPath, t as WsGateway } from "./gateway-D7PGV2DW.mjs";
+import { Readable } from "node:stream";
+import { extname, resolve, sep } from "node:path";
+import { openAsBlob } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { WebSocketServer } from "ws";
+//#region src/adapters/node/index.ts
+const adapters = [];
+/**
+* Records Nest gateways during `init`. `node:http` performs the upgrade.
+*/
+var NodeWsAdapter = class extends WsGateway {
+	constructor() {
+		super();
+		adapters.push(this);
+	}
+	async dispose() {
+		const index = adapters.indexOf(this);
+		if (index !== -1) adapters.splice(index, 1);
+	}
+};
+/**
+* Fetch adapter plus static files via `node:fs`.
+*/
+var NodeAdapter = class extends FetchAdapter {
+	useStaticAssets(root, options) {
+		if (!root) return this;
+		const prefix = options?.prefix ?? "/";
+		const index = options?.index === void 0 ? "index.html" : options.index;
+		const rootResolved = resolve(root);
+		this.router.use(prefix, async (req, res, next) => {
+			if (req.method !== "GET" && req.method !== "HEAD") return next();
+			let relative;
+			try {
+				relative = decodeURIComponent(req.path);
+			} catch {
+				return next();
+			}
+			if (relative === "/") {
+				if (index === false) return next();
+				relative = index;
+			} else relative = relative.replace(/^\//, "");
+			const target = resolve(rootResolved, relative);
+			if (target !== rootResolved && !target.startsWith(rootResolved + sep)) return next();
+			let size;
+			try {
+				const info = await stat(target);
+				if (!info.isFile()) return next();
+				size = info.size;
+			} catch {
+				return next();
+			}
+			const type = contentType(target);
+			const blob = await openAsBlob(target);
+			res.setHeader("content-type", type);
+			res.setHeader("content-length", String(size));
+			if (req.method === "HEAD") {
+				res.end();
+				return;
+			}
+			const reader = blob.stream().getReader();
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				res.write(value);
+			}
+			res.end();
+		});
+		return this;
+	}
+};
+function contentType(file) {
+	switch (extname(file).toLowerCase()) {
+		case ".html": return "text/html; charset=utf-8";
+		case ".txt": return "text/plain; charset=utf-8";
+		case ".json": return "application/json";
+		case ".css": return "text/css; charset=utf-8";
+		case ".js": return "text/javascript; charset=utf-8";
+		case ".svg": return "image/svg+xml";
+		case ".png": return "image/png";
+		case ".jpg":
+		case ".jpeg": return "image/jpeg";
+		case ".webp": return "image/webp";
+		case ".pdf": return "application/pdf";
+		case ".wasm": return "application/wasm";
+		default: return "application/octet-stream";
+	}
+}
+/**
+* Boots a Nest app and serves it with `node:http`, including WebSocket upgrades.
+*/
+async function createNodeServer({ module, port, configure, opts }) {
+	const fallback = new NodeWsAdapter();
+	const seen = new Set(adapters);
+	const fetcher = createFetcher({
+		module,
+		opts,
+		configure: async (app) => {
+			app.useWebSocketAdapter(fallback);
+			await configure?.(app);
+		}
+	}, new NodeAdapter());
+	await fetcher.app();
+	const active = [...adapters].reverse().find((adapter) => !seen.has(adapter) && adapter.hasGateways()) ?? fallback;
+	const sockets = new WebSocketServer({ noServer: true });
+	const server = createServer((req, res) => {
+		writeFetch(fetcher, req, res);
+	});
+	server.on("upgrade", (req, socket, head) => {
+		const pathname = gatewayPath(new URL(req.url ?? "/", "http://localhost").pathname);
+		if (!active.matches(pathname)) {
+			socket.destroy();
+			return;
+		}
+		sockets.handleUpgrade(req, socket, head, (ws) => {
+			const client = {
+				data: { path: pathname },
+				send(data) {
+					ws.send(data);
+				}
+			};
+			active.open(client);
+			ws.on("message", (data) => {
+				const raw = typeof data === "string" ? data : Array.isArray(data) ? Buffer.concat(data) : data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+				active.receive(client, raw);
+			});
+			ws.on("close", () => {
+				active.closed(client);
+			});
+		});
+	});
+	await new Promise((resolve) => {
+		server.listen(port ?? 3e3, "127.0.0.1", () => resolve());
+	});
+	const address = server.address();
+	return {
+		port: typeof address === "object" && address ? address.port : port ?? 3e3,
+		fetch: fetcher,
+		close: async () => {
+			for (const client of sockets.clients) client.terminate();
+			await new Promise((resolve, reject) => {
+				sockets.close((error) => error ? reject(error) : resolve());
+			});
+			server.closeAllConnections();
+			await new Promise((resolve, reject) => {
+				server.close((error) => error ? reject(error) : resolve());
+			});
+			await fetcher.close();
+		}
+	};
+}
+async function writeFetch(fetcher, req, res) {
+	try {
+		const response = await fetcher(toRequest(req));
+		const headers = Object.fromEntries(response.headers.entries());
+		res.writeHead(response.status, headers);
+		if (!response.body) {
+			res.end();
+			return;
+		}
+		await new Promise((resolve, reject) => {
+			Readable.fromWeb(response.body).pipe(res).on("finish", () => resolve()).on("error", reject);
+		});
+	} catch {
+		if (!res.headersSent) res.writeHead(500);
+		res.end();
+	}
+}
+function toRequest(req) {
+	const host = req.headers.host ?? "127.0.0.1";
+	const url = new URL(req.url ?? "/", `http://${host}`);
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(req.headers)) {
+		if (value == null) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+		else headers.set(name, value);
+	}
+	const method = req.method ?? "GET";
+	const bodyless = method === "GET" || method === "HEAD";
+	return new Request(url.href, {
+		method,
+		headers,
+		body: bodyless ? void 0 : Readable.toWeb(req),
+		duplex: "half"
+	});
+}
+//#endregion
+export { NodeAdapter, NodeWsAdapter, createNodeServer };

package/dist/workers.d.mts

@@ -0,0 +1,38 @@
+import { i as Fetcher, n as CreateHandlerOptions } from "./index-DCLeOkkF.mjs";
+//#region src/adapters/workers/index.d.ts
+/**
+ * The `ctx` argument from a Worker `fetch` handler.
+ */
+export interface WorkerExecutionContext {
+  waitUntil(promise: Promise<unknown>): void;
+  passThroughOnException(): void;
+  readonly props?: unknown;
+}
+/**
+ * Bindings and the raw execution context for the request in flight.
+ */
+export interface WorkerContext<Env> {
+  env: Env;
+  ctx: WorkerExecutionContext;
+}
+/**
+ * Bindings and execution context for the current Worker request.
+ */
+export declare function workerContext<Env>(): WorkerContext<Env>;
+export interface WorkerFetcher<Env> {
+  (request: Request, env: Env, ctx: WorkerExecutionContext): Promise<Response>;
+  /**
+   * Resolves the underlying Nest app instance.
+   */
+  app: Fetcher["app"];
+  /**
+   * Closes the underlying Nest app.
+   */
+  close: Fetcher["close"];
+}
+/**
+ * `createFetcher` whose handler also receives Worker bindings and `ctx`.
+ * `workerContext()` reads them for the duration of the request.
+ */
+export declare function createWorkerFetcher<Env>(options: CreateHandlerOptions): WorkerFetcher<Env>;
+//#endregion

package/dist/workers.mjs

@@ -0,0 +1,28 @@
+import { n as createFetcher } from "./fetch-Bmr9TEe3.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/adapters/workers/index.ts
+const storage = new AsyncLocalStorage();
+/**
+* Bindings and execution context for the current Worker request.
+*/
+function workerContext() {
+	const context = storage.getStore();
+	if (!context) throw new Error("Called outside a worker request.");
+	return context;
+}
+/**
+* `createFetcher` whose handler also receives Worker bindings and `ctx`.
+* `workerContext()` reads them for the duration of the request.
+*/
+function createWorkerFetcher(options) {
+	const fetcher = createFetcher(options);
+	const handler = (async (request, env, ctx) => storage.run({
+		env,
+		ctx
+	}, () => fetcher(request)));
+	handler.app = () => fetcher.app();
+	handler.close = () => fetcher.close();
+	return handler;
+}
+//#endregion
+export { createWorkerFetcher, workerContext };