dialcache 0.1.1

package/dist/redis-protocol.cjs

@@ -0,0 +1,197 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/redis-protocol.ts
+var redis_protocol_exports = {};
+__export(redis_protocol_exports, {
+  INVALIDATE_CACHE_SCRIPT: () => INVALIDATE_CACHE_SCRIPT,
+  READ_CACHE_SCRIPT: () => READ_CACHE_SCRIPT,
+  READ_TRACKED_CACHE_SCRIPT: () => READ_TRACKED_CACHE_SCRIPT,
+  REDIS_ENCODING_BINARY: () => REDIS_ENCODING_BINARY,
+  REDIS_ENCODING_UTF8: () => REDIS_ENCODING_UTF8,
+  REDIS_FRAME_VERSION: () => REDIS_FRAME_VERSION,
+  WRITE_CACHE_SCRIPT: () => WRITE_CACHE_SCRIPT,
+  WRITE_TRACKED_CACHE_SCRIPT: () => WRITE_TRACKED_CACHE_SCRIPT
+});
+module.exports = __toCommonJS(redis_protocol_exports);
+
+// src/internal/redis-scripts.ts
+var REDIS_FRAME_VERSION = 1;
+var REDIS_ENCODING_UTF8 = 0;
+var REDIS_ENCODING_BINARY = 1;
+var WATERMARK_TTL_MARGIN_MS = 6e4;
+var PARSE_WATERMARK_LUA = String.raw`local function parse_watermark(raw)
+  if not string.match(raw, "^%d+$") and not string.match(raw, "^%d+%.%d+$") then
+    return nil
+  end
+  local value = tonumber(raw)
+  if not value or value >= math.huge then
+    return nil
+  end
+  return value
+end`;
+var CEIL_FINITE_NUMBER_LUA = String.raw`local function ceil_finite_number(raw)
+  local value = tonumber(raw)
+  if not value or value ~= value or value >= math.huge or value <= -math.huge then
+    return nil
+  end
+  return math.ceil(value)
+end`;
+var READ_FRAME_LUA = String.raw`local value = redis.call("GET", KEYS[1])
+if not value or string.len(value) < 10 then
+  return false
+end
+
+if string.byte(value, 1) ~= ${REDIS_FRAME_VERSION} then
+  return false
+end`;
+var RETURN_PAYLOAD_LUA = String.raw`return string.sub(value, 10)`;
+var VALIDATE_WRITE_ARGUMENTS_LUA = String.raw`local cache_ttl_ms = ceil_finite_number(ARGV[1])
+local encoding = tonumber(ARGV[2])
+if not cache_ttl_ms or cache_ttl_ms <= 0 then
+  return redis.error_reply("ERR invalid DialCache TTL")
+end
+if not encoding or (encoding ~= ${REDIS_ENCODING_UTF8} and encoding ~= ${REDIS_ENCODING_BINARY}) then
+  return redis.error_reply("ERR invalid DialCache payload encoding")
+end`;
+var REDIS_TIME_LUA = String.raw`local redis_time = redis.call("TIME")
+local now_ms = tonumber(redis_time[1]) * 1000 + math.floor(tonumber(redis_time[2]) / 1000)`;
+var WRITE_FRAME_LUA = String.raw`local frame = string.char(${REDIS_FRAME_VERSION})
+  .. struct.pack(">I8", now_ms)
+  .. string.char(encoding)
+  .. ARGV[3]
+redis.call("SET", KEYS[1], frame, "PX", cache_ttl_ms)`;
+var READ_CACHE_SCRIPT = [READ_FRAME_LUA, RETURN_PAYLOAD_LUA].join("\n\n");
+var READ_TRACKED_CACHE_SCRIPT = [
+  PARSE_WATERMARK_LUA,
+  READ_FRAME_LUA,
+  String.raw`local raw_watermark = redis.call("GET", KEYS[2])
+if not raw_watermark then
+  return false
+end
+
+local watermark = parse_watermark(raw_watermark)
+if not watermark then
+  return false
+end
+
+local created_at = struct.unpack(">I8", string.sub(value, 2, 9))
+if created_at <= watermark then
+  return false
+end`,
+  RETURN_PAYLOAD_LUA
+].join("\n\n");
+var WRITE_CACHE_SCRIPT = [
+  CEIL_FINITE_NUMBER_LUA,
+  VALIDATE_WRITE_ARGUMENTS_LUA,
+  REDIS_TIME_LUA,
+  WRITE_FRAME_LUA,
+  "return 1"
+].join("\n\n");
+var WRITE_TRACKED_CACHE_SCRIPT = [
+  PARSE_WATERMARK_LUA,
+  CEIL_FINITE_NUMBER_LUA,
+  VALIDATE_WRITE_ARGUMENTS_LUA,
+  String.raw`local watermark_ttl_floor_ms = ceil_finite_number(ARGV[4])
+if not watermark_ttl_floor_ms or watermark_ttl_floor_ms <= 0 then
+  return redis.error_reply("ERR invalid DialCache watermark TTL")
+end`,
+  REDIS_TIME_LUA,
+  String.raw`local raw_watermark = redis.call("GET", KEYS[2])
+local watermark = 0
+if raw_watermark then
+  watermark = parse_watermark(raw_watermark)
+  if not watermark then
+    return redis.error_reply("ERR invalid DialCache watermark")
+  end
+end
+
+if watermark >= now_ms then
+  return 0
+end`,
+  WRITE_FRAME_LUA,
+  String.raw`local desired_ttl_ms = math.max(watermark_ttl_floor_ms, cache_ttl_ms + ${WATERMARK_TTL_MARGIN_MS})
+if not raw_watermark then
+  redis.call("SET", KEYS[2], "0", "PX", desired_ttl_ms)
+else
+  local current_ttl_ms = redis.call("PTTL", KEYS[2])
+  if current_ttl_ms == -2 then
+    redis.call("SET", KEYS[2], raw_watermark, "PX", desired_ttl_ms)
+  elseif current_ttl_ms ~= -1 and current_ttl_ms < desired_ttl_ms then
+    redis.call("PEXPIRE", KEYS[2], desired_ttl_ms)
+  end
+end`,
+  "return 1"
+].join("\n\n");
+var INVALIDATE_CACHE_SCRIPT = [
+  PARSE_WATERMARK_LUA,
+  CEIL_FINITE_NUMBER_LUA,
+  String.raw`local future_buffer_ms = ceil_finite_number(ARGV[1])
+local watermark_ttl_floor_ms = ceil_finite_number(ARGV[2])
+if not future_buffer_ms or future_buffer_ms < 0 then
+  return redis.error_reply("ERR invalid DialCache future buffer")
+end
+if not watermark_ttl_floor_ms or watermark_ttl_floor_ms <= 0 then
+  return redis.error_reply("ERR invalid DialCache watermark TTL")
+end`,
+  REDIS_TIME_LUA,
+  String.raw`local proposed_watermark = now_ms + future_buffer_ms
+local raw_watermark = redis.call("GET", KEYS[1])
+local current_watermark = 0
+
+if raw_watermark then
+  local parsed_watermark = parse_watermark(raw_watermark)
+  if parsed_watermark then
+    current_watermark = parsed_watermark
+  end
+end
+
+local watermark = math.ceil(math.max(current_watermark, proposed_watermark))
+local current_ttl_ms = -2
+if raw_watermark then
+  current_ttl_ms = redis.call("PTTL", KEYS[1])
+end
+local desired_ttl_ms = math.max(
+  watermark_ttl_floor_ms,
+  future_buffer_ms + ${WATERMARK_TTL_MARGIN_MS},
+  watermark - now_ms + ${WATERMARK_TTL_MARGIN_MS}
+)
+if current_ttl_ms > desired_ttl_ms then
+  desired_ttl_ms = current_ttl_ms
+end
+
+local encoded_watermark = string.format("%.0f", watermark)
+if current_ttl_ms == -1 then
+  redis.call("SET", KEYS[1], encoded_watermark)
+else
+  redis.call("SET", KEYS[1], encoded_watermark, "PX", desired_ttl_ms)
+end`,
+  "return 1"
+].join("\n\n");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INVALIDATE_CACHE_SCRIPT,
+  READ_CACHE_SCRIPT,
+  READ_TRACKED_CACHE_SCRIPT,
+  REDIS_ENCODING_BINARY,
+  REDIS_ENCODING_UTF8,
+  REDIS_FRAME_VERSION,
+  WRITE_CACHE_SCRIPT,
+  WRITE_TRACKED_CACHE_SCRIPT
+});

