dialcache 0.1.1

package/dist/node-redis.cjs

@@ -0,0 +1,329 @@
+"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/node-redis.ts
+var node_redis_exports = {};
+__export(node_redis_exports, {
+  createNodeRedisDialCacheClient: () => createNodeRedisDialCacheClient,
+  dialcacheRedisScripts: () => dialcacheRedisScripts
+});
+module.exports = __toCommonJS(node_redis_exports);
+var import_redis = require("redis");
+
+// 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/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-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/node-redis.ts
+var bufferReplyOptions = (0, import_redis.commandOptions)({ returnBuffers: true });
+var readReply = (reply) => reply;
+var integerReply = (reply) => reply;
+function defineDialCacheScript(config) {
+  return (0, import_redis.defineScript)(config);
+}
+var dialcacheRedisScripts = {
+  dialcacheRead: defineDialCacheScript({
+    SCRIPT: READ_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 1,
+    FIRST_KEY_INDEX: 0,
+    IS_READ_ONLY: true,
+    transformArguments(valueKey) {
+      return [valueKey];
+    },
+    transformReply: readReply
+  }),
+  dialcacheReadTracked: defineDialCacheScript({
+    SCRIPT: READ_TRACKED_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 2,
+    FIRST_KEY_INDEX: 0,
+    // Replica lag must not hide a newly-written invalidation watermark.
+    IS_READ_ONLY: false,
+    transformArguments(valueKey, watermarkKey) {
+      return [valueKey, watermarkKey];
+    },
+    transformReply: readReply
+  }),
+  dialcacheWrite: defineDialCacheScript({
+    SCRIPT: WRITE_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 1,
+    FIRST_KEY_INDEX: 0,
+    IS_READ_ONLY: false,
+    transformArguments(valueKey, cacheTtlMs, encoding, payload) {
+      return [valueKey, String(cacheTtlMs), String(encoding), payload];
+    },
+    transformReply: integerReply
+  }),
+  dialcacheWriteTracked: defineDialCacheScript({
+    SCRIPT: WRITE_TRACKED_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 2,
+    FIRST_KEY_INDEX: 0,
+    IS_READ_ONLY: false,
+    transformArguments(valueKey, watermarkKey, cacheTtlMs, encoding, payload, watermarkTtlFloorMs) {
+      return [valueKey, watermarkKey, String(cacheTtlMs), String(encoding), payload, String(watermarkTtlFloorMs)];
+    },
+    transformReply: integerReply
+  }),
+  dialcacheInvalidate: defineDialCacheScript({
+    SCRIPT: INVALIDATE_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 1,
+    FIRST_KEY_INDEX: 0,
+    IS_READ_ONLY: false,
+    transformArguments(watermarkKey, futureBufferMs, watermarkTtlFloorMs) {
+      return [watermarkKey, String(futureBufferMs), String(watermarkTtlFloorMs)];
+    },
+    transformReply: integerReply
+  })
+};
+function createNodeRedisDialCacheClient(client) {
+  return {
+    async read({ valueKey, watermarkKey }) {
+      const raw = watermarkKey === void 0 ? await client.dialcacheRead(bufferReplyOptions, valueKey) : await client.dialcacheReadTracked(bufferReplyOptions, valueKey, watermarkKey);
+      return raw === null ? null : decodeRedisPayload(raw);
+    },
+    async write(request) {
+      const { valueKey, watermarkKey, cacheTtlMs, value } = request;
+      const encodingByte = redisPayloadEncoding(value);
+      const result = watermarkKey === void 0 ? await client.dialcacheWrite(valueKey, cacheTtlMs, encodingByte, value) : await client.dialcacheWriteTracked(
+        valueKey,
+        watermarkKey,
+        cacheTtlMs,
+        encodingByte,
+        value,
+        request.watermarkTtlFloorMs
+      );
+      return result === 1;
+    },
+    async invalidate({ watermarkKey, futureBufferMs, watermarkTtlFloorMs }) {
+      await client.dialcacheInvalidate(watermarkKey, futureBufferMs, watermarkTtlFloorMs);
+    },
+    async flushAll() {
+      const cluster = clusterCommands(client);
+      if (cluster === null) {
+        if (client.flushAll === void 0) {
+          throw new Error("Node-redis client does not implement flushAll");
+        }
+        await client.flushAll();
+        return;
+      }
+      if (cluster.masters.length === 0) {
+        throw new Error("Node-redis cluster has no connected masters");
+      }
+      await Promise.all(
+        cluster.masters.map(async (master) => {
+          const node = await cluster.nodeClient(master);
+          await node.flushAll();
+        })
+      );
+    }
+  };
+}
+function clusterCommands(client) {
+  if (!("masters" in client) || !("nodeClient" in client) || !Array.isArray(client.masters)) {
+    return null;
+  }
+  return client;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNodeRedisDialCacheClient,
+  dialcacheRedisScripts
+});

