bun-types 1.2.9-canary.20250406T140639 → 1.2.9-canary.20250408T140629

package/docs/api/fetch.md

@@ -337,7 +337,7 @@ This will print the request and response headers to your terminal:
 ```sh
 [fetch] > HTTP/1.1 GET http://example.com/
 [fetch] > Connection: keep-alive
-[fetch] > User-Agent: Bun/1.2.9-canary.20250406T140639
+[fetch] > User-Agent: Bun/1.2.9-canary.20250408T140629
 [fetch] > Accept: */*
 [fetch] > Host: example.com
 [fetch] > Accept-Encoding: gzip, deflate, br

package/docs/api/redis.md

@@ -0,0 +1,514 @@
+Bun provides native bindings for working with Redis databases with a modern, Promise-based API. The interface is designed to be simple and performant, with built-in connection management, fully typed responses, and TLS support. **New in Bun v1.2.9**
+
+```ts
+import { redis } from "bun";
+
+// Set a key
+await redis.set("greeting", "Hello from Bun!");
+
+// Get a key
+const greeting = await redis.get("greeting");
+console.log(greeting); // "Hello from Bun!"
+
+// Increment a counter
+await redis.set("counter", 0);
+await redis.incr("counter");
+
+// Check if a key exists
+const exists = await redis.exists("greeting");
+
+// Delete a key
+await redis.del("greeting");
+```
+
+{% features title="Features" %}
+
+{% icon size=20 name="Bolt" /%} Fast native implementation using Zig and JavaScriptCore
+
+{% icon size=20 name="Link" /%} Automatic pipelining for better performance
+
+{% icon size=20 name="EthernetPort" /%} Auto-reconnect with exponential backoff
+
+{% icon size=20 name="Omega" /%} Support for RESP3 protocol
+
+{% icon size=20 name="Lock" /%} TLS support
+
+{% icon size=20 name="Clock" /%} Connection management with configurable timeouts
+
+{% icon size=20 name="IndentDecrease" /%} Offline command queue
+
+{% icon size=20 name="Settings" /%} Automatic configuration with environment variables
+
+{% icon size=20 name="Hash" /%} Support for hash, set, and other Redis data structures
+
+{% /features %}
+
+## Getting Started
+
+To use the Redis client, you first need to create a connection:
+
+```ts
+import { redis, RedisClient } from "bun";
+
+// Using the default client (reads connection info from environment)
+// process.env.REDIS_URL is used by default
+await redis.set("hello", "world");
+const result = await redis.get("hello");
+
+// Creating a custom client
+const client = new RedisClient("redis://username:password@localhost:6379");
+await client.set("counter", "0");
+await client.incr("counter");
+```
+
+By default, the client reads connection information from the following environment variables (in order of precedence):
+
+- `REDIS_URL`
+- If not set, defaults to `"redis://localhost:6379"`
+
+### Connection Lifecycle
+
+The Redis client automatically handles connections in the background:
+
+```ts
+// No connection is made until a command is executed
+const client = new RedisClient();
+
+// First command initiates the connection
+await client.set("key", "value");
+
+// Connection remains open for subsequent commands
+await client.get("key");
+
+// Explicitly close the connection when done
+client.disconnect();
+```
+
+You can also manually control the connection lifecycle:
+
+```ts
+const client = new RedisClient();
+
+// Explicitly connect
+await client.connect();
+
+// Run commands
+await client.set("key", "value");
+
+// Disconnect when done
+client.disconnect();
+```
+
+## Basic Operations
+
+### String Operations
+
+```ts
+// Set a key
+await redis.set("user:1:name", "Alice");
+
+// Get a key
+const name = await redis.get("user:1:name");
+
+// Delete a key
+await redis.del("user:1:name");
+
+// Check if a key exists
+const exists = await redis.exists("user:1:name");
+
+// Set expiration (in seconds)
+await redis.set("session:123", "active");
+await redis.expire("session:123", 3600); // expires in 1 hour
+
+// Get time to live (in seconds)
+const ttl = await redis.ttl("session:123");
+```
+
+### Numeric Operations
+
+```ts
+// Set initial value
+await redis.set("counter", "0");
+
+// Increment by 1
+await redis.incr("counter");
+
+// Decrement by 1
+await redis.decr("counter");
+```
+
+### Hash Operations
+
+```ts
+// Set multiple fields in a hash
+await redis.hmset("user:123", [
+  "name",
+  "Alice",
+  "email",
+  "alice@example.com",
+  "active",
+  "true",
+]);
+
+// Get multiple fields from a hash
+const userFields = await redis.hmget("user:123", ["name", "email"]);
+console.log(userFields); // ["Alice", "alice@example.com"]
+
+// Increment a numeric field in a hash
+await redis.hincrby("user:123", "visits", 1);
+
+// Increment a float field in a hash
+await redis.hincrbyfloat("user:123", "score", 1.5);
+```
+
+### Set Operations
+
+```ts
+// Add member to set
+await redis.sadd("tags", "javascript");
+
+// Remove member from set
+await redis.srem("tags", "javascript");
+
+// Check if member exists in set
+const isMember = await redis.sismember("tags", "javascript");
+
+// Get all members of a set
+const allTags = await redis.smembers("tags");
+
+// Get a random member
+const randomTag = await redis.srandmember("tags");
+
+// Pop (remove and return) a random member
+const poppedTag = await redis.spop("tags");
+```
+
+## Advanced Usage
+
+### Command Execution and Pipelining
+
+The client automatically pipelines commands, improving performance by sending multiple commands in a batch and processing responses as they arrive.
+
+```ts
+// Commands are automatically pipelined by default
+const [infoResult, listResult] = await Promise.all([
+  redis.get("user:1:name"),
+  redis.get("user:2:email"),
+]);
+```
+
+To disable automatic pipelining, you can set the `enableAutoPipelining` option to `false`:
+
+```ts
+const client = new RedisClient("redis://localhost:6379", {
+  enableAutoPipelining: false,
+});
+```
+
+### Raw Commands
+
+When you need to use commands that don't have convenience methods, you can use the `send` method:
+
+```ts
+// Run any Redis command
+const info = await redis.send("INFO", []);
+
+// LPUSH to a list
+await redis.send("LPUSH", ["mylist", "value1", "value2"]);
+
+// Get list range
+const list = await redis.send("LRANGE", ["mylist", "0", "-1"]);
+```
+
+The `send` method allows you to use any Redis command, even ones that don't have dedicated methods in the client. The first argument is the command name, and the second argument is an array of string arguments.
+
+### Connection Events
+
+You can register handlers for connection events:
+
+```ts
+const client = new RedisClient();
+
+// Called when successfully connected to Redis server
+client.onconnect = () => {
+  console.log("Connected to Redis server");
+};
+
+// Called when disconnected from Redis server
+client.onclose = error => {
+  console.error("Disconnected from Redis server:", error);
+};
+
+// Manually connect/disconnect
+await client.connect();
+client.disconnect();
+```
+
+### Connection Status and Monitoring
+
+```ts
+// Check if connected
+console.log(client.connected); // boolean indicating connection status
+
+// Check amount of data buffered (in bytes)
+console.log(client.bufferedAmount);
+```
+
+### Type Conversion
+
+The Redis client handles automatic type conversion for Redis responses:
+
+- Integer responses are returned as JavaScript numbers
+- Bulk strings are returned as JavaScript strings
+- Simple strings are returned as JavaScript strings
+- Null bulk strings are returned as `null`
+- Array responses are returned as JavaScript arrays
+- Error responses throw JavaScript errors with appropriate error codes
+- Boolean responses (RESP3) are returned as JavaScript booleans
+- Map responses (RESP3) are returned as JavaScript objects
+- Set responses (RESP3) are returned as JavaScript arrays
+
+Special handling for specific commands:
+
+- `EXISTS` returns a boolean instead of a number (1 becomes true, 0 becomes false)
+- `SISMEMBER` returns a boolean (1 becomes true, 0 becomes false)
+
+The following commands disable automatic pipelining:
+
+- `AUTH`
+- `INFO`
+- `QUIT`
+- `EXEC`
+- `MULTI`
+- `WATCH`
+- `SCRIPT`
+- `SELECT`
+- `CLUSTER`
+- `DISCARD`
+- `UNWATCH`
+- `PIPELINE`
+- `SUBSCRIBE`
+- `UNSUBSCRIBE`
+- `UNPSUBSCRIBE`
+
+## Connection Options
+
+When creating a client, you can pass various options to configure the connection:
+
+```ts
+const client = new RedisClient("redis://localhost:6379", {
+  // Connection timeout in milliseconds (default: 10000)
+  connectionTimeout: 5000,
+
+  // Idle timeout in milliseconds (default: 0 = no timeout)
+  idleTimeout: 30000,
+
+  // Whether to automatically reconnect on disconnection (default: true)
+  autoReconnect: true,
+
+  // Maximum number of reconnection attempts (default: 10)
+  maxRetries: 10,
+
+  // Whether to queue commands when disconnected (default: true)
+  enableOfflineQueue: true,
+
+  // Whether to automatically pipeline commands (default: true)
+  enableAutoPipelining: true,
+
+  // TLS options (default: false)
+  tls: true,
+  // Alternatively, provide custom TLS config:
+  // tls: {
+  //   rejectUnauthorized: true,
+  //   ca: "path/to/ca.pem",
+  //   cert: "path/to/cert.pem",
+  //   key: "path/to/key.pem",
+  // }
+});
+```
+
+### Reconnection Behavior
+
+When a connection is lost, the client automatically attempts to reconnect with exponential backoff:
+
+1. The client starts with a small delay (50ms) and doubles it with each attempt
+2. Reconnection delay is capped at 2000ms (2 seconds)
+3. The client attempts to reconnect up to `maxRetries` times (default: 10)
+4. Commands executed during disconnection are:
+   - Queued if `enableOfflineQueue` is true (default)
+   - Rejected immediately if `enableOfflineQueue` is false
+
+## Supported URL Formats
+
+The Redis client supports various URL formats:
+
+```ts
+// Standard Redis URL
+new RedisClient("redis://localhost:6379");
+new RedisClient("redis://localhost:6379");
+
+// With authentication
+new RedisClient("redis://username:password@localhost:6379");
+
+// With database number
+new RedisClient("redis://localhost:6379/0");
+
+// TLS connections
+new RedisClient("rediss://localhost:6379");
+new RedisClient("rediss://localhost:6379");
+new RedisClient("redis+tls://localhost:6379");
+new RedisClient("redis+tls://localhost:6379");
+
+// Unix socket connections
+new RedisClient("redis+unix:///path/to/socket");
+new RedisClient("redis+unix:///path/to/socket");
+
+// TLS over Unix socket
+new RedisClient("redis+tls+unix:///path/to/socket");
+new RedisClient("redis+tls+unix:///path/to/socket");
+```
+
+## Error Handling
+
+The Redis client throws typed errors for different scenarios:
+
+```ts
+try {
+  await redis.get("non-existent-key");
+} catch (error) {
+  if (error.code === "ERR_REDIS_CONNECTION_CLOSED") {
+    console.error("Connection to Redis server was closed");
+  } else if (error.code === "ERR_REDIS_AUTHENTICATION_FAILED") {
+    console.error("Authentication failed");
+  } else {
+    console.error("Unexpected error:", error);
+  }
+}
+```
+
+Common error codes:
+
+- `ERR_REDIS_CONNECTION_CLOSED` - Connection to the server was closed
+- `ERR_REDIS_AUTHENTICATION_FAILED` - Failed to authenticate with the server
+- `ERR_REDIS_INVALID_RESPONSE` - Received an invalid response from the server
+
+## Example Use Cases
+
+### Caching
+
+```ts
+async function getUserWithCache(userId) {
+  const cacheKey = `user:${userId}`;
+
+  // Try to get from cache first
+  const cachedUser = await redis.get(cacheKey);
+  if (cachedUser) {
+    return JSON.parse(cachedUser);
+  }
+
+  // Not in cache, fetch from database
+  const user = await database.getUser(userId);
+
+  // Store in cache for 1 hour
+  await redis.set(cacheKey, JSON.stringify(user));
+  await redis.expire(cacheKey, 3600);
+
+  return user;
+}
+```
+
+### Rate Limiting
+
+```ts
+async function rateLimit(ip, limit = 100, windowSecs = 3600) {
+  const key = `ratelimit:${ip}`;
+
+  // Increment counter
+  const count = await redis.incr(key);
+
+  // Set expiry if this is the first request in window
+  if (count === 1) {
+    await redis.expire(key, windowSecs);
+  }
+
+  // Check if limit exceeded
+  return {
+    limited: count > limit,
+    remaining: Math.max(0, limit - count),
+  };
+}
+```
+
+### Session Storage
+
+```ts
+async function createSession(userId, data) {
+  const sessionId = crypto.randomUUID();
+  const key = `session:${sessionId}`;
+
+  // Store session with expiration
+  await redis.hmset(key, [
+    "userId",
+    userId.toString(),
+    "created",
+    Date.now().toString(),
+    "data",
+    JSON.stringify(data),
+  ]);
+  await redis.expire(key, 86400); // 24 hours
+
+  return sessionId;
+}
+
+async function getSession(sessionId) {
+  const key = `session:${sessionId}`;
+
+  // Get session data
+  const exists = await redis.exists(key);
+  if (!exists) return null;
+
+  const [userId, created, data] = await redis.hmget(key, [
+    "userId",
+    "created",
+    "data",
+  ]);
+
+  return {
+    userId: Number(userId),
+    created: Number(created),
+    data: JSON.parse(data),
+  };
+}
+```
+
+## Implementation Notes
+
+Bun's Redis client is implemented in Zig and uses the Redis Serialization Protocol (RESP3). It manages connections efficiently and provides automatic reconnection with exponential backoff.
+
+The client supports pipelining commands, meaning multiple commands can be sent without waiting for the replies to previous commands. This significantly improves performance when sending multiple commands in succession.
+
+### RESP3 Protocol Support
+
+Bun's Redis client uses the newer RESP3 protocol by default, which provides more data types and features compared to RESP2:
+
+- Better error handling with typed errors
+- Native Boolean responses
+- Map/Dictionary responses (key-value objects)
+- Set responses
+- Double (floating point) values
+- BigNumber support for large integer values
+
+When connecting to Redis servers using older versions that don't support RESP3, the client automatically fallbacks to compatible modes.
+
+## Limitations and Future Plans
+
+Current limitations of the Redis client we are planning to address in future versions:
+
+- [ ] No dedicated API for pub/sub functionality (though you can use the raw command API)
+- [ ] Transactions (MULTI/EXEC) must be done through raw commands for now
+- [ ] Streams are supported but without dedicated methods
+
+Unsupported features:
+
+- Redis Sentinel
+- Redis Cluster

package/docs/api/spawn.md

@@ -120,7 +120,7 @@ You can read results from the subprocess via the `stdout` and `stderr` propertie
 ```ts
 const proc = Bun.spawn(["bun", "--version"]);
 const text = await new Response(proc.stdout).text();