package/dist/redis-protocol.d.cts

@@ -0,0 +1,10 @@
+declare const REDIS_FRAME_VERSION = 1;
+declare const REDIS_ENCODING_UTF8 = 0;
+declare const REDIS_ENCODING_BINARY = 1;
+declare const READ_CACHE_SCRIPT: string;
+declare const READ_TRACKED_CACHE_SCRIPT: string;
+declare const WRITE_CACHE_SCRIPT: string;
+declare const WRITE_TRACKED_CACHE_SCRIPT: string;
+declare const INVALIDATE_CACHE_SCRIPT: string;
+
+export { INVALIDATE_CACHE_SCRIPT, READ_CACHE_SCRIPT, READ_TRACKED_CACHE_SCRIPT, REDIS_ENCODING_BINARY, REDIS_ENCODING_UTF8, REDIS_FRAME_VERSION, WRITE_CACHE_SCRIPT, WRITE_TRACKED_CACHE_SCRIPT };

package/dist/redis-protocol.d.ts

@@ -0,0 +1,10 @@
+declare const REDIS_FRAME_VERSION = 1;
+declare const REDIS_ENCODING_UTF8 = 0;
+declare const REDIS_ENCODING_BINARY = 1;
+declare const READ_CACHE_SCRIPT: string;
+declare const READ_TRACKED_CACHE_SCRIPT: string;
+declare const WRITE_CACHE_SCRIPT: string;
+declare const WRITE_TRACKED_CACHE_SCRIPT: string;
+declare const INVALIDATE_CACHE_SCRIPT: string;
+
+export { INVALIDATE_CACHE_SCRIPT, READ_CACHE_SCRIPT, READ_TRACKED_CACHE_SCRIPT, REDIS_ENCODING_BINARY, REDIS_ENCODING_UTF8, REDIS_FRAME_VERSION, WRITE_CACHE_SCRIPT, WRITE_TRACKED_CACHE_SCRIPT };