package/dist/node-redis.d.cts

@@ -0,0 +1,52 @@
+import { commandOptions } from 'redis';
+import { k as DialCacheRedisClient } from './config-B7bGp-Xj.cjs';
+import 'prom-client';
+
+type BufferReplyOptions = ReturnType<typeof commandOptions<{
+    readonly returnBuffers: true;
+}>>;
+type NodeRedisArgument = string | Buffer;
+interface NodeRedisScript<Args extends Array<unknown>, Reply> {
+    readonly SCRIPT: string;
+    readonly SHA1: string;
+    readonly NUMBER_OF_KEYS: number;
+    readonly FIRST_KEY_INDEX: number;
+    readonly IS_READ_ONLY: boolean;
+    transformArguments(...args: Args): Array<NodeRedisArgument>;
+    transformReply(reply: Reply): Reply;
+}
+type DialCacheNodeRedisScripts = {
+    readonly dialcacheRead: NodeRedisScript<[valueKey: string], string | null>;
+    readonly dialcacheReadTracked: NodeRedisScript<[valueKey: string, watermarkKey: string], string | null>;
+    readonly dialcacheWrite: NodeRedisScript<[
+        valueKey: string,
+        cacheTtlMs: number,
+        encoding: number,
+        payload: string | Buffer
+    ], number>;
+    readonly dialcacheWriteTracked: NodeRedisScript<[
+        valueKey: string,
+        watermarkKey: string,
+        cacheTtlMs: number,
+        encoding: number,
+        payload: string | Buffer,
+        watermarkTtlFloorMs: number
+    ], number>;
+    readonly dialcacheInvalidate: NodeRedisScript<[
+        watermarkKey: string,
+        futureBufferMs: number,
+        watermarkTtlFloorMs: number
+    ], number>;
+};
+declare const dialcacheRedisScripts: DialCacheNodeRedisScripts;
+interface NodeRedisScriptClient {
+    dialcacheRead(options: BufferReplyOptions, valueKey: string): Promise<Buffer | null>;
+    dialcacheReadTracked(options: BufferReplyOptions, valueKey: string, watermarkKey: string): Promise<Buffer | null>;
+    dialcacheWrite(valueKey: string, cacheTtlMs: number, encoding: number, payload: string | Buffer): Promise<number>;
+    dialcacheWriteTracked(valueKey: string, watermarkKey: string, cacheTtlMs: number, encoding: number, payload: string | Buffer, watermarkTtlFloorMs: number): Promise<number>;
+    dialcacheInvalidate(watermarkKey: string, futureBufferMs: number, watermarkTtlFloorMs: number): Promise<number>;
+    flushAll?(): Promise<unknown>;
+}
+declare function createNodeRedisDialCacheClient(client: NodeRedisScriptClient): DialCacheRedisClient;
+
+export { type DialCacheNodeRedisScripts, createNodeRedisDialCacheClient, dialcacheRedisScripts };

