srvx 0.1.4 → 0.2.1

package/dist/adapters/bun.d.mts

@@ -0,0 +1,28 @@
+import { ServerOptions, Server, BunFetchandler } from '../types.mjs';
+import * as Bun from 'bun';
+import 'node:http';
+import 'node:net';
+import '@cloudflare/workers-types';
+
+declare const Response: {
+    new (body?: BodyInit | null, init?: ResponseInit): Response;
+    prototype: Response;
+    error(): Response;
+    json(data: any, init?: ResponseInit): Response;
+    redirect(url: string | URL, status?: number): Response;
+};
+declare function serve(options: ServerOptions): BunServer;
+declare class BunServer implements Server<BunFetchandler> {
+    readonly runtime = "bun";
+    readonly options: ServerOptions;
+    readonly bun: Server["bun"];
+    readonly serveOptions: Bun.ServeOptions;
+    readonly fetch: BunFetchandler;
+    constructor(options: ServerOptions);
+    serve(): Promise<Awaited<this>>;
+    get url(): string | undefined;
+    ready(): Promise<Awaited<this>>;
+    close(closeAll?: boolean): Promise<void | undefined>;
+}
+
+export { Response, serve };

package/dist/adapters/bun.mjs

@@ -0,0 +1,52 @@
+import { r as resolvePort } from '../shared/srvx.PbkQy9Ck.mjs';
+import { w as wrapFetch } from '../shared/srvx.DhN4g5wJ.mjs';
+
+const Response = globalThis.Response;
+function serve(options) {
+  return new BunServer(options);
+}
+class BunServer {
+  constructor(options) {
+    this.runtime = "bun";
+    this.bun = {};
+    this.options = options;
+    const fetchHandler = wrapFetch(this, this.options.fetch);
+    this.fetch = (request, server) => {
+      Object.defineProperties(request, {
+        bun: { value: { server }, enumerable: true },
+        remoteAddress: {
+          get: () => server?.requestIP(request)?.address,
+          enumerable: true
+        }
+      });
+      return fetchHandler(request);
+    };
+    this.serveOptions = {
+      hostname: this.options.hostname,
+      reusePort: this.options.reusePort,
+      port: resolvePort(this.options.port, globalThis.process?.env.PORT),
+      ...this.options.bun,
+      fetch: this.fetch
+    };
+    if (!options.manual) {
+      this.serve();
+    }
+  }
+  serve() {
+    if (!this.bun.server) {
+      this.bun.server = Bun.serve(this.serveOptions);
+    }
+    return Promise.resolve(this);
+  }
+  get url() {
+    return this.bun?.server?.url.href;
+  }
+  ready() {
+    return Promise.resolve(this);
+  }
+  close(closeAll) {
+    return Promise.resolve(this.bun?.server?.stop(closeAll));
+  }
+}
+
+export { Response, serve };

package/dist/adapters/cloudflare.d.mts

@@ -0,0 +1,16 @@
+import { ServerOptions, Server } from '../types.mjs';
+import * as CF from '@cloudflare/workers-types';
+import 'node:http';
+import 'node:net';
+import 'bun';
+
+declare const Response: {
+    new (body?: BodyInit | null, init?: ResponseInit): Response;
+    prototype: Response;
+    error(): Response;
+    json(data: any, init?: ResponseInit): Response;
+    redirect(url: string | URL, status?: number): Response;
+};
+declare function serve(options: ServerOptions): Server<CF.ExportedHandlerFetchHandler>;
+
+export { Response, serve };

package/dist/adapters/cloudflare.mjs

@@ -0,0 +1,45 @@
+import { w as wrapFetch } from '../shared/srvx.DhN4g5wJ.mjs';
+
+const Response = globalThis.Response;
+function serve(options) {
+  return new CloudflareServer(options);
+}
+class CloudflareServer {
+  constructor(options) {
+    this.runtime = "cloudflare";
+    this.options = options;
+    const fetchHandler = wrapFetch(
+      this,
+      this.options.fetch
+    );
+    this.fetch = (request, env, context) => {
+      Object.defineProperties(request, {
+        cloudflare: { value: { env, context }, enumerable: true },
+        remoteAddress: {
+          get: () => void 0,
+          enumerable: true
+        }
+      });
+      return fetchHandler(request);
+    };
+    this.serveOptions = {
+      fetch: this.fetch
+    };
+    if (!options.manual) {
+      this.serve();
+    }
+  }
+  serve() {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.fetch(event.request, {}, event));
+    });
+  }
+  ready() {
+    return Promise.resolve().then(() => this);
+  }
+  close() {
+    return Promise.resolve();
+  }
+}
+
+export { Response, serve };

package/dist/adapters/deno.d.mts