package/dist/redis-protocol.js

@@ -0,0 +1,20 @@
+import {
+  INVALIDATE_CACHE_SCRIPT,
+  READ_CACHE_SCRIPT,
+  READ_TRACKED_CACHE_SCRIPT,
+  REDIS_ENCODING_BINARY,
+  REDIS_ENCODING_UTF8,
+  REDIS_FRAME_VERSION,
+  WRITE_CACHE_SCRIPT,
+  WRITE_TRACKED_CACHE_SCRIPT
+} from "./chunk-2TPHNNE7.js";
+export {
+  INVALIDATE_CACHE_SCRIPT,
+  READ_CACHE_SCRIPT,
+  READ_TRACKED_CACHE_SCRIPT,
+  REDIS_ENCODING_BINARY,
+  REDIS_ENCODING_UTF8,
+  REDIS_FRAME_VERSION,
+  WRITE_CACHE_SCRIPT,
+  WRITE_TRACKED_CACHE_SCRIPT
+};

package/dist/valkey-glide.cjs

@@ -0,0 +1,299 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/valkey-glide.ts
+var valkey_glide_exports = {};
+__export(valkey_glide_exports, {
+  createValkeyGlideDialCacheClient: () => createValkeyGlideDialCacheClient
+});
+module.exports = __toCommonJS(valkey_glide_exports);
+var import_valkey_glide = require("@valkey/valkey-glide");
+
+// src/redis-client.ts
+var DialCacheRedisPayloadError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DialCacheRedisPayloadError";
+  }
+};
+var DialCacheRedisPayloadEncodingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DialCacheRedisPayloadEncodingError";
+  }
+};
+
+// src/internal/redis-scripts.ts
+var REDIS_FRAME_VERSION = 1;
+var REDIS_ENCODING_UTF8 = 0;
+var REDIS_ENCODING_BINARY = 1;
+var WATERMARK_TTL_MARGIN_MS = 6e4;
+var PARSE_WATERMARK_LUA = String.raw`local function parse_watermark(raw)
+  if not string.match(raw, "^%d+$") and not string.match(raw, "^%d+%.%d+$") then
+    return nil
+  end
+  local value = tonumber(raw)
+  if not value or value >= math.huge then
+    return nil
+  end
+  return value
+end`;
+var CEIL_FINITE_NUMBER_LUA = String.raw`local function ceil_finite_number(raw)
+  local value = tonumber(raw)
+  if not value or value ~= value or value >= math.huge or value <= -math.huge then
+    return nil
+  end
+  return math.ceil(value)
+end`;
+var READ_FRAME_LUA = String.raw`local value = redis.call("GET", KEYS[1])
+if not value or string.len(value) < 10 then
+  return false
+end
+
+if string.byte(value, 1) ~= ${REDIS_FRAME_VERSION} then
+  return false
+end`;
+var RETURN_PAYLOAD_LUA = String.raw`return string.sub(value, 10)`;
+var VALIDATE_WRITE_ARGUMENTS_LUA = String.raw`local cache_ttl_ms = ceil_finite_number(ARGV[1])
+local encoding = tonumber(ARGV[2])
+if not cache_ttl_ms or cache_ttl_ms <= 0 then
+  return redis.error_reply("ERR invalid DialCache TTL")
+end
+if not encoding or (encoding ~= ${REDIS_ENCODING_UTF8} and encoding ~= ${REDIS_ENCODING_BINARY}) then
+  return redis.error_reply("ERR invalid DialCache payload encoding")
+end`;
+var REDIS_TIME_LUA = String.raw`local redis_time = redis.call("TIME")
+local now_ms = tonumber(redis_time[1]) * 1000 + math.floor(tonumber(redis_time[2]) / 1000)`;
+var WRITE_FRAME_LUA = String.raw`local frame = string.char(${REDIS_FRAME_VERSION})
+  .. struct.pack(">I8", now_ms)
+  .. string.char(encoding)
+  .. ARGV[3]
+redis.call("SET", KEYS[1], frame, "PX", cache_ttl_ms)`;
+var READ_CACHE_SCRIPT = [READ_FRAME_LUA, RETURN_PAYLOAD_LUA].join("\n\n");
+var READ_TRACKED_CACHE_SCRIPT = [
+  PARSE_WATERMARK_LUA,
+  READ_FRAME_LUA,
+  String.raw`local raw_watermark = redis.call("GET", KEYS[2])
+if not raw_watermark then
+  return false
+end
+
+local watermark = parse_watermark(raw_watermark)
+if not watermark then
+  return false
+end
+
+local created_at = struct.unpack(">I8", string.sub(value, 2, 9))
+if created_at <= watermark then
+  return false
+end`,
+  RETURN_PAYLOAD_LUA
+].join("\n\n");
+var WRITE_CACHE_SCRIPT = [
+  CEIL_FINITE_NUMBER_LUA,
+  VALIDATE_WRITE_ARGUMENTS_LUA,
+  REDIS_TIME_LUA,
+  WRITE_FRAME_LUA,
+  "return 1"
+].join("\n\n");
+var WRITE_TRACKED_CACHE_SCRIPT = [
+  PARSE_WATERMARK_LUA,
+  CEIL_FINITE_NUMBER_LUA,
+  VALIDATE_WRITE_ARGUMENTS_LUA,
+  String.raw`local watermark_ttl_floor_ms = ceil_finite_number(ARGV[4])
+if not watermark_ttl_floor_ms or watermark_ttl_floor_ms <= 0 then
+  return redis.error_reply("ERR invalid DialCache watermark TTL")
+end`,
+  REDIS_TIME_LUA,
+  String.raw`local raw_watermark = redis.call("GET", KEYS[2])
+local watermark = 0
+if raw_watermark then
+  watermark = parse_watermark(raw_watermark)
+  if not watermark then
+    return redis.error_reply("ERR invalid DialCache watermark")
+  end
+end
+
+if watermark >= now_ms then
+  return 0
+end`,
+  WRITE_FRAME_LUA,
+  String.raw`local desired_ttl_ms = math.max(watermark_ttl_floor_ms, cache_ttl_ms + ${WATERMARK_TTL_MARGIN_MS})
+if not raw_watermark then
+  redis.call("SET", KEYS[2], "0", "PX", desired_ttl_ms)
+else
+  local current_ttl_ms = redis.call("PTTL", KEYS[2])
+  if current_ttl_ms == -2 then
+    redis.call("SET", KEYS[2], raw_watermark, "PX", desired_ttl_ms)
+  elseif current_ttl_ms ~= -1 and current_ttl_ms < desired_ttl_ms then
+    redis.call("PEXPIRE", KEYS[2], desired_ttl_ms)
+  end
+end`,
+  "return 1"
+].join("\n\n");
+var INVALIDATE_CACHE_SCRIPT = [
+  PARSE_WATERMARK_LUA,
+  CEIL_FINITE_NUMBER_LUA,
+  String.raw`local future_buffer_ms = ceil_finite_number(ARGV[1])
+local watermark_ttl_floor_ms = ceil_finite_number(ARGV[2])
+if not future_buffer_ms or future_buffer_ms < 0 then
+  return redis.error_reply("ERR invalid DialCache future buffer")
+end
+if not watermark_ttl_floor_ms or watermark_ttl_floor_ms <= 0 then
+  return redis.error_reply("ERR invalid DialCache watermark TTL")
+end`,
+  REDIS_TIME_LUA,
+  String.raw`local proposed_watermark = now_ms + future_buffer_ms
+local raw_watermark = redis.call("GET", KEYS[1])
+local current_watermark = 0
+
+if raw_watermark then
+  local parsed_watermark = parse_watermark(raw_watermark)
+  if parsed_watermark then
+    current_watermark = parsed_watermark
+  end
+end
+
+local watermark = math.ceil(math.max(current_watermark, proposed_watermark))
+local current_ttl_ms = -2
+if raw_watermark then
+  current_ttl_ms = redis.call("PTTL", KEYS[1])
+end
+local desired_ttl_ms = math.max(
+  watermark_ttl_floor_ms,
+  future_buffer_ms + ${WATERMARK_TTL_MARGIN_MS},
+  watermark - now_ms + ${WATERMARK_TTL_MARGIN_MS}
+)
+if current_ttl_ms > desired_ttl_ms then
+  desired_ttl_ms = current_ttl_ms
+end
+
+local encoded_watermark = string.format("%.0f", watermark)
+if current_ttl_ms == -1 then
+  redis.call("SET", KEYS[1], encoded_watermark)
+else
+  redis.call("SET", KEYS[1], encoded_watermark, "PX", desired_ttl_ms)
+end`,
+  "return 1"
+].join("\n\n");
+
+// src/internal/redis-payload.ts
+function redisPayloadEncoding(value) {
+  return Buffer.isBuffer(value) ? REDIS_ENCODING_BINARY : REDIS_ENCODING_UTF8;
+}
+function decodeRedisPayload(raw) {
+  if (raw.length === 0) {
+    throw new DialCacheRedisPayloadError("Invalid DialCache Redis payload");
+  }
+  const encoding = raw[0];
+  const payload = raw.subarray(1);
+  if (encoding === REDIS_ENCODING_UTF8) {
+    return payload.toString("utf8");
+  }
+  if (encoding === REDIS_ENCODING_BINARY) {
+    return payload;
+  }
+  throw new DialCacheRedisPayloadEncodingError("Invalid DialCache Redis payload encoding");
+}
+
+// src/valkey-glide.ts
+function createValkeyGlideDialCacheClient(client) {
+  const scripts = {
+    read: new import_valkey_glide.Script(READ_CACHE_SCRIPT),
+    readTracked: new import_valkey_glide.Script(READ_TRACKED_CACHE_SCRIPT),
+    write: new import_valkey_glide.Script(WRITE_CACHE_SCRIPT),
+    writeTracked: new import_valkey_glide.Script(WRITE_TRACKED_CACHE_SCRIPT),
+    invalidate: new import_valkey_glide.Script(INVALIDATE_CACHE_SCRIPT)
+  };
+  let disposed = false;
+  let activeInvocations = 0;
+  const invoke = async (script, keys, args = []) => {
+    if (disposed) {
+      throw new Error("Valkey GLIDE DialCache client is disposed");
+    }
+    activeInvocations += 1;
+    try {
+      return await client.invokeScript(script, { keys, args, decoder: import_valkey_glide.Decoder.Bytes });
+    } finally {
+      activeInvocations -= 1;
+    }
+  };
+  return {
+    async read({ valueKey, watermarkKey }) {
+      const raw = watermarkKey === void 0 ? await invoke(scripts.read, [valueKey]) : await invoke(scripts.readTracked, [valueKey, watermarkKey]);
+      if (raw === null) {
+        return null;
+      }
+      if (!Buffer.isBuffer(raw)) {
+        throw new DialCacheRedisPayloadError("Invalid DialCache Redis payload reply");
+      }
+      return decodeRedisPayload(raw);
+    },
+    async write(request) {
+      const { valueKey, watermarkKey, cacheTtlMs, value } = request;
+      const encoding = redisPayloadEncoding(value);
+      const raw = watermarkKey === void 0 ? await invoke(scripts.write, [valueKey], [String(cacheTtlMs), String(encoding), value]) : await invoke(
+        scripts.writeTracked,
+        [valueKey, watermarkKey],
+        [String(cacheTtlMs), String(encoding), value, String(request.watermarkTtlFloorMs)]
+      );
+      return integerReply(raw, "write") === 1;
+    },
+    async invalidate({ watermarkKey, futureBufferMs, watermarkTtlFloorMs }) {
+      const raw = await invoke(
+        scripts.invalidate,
+        [watermarkKey],
+        [String(futureBufferMs), String(watermarkTtlFloorMs)]
+      );
+      integerReply(raw, "invalidate");
+    },
+    async flushAll() {
+      if (disposed) {
+        throw new Error("Valkey GLIDE DialCache client is disposed");
+      }
+      if (client instanceof import_valkey_glide.GlideClusterClient) {
+        await client.flushall({ route: "allPrimaries" });
+      } else {
+        await client.flushall();
+      }
+    },
+    dispose() {
+      if (disposed) {
+        return;
+      }
+      if (activeInvocations > 0) {
+        throw new Error("Cannot dispose Valkey GLIDE DialCache client while operations are in flight");
+      }
+      disposed = true;
+      for (const script of Object.values(scripts)) {
+        script.release();
+      }
+    }
+  };
+}
+function integerReply(reply, operation) {
+  if (typeof reply !== "number") {
+    throw new Error(`Invalid DialCache Redis ${operation} reply`);
+  }
+  return reply;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createValkeyGlideDialCacheClient
+});