package/dist/node-redis.d.ts

@@ -0,0 +1,52 @@
+import { commandOptions } from 'redis';
+import { k as DialCacheRedisClient } from './config-B7bGp-Xj.js';
+import 'prom-client';
+
+type BufferReplyOptions = ReturnType<typeof commandOptions<{
+    readonly returnBuffers: true;
+}>>;
+type NodeRedisArgument = string | Buffer;
+interface NodeRedisScript<Args extends Array<unknown>, Reply> {
+    readonly SCRIPT: string;
+    readonly SHA1: string;
+    readonly NUMBER_OF_KEYS: number;
+    readonly FIRST_KEY_INDEX: number;
+    readonly IS_READ_ONLY: boolean;
+    transformArguments(...args: Args): Array<NodeRedisArgument>;
+    transformReply(reply: Reply): Reply;
+}
+type DialCacheNodeRedisScripts = {
+    readonly dialcacheRead: NodeRedisScript<[valueKey: string], string | null>;
+    readonly dialcacheReadTracked: NodeRedisScript<[valueKey: string, watermarkKey: string], string | null>;
+    readonly dialcacheWrite: NodeRedisScript<[
+        valueKey: string,
+        cacheTtlMs: number,
+        encoding: number,
+        payload: string | Buffer
+    ], number>;
+    readonly dialcacheWriteTracked: NodeRedisScript<[
+        valueKey: string,
+        watermarkKey: string,
+        cacheTtlMs: number,
+        encoding: number,
+        payload: string | Buffer,
+        watermarkTtlFloorMs: number
+    ], number>;
+    readonly dialcacheInvalidate: NodeRedisScript<[
+        watermarkKey: string,
+        futureBufferMs: number,
+        watermarkTtlFloorMs: number
+    ], number>;
+};
+declare const dialcacheRedisScripts: DialCacheNodeRedisScripts;
+interface NodeRedisScriptClient {
+    dialcacheRead(options: BufferReplyOptions, valueKey: string): Promise<Buffer | null>;
+    dialcacheReadTracked(options: BufferReplyOptions, valueKey: string, watermarkKey: string): Promise<Buffer | null>;
+    dialcacheWrite(valueKey: string, cacheTtlMs: number, encoding: number, payload: string | Buffer): Promise<number>;
+    dialcacheWriteTracked(valueKey: string, watermarkKey: string, cacheTtlMs: number, encoding: number, payload: string | Buffer, watermarkTtlFloorMs: number): Promise<number>;
+    dialcacheInvalidate(watermarkKey: string, futureBufferMs: number, watermarkTtlFloorMs: number): Promise<number>;
+    flushAll?(): Promise<unknown>;
+}
+declare function createNodeRedisDialCacheClient(client: NodeRedisScriptClient): DialCacheRedisClient;
+
+export { type DialCacheNodeRedisScripts, createNodeRedisDialCacheClient, dialcacheRedisScripts };

package/dist/node-redis.js

