rivetkit 2.0.38 → 2.0.40

package/dist/tsup/{chunk-MIOU6BF3.js → chunk-KVB2SG32.js}

@@ -31,7 +31,7 @@ import {
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-4U45T5KW.js";
+} from "./chunk-ZUMPCWKF.js";
 import {
   ConnStateNotEnabled,
   Forbidden,
@@ -152,12 +152,215 @@ import * as cbor3 from "cbor-x";
 // src/actor/router-endpoints.ts
 import * as cbor2 from "cbor-x";
 
+// src/actor/instance/keys.ts
+var KEYS = {
+  PERSIST_DATA: Uint8Array.from([1]),
+  CONN_PREFIX: Uint8Array.from([2]),
+  // Prefix for connection keys
+  INSPECTOR_TOKEN: Uint8Array.from([3]),
+  // Inspector token key
+  KV: Uint8Array.from([4])
+  // Prefix for user-facing KV storage
+};
+function makePrefixedKey(key) {
+  const prefixed = new Uint8Array(KEYS.KV.length + key.length);
+  prefixed.set(KEYS.KV, 0);
+  prefixed.set(key, KEYS.KV.length);
+  return prefixed;
+}
+function removePrefixFromKey(prefixedKey) {
+  return prefixedKey.slice(KEYS.KV.length);
+}
+function makeConnKey(connId) {
+  const encoder = new TextEncoder();
+  const connIdBytes = encoder.encode(connId);
+  const key = new Uint8Array(KEYS.CONN_PREFIX.length + connIdBytes.length);
+  key.set(KEYS.CONN_PREFIX, 0);
+  key.set(connIdBytes, KEYS.CONN_PREFIX.length);
+  return key;
+}
+
+// src/actor/instance/kv.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function encodeKey(key, keyType) {
+  if (key instanceof Uint8Array) {
+    return key;
+  }
+  const resolvedKeyType = keyType ?? "text";
+  if (resolvedKeyType === "binary") {
+    throw new TypeError("Expected a Uint8Array when keyType is binary");
+  }
+  return textEncoder.encode(key);
+}
+function decodeKey(key, keyType) {
+  const resolvedKeyType = keyType ?? "text";
+  switch (resolvedKeyType) {
+    case "text":
+      return textDecoder.decode(key);
+    case "binary":
+      return key;
+    default:
+      throw new TypeError("Invalid kv key type");
+  }
+}
+function resolveValueType(value) {
+  if (typeof value === "string") {
+    return "text";
+  }
+  if (value instanceof Uint8Array) {
+    return "binary";
+  }
+  if (value instanceof ArrayBuffer) {
+    return "arrayBuffer";
+  }
+  throw new TypeError("Invalid kv value");
+}
+function encodeValue(value, options) {
+  const type = (options == null ? void 0 : options.type) ?? resolveValueType(value);
+  switch (type) {
+    case "text":
+      if (typeof value !== "string") {
+        throw new TypeError("Expected a string when type is text");
+      }
+      return textEncoder.encode(value);
+    case "arrayBuffer":
+      if (!(value instanceof ArrayBuffer)) {
+        throw new TypeError("Expected an ArrayBuffer when type is arrayBuffer");
+      }
+      return new Uint8Array(value);
+    case "binary":
+      if (!(value instanceof Uint8Array)) {
+        throw new TypeError("Expected a Uint8Array when type is binary");
+      }
+      return value;
+    default:
+      throw new TypeError("Invalid kv value type");
+  }
+}
+function decodeValue(value, options) {
+  const type = (options == null ? void 0 : options.type) ?? "text";
+  switch (type) {
+    case "text":
+      return textDecoder.decode(value);
+    case "arrayBuffer": {
+      const copy = new Uint8Array(value.byteLength);
+      copy.set(value);
+      return copy.buffer;
+    }
+    case "binary":
+      return value;
+    default:
+      throw new TypeError("Invalid kv value type");
+  }
+}
+var ActorKv = class {
+  #driver;
+  #actorId;
+  constructor(driver, actorId) {
+    this.#driver = driver;
+    this.#actorId = actorId;
+  }
+  /**
+   * Get a single value by key.
+   */
+  async get(key, options) {
+    const results = await this.#driver.kvBatchGet(this.#actorId, [
+      makePrefixedKey(encodeKey(key))
+    ]);
+    const result = results[0];
+    if (!result) {
+      return null;
+    }
+    return decodeValue(result, options);
+  }
+  /**
+   * Get multiple values by keys.
+   */
+  async getBatch(keys, options) {
+    const prefixedKeys = keys.map(
+      (key) => makePrefixedKey(encodeKey(key))
+    );
+    const results = await this.#driver.kvBatchGet(
+      this.#actorId,
+      prefixedKeys
+    );
+    return results.map(
+      (result) => result ? decodeValue(result, options) : null
+    );
+  }
+  /**
+   * Put a single key-value pair.
+   */
+  async put(key, value, options) {
+    await this.#driver.kvBatchPut(this.#actorId, [
+      [makePrefixedKey(encodeKey(key)), encodeValue(value, options)]
+    ]);
+  }
+  /**
+   * Put multiple key-value pairs.
+   */
+  async putBatch(entries, options) {
+    const prefixedEntries = entries.map(
+      ([key, value]) => [
+        makePrefixedKey(encodeKey(key)),
+        encodeValue(value, options)
+      ]
+    );
+    await this.#driver.kvBatchPut(this.#actorId, prefixedEntries);
+  }
+  /**
+   * Delete a single key.
+   */
+  async delete(key) {
+    await this.#driver.kvBatchDelete(this.#actorId, [
+      makePrefixedKey(encodeKey(key))
+    ]);
+  }
+  /**
+   * Delete multiple keys.
+   */
+  async deleteBatch(keys) {
+    const prefixedKeys = keys.map(
+      (key) => makePrefixedKey(encodeKey(key))
+    );
+    await this.#driver.kvBatchDelete(this.#actorId, prefixedKeys);
+  }
+  /**
+   * List all keys with a given prefix.
+   * Returns key-value pairs where keys have the user prefix removed.
+   */
+  async list(prefix, options) {
+    const prefixedPrefix = makePrefixedKey(
+      encodeKey(prefix, options == null ? void 0 : options.keyType)
+    );
+    const results = await this.#driver.kvListPrefix(
+      this.#actorId,
+      prefixedPrefix
+    );
+    return results.map(([key, value]) => [
+      decodeKey(removePrefixFromKey(key), options == null ? void 0 : options.keyType),
+      decodeValue(value, options)
+    ]);
+  }
+};
+
 // src/actor/contexts/base/actor.ts
 var ActorContext = class {
   #actor;
+  #kv;
   constructor(actor) {
     this.#actor = actor;
   }
+  /**
+   * Gets the KV storage interface.
+   */
+  get kv() {
+    if (!this.#kv) {
+      this.#kv = new ActorKv(this.#actor.driver, this.#actor.id);
+    }
+    return this.#kv;
+  }
   /**
    * Get the actor state
    *
@@ -1902,6 +2105,12 @@ var RegistryConfigSchema = z7.object({
    * What port to run the manager on.
    */
   managerPort: z7.number().optional().default(6420),
+  /**
+   * @experimental
+   *
+   * What host to bind the manager server to.
+   */
+  managerHost: z7.string().optional(),
   /** @experimental */
   inspector: InspectorConfigSchema,
   // MARK: Runtime-specific
@@ -3132,9 +3341,10 @@ async function routeWebSocket(request, requestPath, requestHeaders, config6, act
       isHibernatable
     });
     const closePromiseResolvers = promiseWithResolvers();