@@ -0,0 +1,29 @@
+import { ServerOptions, Server, DenoFetchHandler } from '../types.mjs';
+import 'node:http';
+import 'node:net';
+import 'bun';
+import '@cloudflare/workers-types';
+
+declare const Response: {
+    new (body?: BodyInit | null, init?: ResponseInit): Response;
+    prototype: Response;
+    error(): Response;
+    json(data: any, init?: ResponseInit): Response;
+    redirect(url: string | URL, status?: number): Response;
+};
+declare function serve(options: ServerOptions): DenoServer;
+declare class DenoServer implements Server<DenoFetchHandler> {
+    #private;
+    readonly runtime = "deno";
+    readonly options: ServerOptions;
+    readonly deno: Server["deno"];
+    readonly serveOptions: Deno.ServeTcpOptions;
+    readonly fetch: DenoFetchHandler;
+    constructor(options: ServerOptions);
+    serve(): Promise<this>;
+    get url(): string | undefined;
+    ready(): Promise<Server>;
+    close(): Promise<void | undefined>;
+}
+
+export { Response, serve };

package/dist/adapters/deno.mjs

@@ -0,0 +1,68 @@
+import { r as resolvePort, f as fmtURL } from '../shared/srvx.PbkQy9Ck.mjs';
+import { w as wrapFetch } from '../shared/srvx.DhN4g5wJ.mjs';
+
+const Response = globalThis.Response;
+function serve(options) {
+  return new DenoServer(options);
+}
+class DenoServer {
+  constructor(options) {
+    this.runtime = "deno";
+    this.deno = {};
+    this.options = options;
+    const fetchHandler = wrapFetch(this, this.options.fetch);
+    this.fetch = (request, info) => {
+      Object.defineProperties(request, {
+        deno: { value: { info, server: this.deno?.server }, enumerable: true },
+        remoteAddress: {
+          get: () => info?.remoteAddr?.hostname,
+          enumerable: true
+        }
+      });
+      return fetchHandler(request);
+    };
+    this.serveOptions = {
+      port: resolvePort(this.options.port, globalThis.Deno?.env.get("PORT")),
+      hostname: this.options.hostname,
+      reusePort: this.options.reusePort,
+      ...this.options.deno
+    };
+    if (!options.manual) {
+      this.serve();
+    }
+  }
+  #listeningPromise;
+  #listeningInfo;
+  serve() {
+    if (this.deno?.server) {
+      return Promise.resolve(this.#listeningPromise).then(() => this);
+    }
+    const onListenPromise = Promise.withResolvers();
+    this.#listeningPromise = onListenPromise.promise;
+    this.deno.server = Deno.serve(
+      {
+        ...this.serveOptions,
+        onListen: (info) => {
+          this.#listeningInfo = info;
+          if (this.options.deno?.onListen) {
+            this.options.deno.onListen(info);
+          }
+          onListenPromise.resolve();
+        }
+      },
+      this.fetch
+    );
+    return Promise.resolve(this.#listeningPromise).then(() => this);
+  }
+  get url() {
+    return this.#listeningInfo ? fmtURL(this.#listeningInfo.hostname, this.#listeningInfo.port) : void 0;
+  }
+  ready() {
+    return Promise.resolve(this.#listeningPromise).then(() => this);
+  }
+  close() {
+    return Promise.resolve(this.deno?.server?.shutdown());
+  }
+}
+
+export { Response, serve };

package/dist/adapters/node.d.mts

@@ -0,0 +1,49 @@
+import { ServerOptions, Server, FetchHandler, NodeHttpHandler } from '../types.mjs';
+import NodeHttp__default from 'node:http';
+import 'node:net';
+import 'bun';
+import '@cloudflare/workers-types';
+
+type NodeFastResponse = InstanceType<typeof NodeFastResponse>;
+declare const NodeFastResponse: {
+    new (body?: BodyInit | null, init?: ResponseInit): {
+        "__#4200@#body"?: BodyInit | null;
+        "__#4200@#init"?: ResponseInit;
+        /**
+         * Prepare Node.js response object
+         */
+        nodeResponse(): {
+            status: number;
+            statusText: string;
+            headers: NodeHttp__default.OutgoingHttpHeader[];
+            body: string | Uint8Array<ArrayBufferLike> | ReadableStream<Uint8Array<ArrayBufferLike>> | Buffer<ArrayBufferLike> | DataView<ArrayBufferLike> | null | undefined;
+        };
+        /** Lazy initialized response instance */
+        "__#4200@#responseObj"?: Response;
+        /** Lazy initialized headers instance */
+        "__#4200@#headersObj"?: Headers;
+        clone(): Response;
+        readonly "__#4200@#response": Response;
+        readonly headers: Headers;
+        readonly ok: boolean;
+        readonly redirected: boolean;
+        readonly status: number;
+        readonly statusText: string;
+        readonly type: ResponseType;
+        readonly url: string;
+        "__#4200@#fastBody"<T extends object>(as: new (...args: any[]) => T): T | null | false;
+        readonly body: ReadableStream<Uint8Array> | null;
+        readonly bodyUsed: boolean;
+        arrayBuffer(): Promise<ArrayBuffer>;
+        blob(): Promise<Blob>;
+        bytes(): Promise<Uint8Array>;
+        formData(): Promise<FormData>;
+        text(): Promise<string>;
+        json(): Promise<any>;
+    };
+};
+
+declare function serve(options: ServerOptions): Server;
+declare function toNodeHandler(fetchHandler: FetchHandler): NodeHttpHandler;
+
+export { NodeFastResponse as Response, serve, toNodeHandler };