package/dist/valkey-glide.d.cts

@@ -0,0 +1,12 @@
+import { GlideClient, GlideClusterClient } from '@valkey/valkey-glide';
+import { k as DialCacheRedisClient } from './config-B7bGp-Xj.cjs';
+import 'prom-client';
+
+type SupportedValkeyGlideClient = GlideClient | GlideClusterClient;
+interface ValkeyGlideDialCacheClient extends DialCacheRedisClient {
+    /** Release the adapter-owned GLIDE Script handles. Does not close the wrapped GLIDE client. */
+    dispose(): void;
+}
+declare function createValkeyGlideDialCacheClient(client: SupportedValkeyGlideClient): ValkeyGlideDialCacheClient;
+
+export { type ValkeyGlideDialCacheClient, createValkeyGlideDialCacheClient };

package/dist/valkey-glide.d.ts

@@ -0,0 +1,12 @@
+import { GlideClient, GlideClusterClient } from '@valkey/valkey-glide';
+import { k as DialCacheRedisClient } from './config-B7bGp-Xj.js';
+import 'prom-client';
+
+type SupportedValkeyGlideClient = GlideClient | GlideClusterClient;
+interface ValkeyGlideDialCacheClient extends DialCacheRedisClient {
+    /** Release the adapter-owned GLIDE Script handles. Does not close the wrapped GLIDE client. */
+    dispose(): void;
+}
+declare function createValkeyGlideDialCacheClient(client: SupportedValkeyGlideClient): ValkeyGlideDialCacheClient;
+
+export { type ValkeyGlideDialCacheClient, createValkeyGlideDialCacheClient };