-console.log(text); // => "1.2.9-canary.20250406T140639"
+console.log(text); // => "1.2.9-canary.20250408T140629"
 ```
 
 Configure the output stream by passing one of the following values to `stdout/stderr`:

package/docs/cli/publish.md

@@ -7,7 +7,7 @@ Use `bun publish` to publish a package to the npm registry.
 $ bun publish
 
 ## Output
-bun publish v1.2.9-canary.20250406T140639 (ca7428e9)
+bun publish v1.2.9-canary.20250408T140629 (ca7428e9)
 
 packed 203B package.json
 packed 224B README.md

package/docs/guides/ecosystem/nuxt.md

@@ -9,7 +9,7 @@ $ bunx nuxi init my-nuxt-app
 ✔ Which package manager would you like to use?
 bun
 ◐ Installing dependencies...
-bun install v1.2.9-canary.20250406T140639 (16b4bf34)
+bun install v1.2.9-canary.20250408T140629 (16b4bf34)
  + @nuxt/devtools@0.8.2
  + nuxt@3.7.0
  785 packages installed [2.67s]

package/docs/guides/install/add-peer.md

@@ -16,7 +16,7 @@ This will add the package to `peerDependencies` in `package.json`.
 ```json-diff
 {
   "peerDependencies": {
-+   "@types/bun": "^1.2.9-canary.20250406T140639"
++   "@types/bun": "^1.2.9-canary.20250408T140629"
   }
 }
 ```
@@ -28,7 +28,7 @@ Running `bun install` will install peer dependencies by default, unless marked o
 ```json-diff
 {
   "peerDependencies": {
-    "@types/bun": "^1.2.9-canary.20250406T140639"
+    "@types/bun": "^1.2.9-canary.20250408T140629"
   },
   "peerDependenciesMeta": {
 +   "@types/bun": {

package/docs/guides/install/from-npm-install-to-bun-install.md

@@ -97,7 +97,7 @@ $ bun update
 $ bun update @types/bun --latest
 
 # Update a dependency to a specific version
-$ bun update @types/bun@1.2.9-canary.20250406T140639
+$ bun update @types/bun@1.2.9-canary.20250408T140629
 
 # Update all dependencies to the latest versions
 $ bun update --latest

package/docs/guides/test/run-tests.md

@@ -21,7 +21,7 @@ Here's what the output of a typical test run looks like. In this case, there are
 
 ```sh
 $ bun test
-bun test v1.2.9-canary.20250406T140639 (9c68abdb)
+bun test v1.2.9-canary.20250408T140629 (9c68abdb)
 
 test.test.js:
 ✓ add [0.87ms]
@@ -47,7 +47,7 @@ To only run certain test files, pass a positional argument to `bun test`. The ru
 
 ```sh
 $ bun test test3
-bun test v1.2.9-canary.20250406T140639 (9c68abdb)
+bun test v1.2.9-canary.20250408T140629 (9c68abdb)
 
 test3.test.js:
 ✓ add [1.40ms]
@@ -85,7 +85,7 @@ Adding `-t add` will only run tests with "add" in the name. This works with test
 
 ```sh
 $ bun test -t add
-bun test v1.2.9-canary.20250406T140639 (9c68abdb)
+bun test v1.2.9-canary.20250408T140629 (9c68abdb)
 
 test.test.js:
 ✓ add [1.79ms]

package/docs/guides/test/snapshot.md

@@ -18,7 +18,7 @@ The first time this test is executed, Bun will evaluate the value passed into `e
 
 ```sh
 $ bun test test/snap
-bun test v1.2.9-canary.20250406T140639 (9c68abdb)
+bun test v1.2.9-canary.20250408T140629 (9c68abdb)
 
 test/snap.test.ts:
 ✓ snapshot [1.48ms]
@@ -61,7 +61,7 @@ Later, when this test file is executed again, Bun will read the snapshot file an
 
 ```sh
 $ bun test
-bun test v1.2.9-canary.20250406T140639 (9c68abdb)
+bun test v1.2.9-canary.20250408T140629 (9c68abdb)
 
 test/snap.test.ts:
 ✓ snapshot [1.05ms]
@@ -78,7 +78,7 @@ To update snapshots, use the `--update-snapshots` flag.
 
 ```sh
 $ bun test --update-snapshots
-bun test v1.2.9-canary.20250406T140639 (9c68abdb)
+bun test v1.2.9-canary.20250408T140629 (9c68abdb)
 
 test/snap.test.ts:
 ✓ snapshot [0.86ms]

package/docs/guides/test/update-snapshots.md

@@ -29,7 +29,7 @@ To regenerate snapshots, use the `--update-snapshots` flag.
 
 ```sh
 $ bun test --update-snapshots
-bun test v1.2.9-canary.20250406T140639 (9c68abdb)
+bun test v1.2.9-canary.20250408T140629 (9c68abdb)
 
 test/snap.test.ts:
 ✓ snapshot [0.86ms]

package/docs/guides/util/version.md

@@ -5,7 +5,7 @@ name: Get the current Bun version
 Get the current version of Bun in a semver format.
 
 ```ts#index.ts
-Bun.version; // => "1.2.9-canary.20250406T140639"
+Bun.version; // => "1.2.9-canary.20250408T140629"
 ```
 
 ---

package/docs/installation.md

@@ -14,7 +14,7 @@ Kernel version 5.6 or higher is strongly recommended, but the minimum is 5.1. Us
 ```bash#macOS/Linux_(curl)
 $ curl -fsSL https://bun.sh/install | bash # for macOS, Linux, and WSL
 # to install a specific version
-$ curl -fsSL https://bun.sh/install | bash -s "bun-v1.2.9-canary.20250406T140639"
+$ curl -fsSL https://bun.sh/install | bash -s "bun-v1.2.9-canary.20250408T140629"
 ```
 
 ```bash#npm
@@ -189,10 +189,10 @@ Since Bun is a single binary, you can install older versions of Bun by re-runnin
 
 ### Installing a specific version of Bun on Linux/Mac
 
-To install a specific version of Bun, you can pass the git tag of the version you want to install to the install script, such as `bun-v1.2.0` or `bun-v1.2.9-canary.20250406T140639`.
+To install a specific version of Bun, you can pass the git tag of the version you want to install to the install script, such as `bun-v1.2.0` or `bun-v1.2.9-canary.20250408T140629`.
 
 ```sh
-$ curl -fsSL https://bun.sh/install | bash -s "bun-v1.2.9-canary.20250406T140639"
+$ curl -fsSL https://bun.sh/install | bash -s "bun-v1.2.9-canary.20250408T140629"
 ```
 
 ### Installing a specific version of Bun on Windows
@@ -201,7 +201,7 @@ On Windows, you can install a specific version of Bun by passing the version num
 
 ```sh
 # PowerShell:
-$ iex "& {$(irm https://bun.sh/install.ps1)} -Version 1.2.9-canary.20250406T140639"
+$ iex "& {$(irm https://bun.sh/install.ps1)} -Version 1.2.9-canary.20250408T140629"
 ```
 
 ## Downloading Bun binaries directly

package/docs/runtime/debugger.md

@@ -124,11 +124,11 @@ await fetch("https://example.com", {
 This prints the `fetch` request as a single-line `curl` command to let you copy-paste into your terminal to replicate the request.
 
 ```sh
-[fetch] $ curl --http1.1 "https://example.com/" -X POST -H "content-type: application/json" -H "Connection: keep-alive" -H "User-Agent: Bun/1.2.9-canary.20250406T140639" -H "Accept: */*" -H "Host: example.com" -H "Accept-Encoding: gzip, deflate, br" --compressed -H "Content-Length: 13" --data-raw "{\"foo\":\"bar\"}"
+[fetch] $ curl --http1.1 "https://example.com/" -X POST -H "content-type: application/json" -H "Connection: keep-alive" -H "User-Agent: Bun/1.2.9-canary.20250408T140629" -H "Accept: */*" -H "Host: example.com" -H "Accept-Encoding: gzip, deflate, br" --compressed -H "Content-Length: 13" --data-raw "{\"foo\":\"bar\"}"
 [fetch] > HTTP/1.1 POST https://example.com/
 [fetch] > content-type: application/json
 [fetch] > Connection: keep-alive
-[fetch] > User-Agent: Bun/1.2.9-canary.20250406T140639
+[fetch] > User-Agent: Bun/1.2.9-canary.20250408T140629
 [fetch] > Accept: */*
 [fetch] > Host: example.com
 [fetch] > Accept-Encoding: gzip, deflate, br
@@ -170,7 +170,7 @@ This prints the following to the console:
 [fetch] > HTTP/1.1 POST https://example.com/
 [fetch] > content-type: application/json
 [fetch] > Connection: keep-alive
-[fetch] > User-Agent: Bun/1.2.9-canary.20250406T140639
+[fetch] > User-Agent: Bun/1.2.9-canary.20250408T140629
 [fetch] > Accept: */*
 [fetch] > Host: example.com
 [fetch] > Accept-Encoding: gzip, deflate, br

package/docs/test/dom.md

@@ -55,7 +55,7 @@ Let's run this test with `bun test`:
 
 ```bash
 $ bun test
-bun test v1.2.9-canary.20250406T140639
+bun test v1.2.9-canary.20250408T140629
 
 dom.test.ts:
 ✓ dom test [0.82ms]

package/extensions.d.ts

@@ -23,9 +23,3 @@ declare module "*.html" {
   var contents: any;
   export = contents;
 }
-
-declare module "*.svg" {
-  // Bun 1.2.3 added support for frontend dev server
-  var content: `${string}.svg`;
-  export = content;
-}

package/index.d.ts

@@ -18,7 +18,7 @@
 /// <reference path="./wasm.d.ts" />
 /// <reference path="./overrides.d.ts" />
 /// <reference path="./deprecated.d.ts" />
-
+/// <reference path="./redis.d.ts" />
 /// <reference path="./bun.ns.d.ts" />
 
 // @ts-ignore Must disable this so it doesn't conflict with the DOM onmessage type, but still

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.2.9-canary.20250406T140639",
+  "version": "1.2.9-canary.20250408T140629",
   "name": "bun-types",
   "license": "MIT",
   "types": "./index.d.ts",

package/redis.d.ts

@@ -0,0 +1,497 @@
+declare module "bun" {
+  export interface RedisOptions {
+    /**
+     * URL to connect to, defaults to "redis://localhost:6379"
+     * Supported protocols: redis://, rediss://, redis+unix://, redis+tls://
+     */
+    url?: string;
+
+    /**
+     * Connection timeout in milliseconds
+     * @default 10000
+     */
+    connectionTimeout?: number;
+
+    /**
+     * Idle timeout in milliseconds
+     * @default 0 (no timeout)
+     */
+    idleTimeout?: number;
+
+    /**
+     * Whether to automatically reconnect
+     * @default true
+     */
+    autoReconnect?: boolean;
+
+    /**
+     * Maximum number of reconnection attempts
+     * @default 10
+     */
+    maxRetries?: number;
+
+    /**
+     * Whether to queue commands when disconnected
+     * @default true
+     */
+    enableOfflineQueue?: boolean;
+
+    /**
+     * TLS options
+     * Can be a boolean or an object with TLS options
+     */
+    tls?:
+      | boolean
+      | {
+          key?: string | Buffer;
+          cert?: string | Buffer;
+          ca?: string | Buffer | Array<string | Buffer>;
+          rejectUnauthorized?: boolean;
+        };
+
+    /**
+     * Whether to enable auto-pipelining
+     * @default true
+     */
+    enableAutoPipelining?: boolean;
+  }
+
+  export class RedisClient {
+    /**
+     * Creates a new Redis client
+     * @param url URL to connect to, defaults to process.env.VALKEY_URL, process.env.REDIS_URL, or "valkey://localhost:6379"
+     * @param options Additional options
+     *
+     * @example
+     * ```ts
+     * const valkey = new RedisClient();
+     *
+     * await valkey.set("hello", "world");
+     *
+     * console.log(await valkey.get("hello"));
+     * ```
+     */
+    constructor(url?: string, options?: RedisOptions);
+
+    /**
+     * Whether the client is connected to the Redis server
+     */
+    readonly connected: boolean;
+
+    /**
+     * Amount of data buffered in bytes
+     */
+    readonly bufferedAmount: number;
+
+    /**
+     * Callback fired when the client connects to the Redis server
+     */
+    onconnect: ((this: RedisClient) => void) | null;
+
+    /**
+     * Callback fired when the client disconnects from the Redis server
+     * @param error The error that caused the disconnection
+     */
+    onclose: ((this: RedisClient, error: Error) => void) | null;
+
+    /**
+     * Connect to the Redis server
+     * @returns A promise that resolves when connected
+     */
+    connect(): Promise<void>;
+
+    /**
+     * Disconnect from the Redis server
+     */
+    disconnect(): void;
+
+    /**
+     * Send a raw command to the Redis server
+     * @param command The command to send
+     * @param args The arguments to the command
+     * @returns A promise that resolves with the command result
+     */
+    send(command: string, args: string[]): Promise<any>;
+
+    /**
+     * Get the value of a key
+     * @param key The key to get
+     * @returns Promise that resolves with the key's value, or null if the key doesn't exist
+     */
+    get(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Set the value of a key
+     * @param key The key to set
+     * @param value The value to set
+     * @returns Promise that resolves with "OK" on success
+     */
+    set(key: string | NodeJS.TypedArray | Blob, value: string | NodeJS.TypedArray | Blob): Promise<"OK">;
+
+    /**
+     * Delete a key
+     * @param key The key to delete
+     * @returns Promise that resolves with the number of keys removed
+     */
+    del(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Increment the integer value of a key by one
+     * @param key The key to increment
+     * @returns Promise that resolves with the new value
+     */
+    incr(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Decrement the integer value of a key by one
+     * @param key The key to decrement
+     * @returns Promise that resolves with the new value
+     */
+    decr(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Determine if a key exists
+     * @param key The key to check
+     * @returns Promise that resolves with true if the key exists, false otherwise
+     */
+    exists(key: string | NodeJS.TypedArray | Blob): Promise<boolean>;
+
+    /**
+     * Set a key's time to live in seconds
+     * @param key The key to set the expiration for
+     * @param seconds The number of seconds until expiration
+     * @returns Promise that resolves with 1 if the timeout was set, 0 if not
+     */
+    expire(key: string | NodeJS.TypedArray | Blob, seconds: number): Promise<number>;
+
+    /**
+     * Get the time to live for a key in seconds
+     * @param key The key to get the TTL for
+     * @returns Promise that resolves with the TTL, -1 if no expiry, or -2 if key doesn't exist
+     */
+    ttl(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Set multiple hash fields to multiple values
+     * @param key The hash key
+     * @param fieldValues An array of alternating field names and values
+     * @returns Promise that resolves with "OK" on success
+     */
+    hmset(key: string | NodeJS.TypedArray | Blob, fieldValues: string[]): Promise<string>;
+
+    /**
+     * Get the values of all the given hash fields
+     * @param key The hash key
+     * @param fields The fields to get
+     * @returns Promise that resolves with an array of values
+     */
+    hmget(key: string | NodeJS.TypedArray | Blob, fields: string[]): Promise<Array<string | null>>;
+
+    /**
+     * Check if a value is a member of a set
+     * @param key The set key
+     * @param member The member to check
+     * @returns Promise that resolves with true if the member exists, false otherwise
+     */
+    sismember(key: string | NodeJS.TypedArray | Blob, member: string): Promise<boolean>;
+
+    /**
+     * Add a member to a set
+     * @param key The set key
+     * @param member The member to add
+     * @returns Promise that resolves with 1 if the member was added, 0 if it already existed
+     */
+    sadd(key: string | NodeJS.TypedArray | Blob, member: string): Promise<number>;
+
+    /**
+     * Remove a member from a set
+     * @param key The set key
+     * @param member The member to remove
+     * @returns Promise that resolves with 1 if the member was removed, 0 if it didn't exist
+     */
+    srem(key: string | NodeJS.TypedArray | Blob, member: string): Promise<number>;
+
+    /**
+     * Get all the members in a set
+     * @param key The set key
+     * @returns Promise that resolves with an array of all members
+     */
+    smembers(key: string | NodeJS.TypedArray | Blob): Promise<string[]>;
+
+    /**
+     * Get a random member from a set
+     * @param key The set key
+     * @returns Promise that resolves with a random member, or null if the set is empty
+     */
+    srandmember(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Remove and return a random member from a set
+     * @param key The set key
+     * @returns Promise that resolves with the removed member, or null if the set is empty
+     */
+    spop(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Increment the integer value of a hash field by the given number
+     * @param key The hash key
+     * @param field The field to increment
+     * @param increment The amount to increment by
+     * @returns Promise that resolves with the new value
+     */
+    hincrby(key: string | NodeJS.TypedArray | Blob, field: string, increment: string | number): Promise<number>;
+
+    /**
+     * Increment the float value of a hash field by the given amount
+     * @param key The hash key
+     * @param field The field to increment
+     * @param increment The amount to increment by
+     * @returns Promise that resolves with the new value as a string
+     */
+    hincrbyfloat(key: string | NodeJS.TypedArray | Blob, field: string, increment: string | number): Promise<string>;
+
+    /**
+     * Get all the fields and values in a hash
+     * @param key The hash key
+     * @returns Promise that resolves with an object containing all fields and values
+     */
+    hgetall(key: string | NodeJS.TypedArray | Blob): Promise<Record<string, string> | null>;
+
+    /**
+     * Get all field names in a hash
+     * @param key The hash key
+     * @returns Promise that resolves with an array of field names
+     */
+    hkeys(key: string | NodeJS.TypedArray | Blob): Promise<string[]>;
+
+    /**
+     * Get the number of fields in a hash
+     * @param key The hash key
+     * @returns Promise that resolves with the number of fields
+     */
+    hlen(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Get all values in a hash
+     * @param key The hash key
+     * @returns Promise that resolves with an array of values
+     */
+    hvals(key: string | NodeJS.TypedArray | Blob): Promise<string[]>;
+
+    /**
+     * Find all keys matching the given pattern
+     * @param pattern The pattern to match
+     * @returns Promise that resolves with an array of matching keys
+     */
+    keys(pattern: string): Promise<string[]>;
+
+    /**
+     * Get the length of a list
+     * @param key The list key
+     * @returns Promise that resolves with the length of the list
+     */
+    llen(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Remove and get the first element in a list
+     * @param key The list key
+     * @returns Promise that resolves with the first element, or null if the list is empty
+     */
+    lpop(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Remove the expiration from a key
+     * @param key The key to persist
+     * @returns Promise that resolves with 1 if the timeout was removed, 0 if the key doesn't exist or has no timeout
+     */
+    persist(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Get the expiration time of a key as a UNIX timestamp in milliseconds
+     * @param key The key to check
+     * @returns Promise that resolves with the timestamp, or -1 if the key has no expiration, or -2 if the key doesn't exist
+     */
+    pexpiretime(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Get the time to live for a key in milliseconds
+     * @param key The key to check
+     * @returns Promise that resolves with the TTL in milliseconds, or -1 if the key has no expiration, or -2 if the key doesn't exist
+     */
+    pttl(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Remove and get the last element in a list
+     * @param key The list key
+     * @returns Promise that resolves with the last element, or null if the list is empty
+     */
+    rpop(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Get the number of members in a set
+     * @param key The set key
+     * @returns Promise that resolves with the cardinality (number of elements) of the set
+     */
+    scard(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Get the length of the value stored in a key
+     * @param key The key to check
+     * @returns Promise that resolves with the length of the string value, or 0 if the key doesn't exist
+     */
+    strlen(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Get the number of members in a sorted set
+     * @param key The sorted set key
+     * @returns Promise that resolves with the cardinality (number of elements) of the sorted set
+     */
+    zcard(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Remove and return members with the highest scores in a sorted set
+     * @param key The sorted set key
+     * @returns Promise that resolves with the removed member and its score, or null if the set is empty
+     */
+    zpopmax(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Remove and return members with the lowest scores in a sorted set
+     * @param key The sorted set key
+     * @returns Promise that resolves with the removed member and its score, or null if the set is empty
+     */
+    zpopmin(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Get one or multiple random members from a sorted set
+     * @param key The sorted set key
+     * @returns Promise that resolves with a random member, or null if the set is empty
+     */
+    zrandmember(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Append a value to a key
+     * @param key The key to append to
+     * @param value The value to append
+     * @returns Promise that resolves with the length of the string after the append operation
+     */
+    append(key: string | NodeJS.TypedArray | Blob, value: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Set the value of a key and return its old value
+     * @param key The key to set
+     * @param value The value to set
+     * @returns Promise that resolves with the old value, or null if the key didn't exist
+     */
+    getset(key: string | NodeJS.TypedArray | Blob, value: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Prepend one or multiple values to a list
+     * @param key The list key
+     * @param value The value to prepend
+     * @returns Promise that resolves with the length of the list after the push operation
+     */
+    lpush(key: string | NodeJS.TypedArray | Blob, value: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Prepend a value to a list, only if the list exists
+     * @param key The list key
+     * @param value The value to prepend
+     * @returns Promise that resolves with the length of the list after the push operation, or 0 if the list doesn't exist
+     */
+    lpushx(key: string | NodeJS.TypedArray | Blob, value: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Add one or more members to a HyperLogLog
+     * @param key The HyperLogLog key
+     * @param element The element to add
+     * @returns Promise that resolves with 1 if the HyperLogLog was altered, 0 otherwise
+     */
+    pfadd(key: string | NodeJS.TypedArray | Blob, element: string): Promise<number>;
+
+    /**
+     * Append one or multiple values to a list
+     * @param key The list key
+     * @param value The value to append
+     * @returns Promise that resolves with the length of the list after the push operation
+     */
+    rpush(key: string | NodeJS.TypedArray | Blob, value: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Append a value to a list, only if the list exists
+     * @param key The list key
+     * @param value The value to append
+     * @returns Promise that resolves with the length of the list after the push operation, or 0 if the list doesn't exist
+     */
+    rpushx(key: string | NodeJS.TypedArray | Blob, value: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Set the value of a key, only if the key does not exist
+     * @param key The key to set
+     * @param value The value to set
+     * @returns Promise that resolves with 1 if the key was set, 0 if the key was not set
+     */
+    setnx(key: string | NodeJS.TypedArray | Blob, value: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Get the score associated with the given member in a sorted set
+     * @param key The sorted set key
+     * @param member The member to get the score for
+     * @returns Promise that resolves with the score of the member as a string, or null if the member or key doesn't exist
+     */
+    zscore(key: string | NodeJS.TypedArray | Blob, member: string): Promise<string | null>;
+
+    /**
+     * Get the values of all specified keys
+     * @param keys The keys to get
+     * @returns Promise that resolves with an array of values, with null for keys that don't exist
+     */
+    mget(...keys: (string | NodeJS.TypedArray | Blob)[]): Promise<(string | null)[]>;
+
+    /**
+     * Count the number of set bits (population counting) in a string
+     * @param key The key to count bits in
+     * @returns Promise that resolves with the number of bits set to 1
+     */
+    bitcount(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Return a serialized version of the value stored at the specified key
+     * @param key The key to dump
+     * @returns Promise that resolves with the serialized value, or null if the key doesn't exist
+     */
+    dump(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Get the expiration time of a key as a UNIX timestamp in seconds
+     * @param key The key to check
+     * @returns Promise that resolves with the timestamp, or -1 if the key has no expiration, or -2 if the key doesn't exist
+     */
+    expiretime(key: string | NodeJS.TypedArray | Blob): Promise<number>;
+
+    /**
+     * Get the value of a key and delete the key
+     * @param key The key to get and delete
+     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     */
+    getdel(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+
+    /**
+     * Get the value of a key and optionally set its expiration
+     * @param key The key to get
+     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     */
+    getex(key: string | NodeJS.TypedArray | Blob): Promise<string | null>;
+  }
+
+  /**
+   * Default Redis client
+   *
+   * Connection information populated from one of, in order of preference:
+   * - `process.env.VALKEY_URL`
+   * - `process.env.REDIS_URL`
+   * - `"valkey://localhost:6379"`
+   *
+   */
+  export const redis: RedisClient;
+}