elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/universal/constants.d.ts

@@ -1,6 +1,7 @@
 //#region src/universal/constants.d.ts
 declare const isBun: boolean;
+declare const isFastly: boolean;
 declare const isCloudflareWorker: boolean;
 declare const hasHeaderShorthand: boolean;
 //#endregion
-export { hasHeaderShorthand, isBun, isCloudflareWorker };
+export { hasHeaderShorthand, isBun, isCloudflareWorker, isFastly };

package/dist/universal/constants.js

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/universal/constants.ts
 const isBun = typeof Bun !== "undefined";
+const isFastly = typeof fastly !== "undefined";
 const isCloudflareWorker = (() => {
 	try {
 		if (typeof caches !== "undefined" && typeof caches.default !== "undefined") return true;
@@ -16,4 +17,5 @@ const hasHeaderShorthand = isBun ? "toJSON" in new Headers() : false;
 //#endregion
 exports.hasHeaderShorthand = hasHeaderShorthand;
 exports.isBun = isBun;
-exports.isCloudflareWorker = isCloudflareWorker;
+exports.isCloudflareWorker = isCloudflareWorker;
+exports.isFastly = isFastly;

package/dist/universal/constants.mjs

@@ -1,5 +1,6 @@
 //#region src/universal/constants.ts
 const isBun = typeof Bun !== "undefined";
+const isFastly = typeof fastly !== "undefined";
 const isCloudflareWorker = (() => {
 	try {
 		if (typeof caches !== "undefined" && typeof caches.default !== "undefined") return true;
@@ -12,4 +13,4 @@ const isCloudflareWorker = (() => {
 const hasHeaderShorthand = isBun ? "toJSON" in new Headers() : false;
 
 //#endregion
-export { hasHeaderShorthand, isBun, isCloudflareWorker };
+export { hasHeaderShorthand, isBun, isCloudflareWorker, isFastly };

package/dist/universal/env.js

@@ -1,11 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_universal_constants = require('./constants.js');
 const require_utils = require('../utils.js');
 
 //#region src/universal/env.ts
 const nodeEnv = typeof process !== "undefined" && process?.env ? process.env : void 0;
-const env = require_universal_constants.isBun ? Bun.env : nodeEnv ?? require_utils.nullObject();
-const hasReadableEnv = require_universal_constants.isBun || nodeEnv !== void 0;
+const env = nodeEnv ?? require_utils.nullObject();
+const hasReadableEnv = nodeEnv !== void 0;
 
 //#endregion
 exports.env = env;

package/dist/universal/env.mjs

@@ -1,10 +1,9 @@
-import { isBun } from "./constants.mjs";
 import { nullObject } from "../utils.mjs";
 
 //#region src/universal/env.ts
 const nodeEnv = typeof process !== "undefined" && process?.env ? process.env : void 0;
-const env = isBun ? Bun.env : nodeEnv ?? nullObject();
-const hasReadableEnv = isBun || nodeEnv !== void 0;
+const env = nodeEnv ?? nullObject();
+const hasReadableEnv = nodeEnv !== void 0;
 
 //#endregion
 export { env, hasReadableEnv };

package/dist/universal/file.d.ts

@@ -37,8 +37,6 @@ declare const mime: {
   readonly ppt: "application/vnd.ms-powerpoint";
   readonly pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
 };
-/** @internal exported for test/universal/file-extension.test.ts */
-declare function getFileExtension(path: string): string;
 /**
  * Serve a file from a path as the response.
  */
@@ -47,11 +45,15 @@ declare class ElysiaFile {
   #private;
   path: string;
   constructor(path: string);
+  /**
+   * Brand check on the private field: true for subclasses, and unlike
+   * `instanceof` it never walks the prototype chain, so no user trap runs
+   */
+  static isElysiaFile(value: unknown): value is ElysiaFile;
   get stats(): Promise<_$node_fs0.Stats> | undefined;
   get value(): BunFile | _$node_fs0.ReadStream | undefined;
   slice(start: number, end: number): BunFile | _$node_fs0.ReadStream | undefined;
   get type(): any;
-  get length(): number | Promise<number>;
 }
 //#endregion
-export { ElysiaFile, file, getFileExtension, mime };
+export { ElysiaFile, file, mime };

package/dist/universal/file.js

@@ -41,20 +41,14 @@ const mime = {
 	ppt: `${application}vnd.ms-powerpoint`,
 	pptx: `${msft365}presentationml.presentation`
 };
-/** @internal exported for test/universal/file-extension.test.ts */
-function getFileExtension(path) {
-	const index = path.lastIndexOf(".");
-	if (index === -1) return "";
-	return path.slice(index + 1).toLowerCase();
-}
 /**
 * Serve a file from a path as the response.
 */
 const file = (path) => new ElysiaFile(path);
 let createReadStream;
 let stat;
-function warnMissing(name) {
-	console.warn(/* @__PURE__ */ new Error(`[Elysia] \`file\` require \`fs${name ? "." + name : ""}\` ${name?.includes(".") ? "module " : ""}which is not available in this environment`));
+function warnMissing() {
+	console.warn(/* @__PURE__ */ new Error("[Elysia] `file` require `fs` which is not available in this environment"));
 }
 var ElysiaFile = class {
 	#value;
@@ -79,6 +73,13 @@ var ElysiaFile = class {
 			stat = fs.promises.stat;
 		}
 	}
+	/**
+	* Brand check on the private field: true for subclasses, and unlike
+	* `instanceof` it never walks the prototype chain, so no user trap runs
+	*/
+	static isElysiaFile(value) {
+		return typeof value === "object" && value !== null && #value in value;
+	}
 	get stats() {
 		if (require_universal_constants.isBun || !stat) return;
 		const value = stat(this.path);
@@ -101,13 +102,8 @@ var ElysiaFile = class {
 		return stream;
 	}
 	get type() {
-		return mime[getFileExtension(this.path)] || "application/octet-stream";
-	}
-	get length() {
-		if (require_universal_constants.isBun) return this.#value.size;
-		const value = this.stats?.then((x) => x.size);
-		value?.catch(() => {});
-		return value ?? 0;
+		const index = this.path.lastIndexOf(".");
+		return mime[index === -1 ? "" : this.path.slice(index + 1).toLowerCase()] || "application/octet-stream";
 	}
 };
 Object.defineProperty(ElysiaFile, "name", { value: "ElysiaFile" });
@@ -115,5 +111,4 @@ Object.defineProperty(ElysiaFile, "name", { value: "ElysiaFile" });
 //#endregion
 exports.ElysiaFile = ElysiaFile;
 exports.file = file;
-exports.getFileExtension = getFileExtension;
 exports.mime = mime;

package/dist/universal/file.mjs

@@ -40,20 +40,14 @@ const mime = {
 	ppt: `${application}vnd.ms-powerpoint`,
 	pptx: `${msft365}presentationml.presentation`
 };
-/** @internal exported for test/universal/file-extension.test.ts */
-function getFileExtension(path) {
-	const index = path.lastIndexOf(".");
-	if (index === -1) return "";
-	return path.slice(index + 1).toLowerCase();
-}
 /**
 * Serve a file from a path as the response.
 */
 const file = (path) => new ElysiaFile(path);
 let createReadStream;
 let stat;
-function warnMissing(name) {
-	console.warn(/* @__PURE__ */ new Error(`[Elysia] \`file\` require \`fs${name ? "." + name : ""}\` ${name?.includes(".") ? "module " : ""}which is not available in this environment`));
+function warnMissing() {
+	console.warn(/* @__PURE__ */ new Error("[Elysia] `file` require `fs` which is not available in this environment"));
 }
 var ElysiaFile = class {
 	#value;
@@ -78,6 +72,13 @@ var ElysiaFile = class {
 			stat = fs.promises.stat;
 		}
 	}
+	/**
+	* Brand check on the private field: true for subclasses, and unlike
+	* `instanceof` it never walks the prototype chain, so no user trap runs
+	*/
+	static isElysiaFile(value) {
+		return typeof value === "object" && value !== null && #value in value;
+	}
 	get stats() {
 		if (isBun || !stat) return;
 		const value = stat(this.path);
@@ -100,16 +101,11 @@ var ElysiaFile = class {
 		return stream;
 	}
 	get type() {
-		return mime[getFileExtension(this.path)] || "application/octet-stream";
-	}
-	get length() {
-		if (isBun) return this.#value.size;
-		const value = this.stats?.then((x) => x.size);
-		value?.catch(() => {});
-		return value ?? 0;
+		const index = this.path.lastIndexOf(".");
+		return mime[index === -1 ? "" : this.path.slice(index + 1).toLowerCase()] || "application/octet-stream";
 	}
 };
 Object.defineProperty(ElysiaFile, "name", { value: "ElysiaFile" });
 
 //#endregion
-export { ElysiaFile, file, getFileExtension, mime };
+export { ElysiaFile, file, mime };

package/dist/universal/index.d.ts

@@ -1,5 +1,5 @@
+import { isProduction } from "./is-production.js";
+import { ErrorLike, GenericServeOptions, ListenCallback, Serve, ServeOptions, Server, ServerWebSocketSendStatus, SocketAddress } from "./server.js";
 import { file } from "./file.js";
 import { env } from "./env.js";
-import { ErrorLike, GenericServeOptions, ListenCallback, Serve, ServeOptions, Server, ServerWebSocketSendStatus, SocketAddress } from "./server.js";
-import { isProduction } from "./is-production.js";
 export { type ErrorLike, type GenericServeOptions, type ListenCallback, type Serve, type ServeOptions, type Server, type ServerWebSocketSendStatus, type SocketAddress, env, file, isProduction };

package/dist/universal/is-production.d.ts

@@ -1,5 +1,4 @@
 //#region src/universal/is-production.d.ts
-declare const computeIsProduction: (readable: boolean, nodeEnv?: string, elysiaEnv?: string) => boolean;
 declare const isProduction: () => boolean;
 //#endregion
-export { computeIsProduction, isProduction };
+export { isProduction };

package/dist/universal/is-production.js

@@ -2,9 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_env = require('./env.js');
 
 //#region src/universal/is-production.ts
-const computeIsProduction = (readable, nodeEnv, elysiaEnv) => !readable || (nodeEnv ?? elysiaEnv) === "production";
-const isProduction = () => computeIsProduction(require_universal_env.hasReadableEnv, require_universal_env.env.NODE_ENV, require_universal_env.env.ENV);
+const isProduction = () => !require_universal_env.hasReadableEnv || (require_universal_env.env.NODE_ENV ?? require_universal_env.env.ENV) === "production";
 
 //#endregion
-exports.computeIsProduction = computeIsProduction;
 exports.isProduction = isProduction;

package/dist/universal/is-production.mjs

@@ -1,8 +1,7 @@
 import { env, hasReadableEnv } from "./env.mjs";
 
 //#region src/universal/is-production.ts
-const computeIsProduction = (readable, nodeEnv, elysiaEnv) => !readable || (nodeEnv ?? elysiaEnv) === "production";
-const isProduction = () => computeIsProduction(hasReadableEnv, env.NODE_ENV, env.ENV);
+const isProduction = () => !hasReadableEnv || (env.NODE_ENV ?? env.ENV) === "production";
 
 //#endregion
-export { computeIsProduction, isProduction };
+export { isProduction };

package/dist/universal/server.d.ts

@@ -8,96 +8,16 @@ interface ErrorLike extends Error {
   syscall?: string;
 }
 interface GenericServeOptions {
-  /**
-   * What URI should be used to make {@link Request.url} absolute?
-   *
-   * By default, looks at {@link hostname}, {@link port}, and whether or not SSL is enabled to generate one
-   *
-   * @example
-   * ```js
-   * "http://my-app.com"
-   * ```
-   *
-   * @example
-   * ```js
-   * "https://wongmjane.com/"
-   * ```
-   *
-   * This should be the public, absolute URL – include the protocol and {@link hostname}. If the port isn't 80 or 443, then include the {@link port} too.
-   *
-   * @example
-   * "http://localhost:3000"
-   */
-  /**
-   * What is the maximum size of a request body? (in bytes)
-   *
-   * @default 1024 * 1024 * 128 // 128MB
-   */
   maxRequestBodySize?: number;
-  /**
-   * Render contextual errors? This enables bun's error page
-   * @default process.env.NODE_ENV !== 'production'
-   */
   development?: boolean;
   error?: (this: Server, request: ErrorLike) => Response | Promise<Response> | undefined | Promise<undefined>;
-  /**
-   * Uniquely identify a server instance with an ID
-   *
-   * ### When bun is started with the `--hot` flag
-   *
-   * This string will be used to hot reload the server without interrupting
-   * pending requests or websockets. If not provided, a value will be
-   * generated. To disable hot reloading, set this value to `null`.
-   *
-   * ### When bun is not started with the `--hot` flag
-   *
-   * This string will currently do nothing. But in the future it could be useful for logs or metrics.
-   */
   id?: string | null;
 }
 interface ServeOptions extends GenericServeOptions {
-  /**
-   * What port should the server listen on?
-   * @default process.env.PORT || "3000"
-   */
   port?: string | number;
-  /**
-   * If the `SO_REUSEPORT` flag should be set.
-   *
-   * This allows multiple processes to bind to the same port, which is useful for load balancing.
-   *
-   * @default false
-   */
   reusePort?: boolean;
-  /**
-   * What hostname should the server listen on?
-   *
-   * @default
-   * ```js
-   * "0.0.0.0" // listen on all interfaces
-   * ```
-   * @example
-   *  ```js
-   * "127.0.0.1" // Only listen locally
-   * ```
-   * @example
-   * ```js
-   * "remix.run" // Only listen on remix.run
-   * ````
-   *
-   * note: hostname should not include a {@link port}
-   */
   hostname?: string;
-  /**
-   * If set, the HTTP server will listen on a unix socket instead of a port.
-   * (Cannot be used with hostname+port)
-   */
   unix?: never;
-  /**
-   * Handle HTTP requests
-   *
-   * Respond to {@link Request} objects with a {@link Response} object.
-   */
   fetch(this: Server, request: Request, server: Server): Response | Promise<Response>;
   routes: Record<string, Function | Response | Record<string, Function | Response>>;
 }
@@ -105,221 +25,29 @@ type Serve = Equal<Serve$1.Options<unknown>, unknown> extends false ? Serve$1.Op
 type Server = Equal<Server$1<unknown>, unknown> extends false ? Server$1<unknown> : ServerOptions;
 type ServerWebSocketSendStatus = number;
 interface SocketAddress {
-  /**
-   * The IP address of the client.
-   */
   address: string;
-  /**
-   * The port of the client.
-   */
   port: number;
-  /**
-   * The IP family ("IPv4" or "IPv6").
-   */
   family: 'IPv4' | 'IPv6';
 }
 interface ServerOptions extends Disposable {
-  /**
-   * Stop listening to prevent new connections from being accepted.
-   *
-   * By default, it does not cancel in-flight requests or websockets. That means it may take some time before all network activity stops.
-   *
-   * @param closeActiveConnections Immediately terminate in-flight requests, websockets, and stop accepting new connections.
-   * @default false
-   */
   stop(closeActiveConnections?: boolean): void;
-  /**
-   * Update the `fetch` and `error` handlers without restarting the server.
-   *
-   * This is useful if you want to change the behavior of your server without
-   * restarting it or for hot reloading.
-   *
-   * @example
-   *
-   * ```js
-   * // create the server
-   * const server = Bun.serve({
-   *  fetch(request) {
-   *    return new Response("Hello World v1")
-   *  }
-   * });
-   *
-   * // Update the server to return a different response
-   * server.reload({
-   *   fetch(request) {
-   *     return new Response("Hello World v2")
-   *   }
-   * });
-   * ```
-   *
-   * Passing other options such as `port` or `hostname` won't do anything.
-   */
   reload(options: Serve): void;
-  /**
-   * Mock the fetch handler for a running server.
-   *
-   * This feature is not fully implemented yet. It doesn't normalize URLs
-   * consistently in all cases and it doesn't yet call the `error` handler
-   * consistently. This needs to be fixed
-   */
   fetch(request: Request | string): Response | Promise<Response>;
-  /**
-   * Upgrade a {@link Request} to a {@link ServerWebSocket}
-   *
-   * @param request The {@link Request} to upgrade
-   * @param options Pass headers or attach data to the {@link ServerWebSocket}
-   *
-   * @returns `true` if the upgrade was successful and `false` if it failed
-   *
-   * @example
-   * ```js
-   * import { serve } from "bun";
-   *  serve({
-   *    websocket: {
-   *      open: (ws) => {
-   *        console.log("Client connected");
-   *      },
-   *      message: (ws, message) => {
-   *        console.log("Client sent message", message);
-   *      },
-   *      close: (ws) => {
-   *        console.log("Client disconnected");
-   *      },
-   *    },
-   *    fetch(req, server) {
-   *      const url = new URL(req.url);
-   *      if (url.pathname === "/chat") {
-   *        const upgraded = server.upgrade(req);
-   *        if (!upgraded) {
-   *          return new Response("Upgrade failed", { status: 400 });
-   *        }
-   *      }
-   *      return new Response("Hello World");
-   *    },
-   *  });
-   * ```
-   *  What you pass to `data` is available on the {@link ServerWebSocket.data} property
-   */
   upgrade<T = undefined>(request: Request, options?: {
-    /**
-     * Send any additional headers while upgrading, like cookies
-     */
     headers?: Bun.HeadersInit;
-    /**
-     * This value is passed to the {@link ServerWebSocket.data} property
-     */
     data?: T;
   }): boolean;
-  /**
-   * Send a message to all connected {@link ServerWebSocket} subscribed to a topic
-   *
-   * @param topic The topic to publish to
-   * @param data The data to send
-   * @param compress Should the data be compressed? Ignored if the client does not support compression.
-   *
-   * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent.
-   *
-   * @example
-   *
-   * ```js
-   * server.publish("chat", "Hello World");
-   * ```
-   *
-   * @example
-   * ```js
-   * server.publish("chat", new Uint8Array([1, 2, 3, 4]));
-   * ```
-   *
-   * @example
-   * ```js
-   * server.publish("chat", new ArrayBuffer(4), true);
-   * ```
-   *
-   * @example
-   * ```js
-   * server.publish("chat", new DataView(new ArrayBuffer(4)));
-   * ```
-   */
   publish(topic: string, data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, compress?: boolean): ServerWebSocketSendStatus;
-  /**
-   * Returns the client IP address and port of the given Request. If the request was closed or is a unix socket, returns null.
-   *
-   * @example
-   * ```js
-   * export default {
-   *  async fetch(request, server) {
-   *    return new Response(server.requestIP(request));
-   *  }
-   * }
-   * ```
-   */
   requestIP(request: Request): SocketAddress | null;
-  /**
-   * Reset the idleTimeout of the given Request to the number in seconds. 0 means no timeout.
-   *
-   * @example
-   * ```js
-   * export default {
-   *  async fetch(request, server) {
-   *    server.timeout(request, 60);
-   *    await Bun.sleep(30000);
-   *    return new Response("30 seconds have passed");
-   *  }
-   * }
-   * ```
-   */
   timeout(request: Request, seconds: number): void;
-  /**
-   * Undo a call to {@link Server.unref}
-   *
-   * If the Server has already been stopped, this does nothing.
-   *
-   * If {@link Server.ref} is called multiple times, this does nothing. Think of it as a boolean toggle.
-   */
   ref(): void;
-  /**
-   * Don't keep the process alive if this server is the only thing left.
-   * Active connections may continue to keep the process alive.
-   *
-   * By default, the server is ref'd.
-   *
-   * To prevent new connections from being accepted, use {@link Server.stop}
-   */
   unref(): void;
-  /**
-   * How many requests are in-flight right now?
-   */
   readonly pendingRequests: number;
-  /**
-   * How many {@link ServerWebSocket}s are in-flight right now?
-   */
   readonly pendingWebSockets: number;
   readonly url: URL;
   readonly port: number;
-  /**
-   * The hostname the server is listening on. Does not include the port
-   * @example
-   * ```js
-   * "localhost"
-   * ```
-   */
   readonly hostname: string;
-  /**
-   * Is the server running in development mode?
-   *
-   * In development mode, `Bun.serve()` returns rendered error messages with
-   * stack traces instead of a generic 500 error. This makes debugging easier,
-   * but development mode shouldn't be used in production or you will risk
-   * leaking sensitive information.
-   */
   readonly development: boolean;
-  /**
-   * An identifier of the server instance
-   *
-   * When bun is started with the `--hot` flag, this ID is used to hot reload the server without interrupting pending requests or websockets.
-   *
-   * When bun is not started with the `--hot` flag, this ID is currently unused.
-   */
   readonly id: string;
 }
 type ListenCallback = (server: Server) => MaybePromise<void>;