@@ -0,0 +1,127 @@
+import {
+  decodeRedisPayload,
+  redisPayloadEncoding
+} from "./chunk-BF6XTPTS.js";
+import "./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/node-redis.ts
+import { commandOptions, defineScript } from "redis";
+var bufferReplyOptions = commandOptions({ returnBuffers: true });
+var readReply = (reply) => reply;
+var integerReply = (reply) => reply;
+function defineDialCacheScript(config) {
+  return defineScript(config);
+}
+var dialcacheRedisScripts = {
+  dialcacheRead: defineDialCacheScript({
+    SCRIPT: READ_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 1,
+    FIRST_KEY_INDEX: 0,
+    IS_READ_ONLY: true,
+    transformArguments(valueKey) {
+      return [valueKey];
+    },
+    transformReply: readReply
+  }),
+  dialcacheReadTracked: defineDialCacheScript({
+    SCRIPT: READ_TRACKED_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 2,
+    FIRST_KEY_INDEX: 0,
+    // Replica lag must not hide a newly-written invalidation watermark.
+    IS_READ_ONLY: false,
+    transformArguments(valueKey, watermarkKey) {
+      return [valueKey, watermarkKey];
+    },
+    transformReply: readReply
+  }),
+  dialcacheWrite: defineDialCacheScript({
+    SCRIPT: WRITE_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 1,
+    FIRST_KEY_INDEX: 0,
+    IS_READ_ONLY: false,
+    transformArguments(valueKey, cacheTtlMs, encoding, payload) {
+      return [valueKey, String(cacheTtlMs), String(encoding), payload];
+    },
+    transformReply: integerReply
+  }),
+  dialcacheWriteTracked: defineDialCacheScript({
+    SCRIPT: WRITE_TRACKED_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 2,
+    FIRST_KEY_INDEX: 0,
+    IS_READ_ONLY: false,
+    transformArguments(valueKey, watermarkKey, cacheTtlMs, encoding, payload, watermarkTtlFloorMs) {
+      return [valueKey, watermarkKey, String(cacheTtlMs), String(encoding), payload, String(watermarkTtlFloorMs)];
+    },
+    transformReply: integerReply
+  }),
+  dialcacheInvalidate: defineDialCacheScript({
+    SCRIPT: INVALIDATE_CACHE_SCRIPT,
+    NUMBER_OF_KEYS: 1,
+    FIRST_KEY_INDEX: 0,
+    IS_READ_ONLY: false,
+    transformArguments(watermarkKey, futureBufferMs, watermarkTtlFloorMs) {
+      return [watermarkKey, String(futureBufferMs), String(watermarkTtlFloorMs)];
+    },
+    transformReply: integerReply
+  })
+};
+function createNodeRedisDialCacheClient(client) {
+  return {
+    async read({ valueKey, watermarkKey }) {
+      const raw = watermarkKey === void 0 ? await client.dialcacheRead(bufferReplyOptions, valueKey) : await client.dialcacheReadTracked(bufferReplyOptions, valueKey, watermarkKey);
+      return raw === null ? null : decodeRedisPayload(raw);
+    },
+    async write(request) {
+      const { valueKey, watermarkKey, cacheTtlMs, value } = request;
+      const encodingByte = redisPayloadEncoding(value);
+      const result = watermarkKey === void 0 ? await client.dialcacheWrite(valueKey, cacheTtlMs, encodingByte, value) : await client.dialcacheWriteTracked(
+        valueKey,
+        watermarkKey,
+        cacheTtlMs,
+        encodingByte,
+        value,
+        request.watermarkTtlFloorMs
+      );
+      return result === 1;
+    },
+    async invalidate({ watermarkKey, futureBufferMs, watermarkTtlFloorMs }) {
+      await client.dialcacheInvalidate(watermarkKey, futureBufferMs, watermarkTtlFloorMs);
+    },
+    async flushAll() {
+      const cluster = clusterCommands(client);
+      if (cluster === null) {
+        if (client.flushAll === void 0) {
+          throw new Error("Node-redis client does not implement flushAll");
+        }
+        await client.flushAll();
+        return;
+      }
+      if (cluster.masters.length === 0) {
+        throw new Error("Node-redis cluster has no connected masters");
+      }
+      await Promise.all(
+        cluster.masters.map(async (master) => {
+          const node = await cluster.nodeClient(master);
+          await node.flushAll();
+        })
+      );
+    }
+  };
+}
+function clusterCommands(client) {
+  if (!("masters" in client) || !("nodeClient" in client) || !Array.isArray(client.masters)) {
+    return null;
+  }
+  return client;
+}
+export {
+  createNodeRedisDialCacheClient,
+  dialcacheRedisScripts
+};