package/dist/valkey-glide.js

@@ -0,0 +1,104 @@
+import {
+  decodeRedisPayload,
+  redisPayloadEncoding
+} from "./chunk-BF6XTPTS.js";
+import {
+  DialCacheRedisPayloadError
+} from "./chunk-S5VCTJID.js";
+import {
+  INVALIDATE_CACHE_SCRIPT,
+  READ_CACHE_SCRIPT,
+  READ_TRACKED_CACHE_SCRIPT,
+  WRITE_CACHE_SCRIPT,
+  WRITE_TRACKED_CACHE_SCRIPT
+} from "./chunk-2TPHNNE7.js";
+
+// src/valkey-glide.ts
+import {
+  Decoder,
+  GlideClusterClient,
+  Script
+} from "@valkey/valkey-glide";
+function createValkeyGlideDialCacheClient(client) {
+  const scripts = {
+    read: new Script(READ_CACHE_SCRIPT),
+    readTracked: new Script(READ_TRACKED_CACHE_SCRIPT),
+    write: new Script(WRITE_CACHE_SCRIPT),
+    writeTracked: new Script(WRITE_TRACKED_CACHE_SCRIPT),
+    invalidate: new Script(INVALIDATE_CACHE_SCRIPT)
+  };
+  let disposed = false;
+  let activeInvocations = 0;
+  const invoke = async (script, keys, args = []) => {
+    if (disposed) {
+      throw new Error("Valkey GLIDE DialCache client is disposed");
+    }
+    activeInvocations += 1;
+    try {
+      return await client.invokeScript(script, { keys, args, decoder: Decoder.Bytes });
+    } finally {
+      activeInvocations -= 1;
+    }
+  };
+  return {
+    async read({ valueKey, watermarkKey }) {
+      const raw = watermarkKey === void 0 ? await invoke(scripts.read, [valueKey]) : await invoke(scripts.readTracked, [valueKey, watermarkKey]);
+      if (raw === null) {
+        return null;
+      }
+      if (!Buffer.isBuffer(raw)) {
+        throw new DialCacheRedisPayloadError("Invalid DialCache Redis payload reply");
+      }
+      return decodeRedisPayload(raw);
+    },
+    async write(request) {
+      const { valueKey, watermarkKey, cacheTtlMs, value } = request;
+      const encoding = redisPayloadEncoding(value);
+      const raw = watermarkKey === void 0 ? await invoke(scripts.write, [valueKey], [String(cacheTtlMs), String(encoding), value]) : await invoke(
+        scripts.writeTracked,
+        [valueKey, watermarkKey],
+        [String(cacheTtlMs), String(encoding), value, String(request.watermarkTtlFloorMs)]
+      );
+      return integerReply(raw, "write") === 1;
+    },
+    async invalidate({ watermarkKey, futureBufferMs, watermarkTtlFloorMs }) {
+      const raw = await invoke(
+        scripts.invalidate,
+        [watermarkKey],
+        [String(futureBufferMs), String(watermarkTtlFloorMs)]
+      );
+      integerReply(raw, "invalidate");
+    },
+    async flushAll() {
+      if (disposed) {
+        throw new Error("Valkey GLIDE DialCache client is disposed");
+      }
+      if (client instanceof GlideClusterClient) {
+        await client.flushall({ route: "allPrimaries" });
+      } else {
+        await client.flushall();
+      }
+    },
+    dispose() {
+      if (disposed) {
+        return;
+      }
+      if (activeInvocations > 0) {
+        throw new Error("Cannot dispose Valkey GLIDE DialCache client while operations are in flight");
+      }
+      disposed = true;
+      for (const script of Object.values(scripts)) {
+        script.release();
+      }
+    }
+  };
+}
+function integerReply(reply, operation) {
+  if (typeof reply !== "number") {
+    throw new Error(`Invalid DialCache Redis ${operation} reply`);
+  }
+  return reply;
+}
+export {
+  createValkeyGlideDialCacheClient
+};