+    const requestPathWithoutQuery = requestPath.split("?")[0];
     let handler;
     let connDriver;
-    if (requestPath === PATH_CONNECT) {
+    if (requestPathWithoutQuery === PATH_CONNECT) {
       const { driver, setWebSocket } = createWebSocketDriver(
         isHibernatable ? { gatewayId, requestId } : void 0,
         encoding,
@@ -3143,14 +3353,14 @@ async function routeWebSocket(request, requestPath, requestHeaders, config6, act
       );
       handler = handleWebSocketConnect.bind(void 0, setWebSocket);
       connDriver = driver;
-    } else if (requestPath === PATH_WEBSOCKET_BASE || requestPath.startsWith(PATH_WEBSOCKET_PREFIX)) {
+    } else if (requestPathWithoutQuery === PATH_WEBSOCKET_BASE || requestPathWithoutQuery.startsWith(PATH_WEBSOCKET_PREFIX)) {
       const { driver, setWebSocket } = createRawWebSocketDriver(
         isHibernatable ? { gatewayId, requestId } : void 0,
         closePromiseResolvers.promise
       );
       handler = handleRawWebSocket.bind(void 0, setWebSocket);
       connDriver = driver;
-    } else if (requestPath === PATH_INSPECTOR_CONNECT) {
+    } else if (requestPathWithoutQuery === PATH_INSPECTOR_CONNECT) {
       if (!actor.inspectorToken) {
         throw "WebSocket Inspector Unauthorized: actor does not provide inspector access";
       }
@@ -3338,7 +3548,7 @@ function parseWebSocketProtocols(protocols) {
       }
     }
   }
-  const encoding = EncodingSchema.parse(encodingRaw);
+  const encoding = EncodingSchema.parse(encodingRaw ?? "json");
   const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
   return { encoding, connParams };
 }
@@ -4200,23 +4410,6 @@ function createApiActor(actor) {
 // src/driver-helpers/utils.ts
 import * as cbor7 from "cbor-x";
 
-// src/actor/instance/kv.ts
-var KEYS = {
-  PERSIST_DATA: Uint8Array.from([1]),
-  CONN_PREFIX: Uint8Array.from([2]),
-  // Prefix for connection keys
-  INSPECTOR_TOKEN: Uint8Array.from([3])
-  // Inspector token key
-};
-function makeConnKey(connId) {
-  const encoder = new TextEncoder();
-  const connIdBytes = encoder.encode(connId);
-  const key = new Uint8Array(KEYS.CONN_PREFIX.length + connIdBytes.length);
-  key.set(KEYS.CONN_PREFIX, 0);
-  key.set(connIdBytes, KEYS.CONN_PREFIX.length);
-  return key;
-}
-
 // src/schemas/actor-persist/versioned.ts
 import { createVersionedDataHandler as createVersionedDataHandler2 } from "vbare";
 
@@ -4936,6 +5129,9 @@ export {
   CONN_STATE_MANAGER_SYMBOL,
   CONN_SEND_MESSAGE_SYMBOL,
   Conn,
+  KEYS,
+  makeConnKey,
+  ActorKv,
   ActorContext,
   ActionContext,
   CURRENT_VERSION2,
@@ -4951,8 +5147,6 @@ export {
   getValueLength,
   inputDataToBuffer,
   processMessage,
-  KEYS,
-  makeConnKey,
   PATH_CONNECT,
   PATH_WEBSOCKET_BASE,
   PATH_WEBSOCKET_PREFIX,
@@ -4999,4 +5193,4 @@ export {
   buildManagerRouter,
   getInitialActorKvState
 };
-//# sourceMappingURL=chunk-MIOU6BF3.js.map
+//# sourceMappingURL=chunk-KVB2SG32.js.map