drizzle-redis 1.0.0 → 1.0.2

package/build/bun/index.cjs

@@ -0,0 +1,283 @@
+let bun = require("bun");
+let drizzle_orm = require("drizzle-orm");
+let drizzle_orm_cache_core = require("drizzle-orm/cache/core");
+let drizzle_orm_entity = require("drizzle-orm/entity");
+
+//#region src/bun/cache.ts
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+	try {
+		var info = gen[key](arg);
+		var value = info.value;
+	} catch (error) {
+		reject(error);
+		return;
+	}
+	if (info.done) {
+		resolve(value);
+	} else {
+		Promise.resolve(value).then(_next, _throw);
+	}
+}
+function _async_to_generator(fn) {
+	return function() {
+		var self = this, args = arguments;
+		return new Promise(function(resolve, reject) {
+			var gen = fn.apply(self, args);
+			function _next(value) {
+				asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+			}
+			function _throw(err) {
+				asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+			}
+			_next(undefined);
+		});
+	};
+}
+function _define_property(obj, key, value) {
+	if (key in obj) {
+		Object.defineProperty(obj, key, {
+			value,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+	} else {
+		obj[key] = value;
+	}
+	return obj;
+}
+/**
+* Lua script to atomically get a cached value by tag.
+* Looks up the composite table name from the tags map, then retrieves the value.
+*/ const getByTagScript = `
+local tagsMapKey = KEYS[1] -- tags map key
+local tag        = ARGV[1] -- tag
+
+local compositeTableName = redis.call('HGET', tagsMapKey, tag)
+if not compositeTableName then
+  return nil
+end
+
+local value = redis.call('HGET', compositeTableName, tag)
+return value
+`;
+/**
+* Lua script to atomically invalidate cache entries on mutation.
+* Handles both tag-based and table-based invalidation.
+*/ const onMutateScript = `
+local tagsMapKey = KEYS[1] -- tags map key
+local tables     = {}      -- initialize tables array
+local tags       = ARGV    -- tags array
+
+for i = 2, #KEYS do
+  tables[#tables + 1] = KEYS[i] -- add all keys except the first one to tables
+end
+
+if #tags > 0 then
+  for _, tag in ipairs(tags) do
+    if tag ~= nil and tag ~= '' then
+      local compositeTableName = redis.call('HGET', tagsMapKey, tag)
+      if compositeTableName then
+        redis.call('HDEL', compositeTableName, tag)
+      end
+    end
+  end
+  redis.call('HDEL', tagsMapKey, unpack(tags))
+end
+
+local keysToDelete = {}
+
+if #tables > 0 then
+  local compositeTableNames = redis.call('SUNION', unpack(tables))
+  for _, compositeTableName in ipairs(compositeTableNames) do
+    keysToDelete[#keysToDelete + 1] = compositeTableName
+  end
+  for _, table in ipairs(tables) do
+    keysToDelete[#keysToDelete + 1] = table
+  end
+  redis.call('DEL', unpack(keysToDelete))
+end
+`;
+var BunCache = class BunCache extends drizzle_orm_cache_core.Cache {
+	toInternalConfig(config) {
+		var _config_ex;
+		return config ? {
+			seconds: (_config_ex = config.ex) !== null && _config_ex !== void 0 ? _config_ex : 1,
+			hexOptions: config.hexOptions
+		} : { seconds: 1 };
+	}
+	strategy() {
+		return this.useGlobally ? "all" : "explicit";
+	}
+	get(key, tables, isTag, isAutoInvalidate) {
+		return _async_to_generator(function* () {
+			if (!isAutoInvalidate) {
+				const result = yield this.client.hget(this.addPrefix(BunCache.nonAutoInvalidateTablePrefix), key);
+				return result === null ? undefined : JSON.parse(result);
+			}
+			if (isTag) {
+				const result = yield this.client.send("EVAL", [
+					getByTagScript,
+					"1",
+					this.addPrefix(BunCache.tagsMapKey),
+					key
+				]);
+				if (result === null) {
+					return undefined;
+				}
+				return JSON.parse(result);
+			}
+			const compositeKey = this.getCompositeKey(tables);
+			const result = yield this.client.hget(compositeKey, key);
+			return result === null ? undefined : JSON.parse(result);
+		}).call(this);
+	}
+	put(key, response, tables, isTag = false, config) {
+		return _async_to_generator(function* () {
+			var _this_internalConfig;
+			const isAutoInvalidate = tables.length !== 0;
+			const ttlSeconds = config && config.ex ? config.ex : this.internalConfig.seconds;
+			const hexOptions = config && config.hexOptions ? config.hexOptions : (_this_internalConfig = this.internalConfig) === null || _this_internalConfig === void 0 ? void 0 : _this_internalConfig.hexOptions;
+			const serializedResponse = JSON.stringify(response);
+			if (!isAutoInvalidate) {
+				const nonAutoInvalidateKey = this.addPrefix(BunCache.nonAutoInvalidateTablePrefix);
+				const commands = [];
+				if (isTag) {
+					const tagsMapKey = this.addPrefix(BunCache.tagsMapKey);
+					commands.push(this.client.send("HSET", [
+						tagsMapKey,
+						key,
+						nonAutoInvalidateKey
+					]));
+					commands.push(this.hexpire(tagsMapKey, key, ttlSeconds, hexOptions));
+				}
+				commands.push(this.client.send("HSET", [
+					nonAutoInvalidateKey,
+					key,
+					serializedResponse
+				]));
+				commands.push(this.hexpire(nonAutoInvalidateKey, key, ttlSeconds, hexOptions));
+				yield Promise.all(commands);
+				return;
+			}
+			const compositeKey = this.getCompositeKey(tables);
+			const commands = [];
+			commands.push(this.client.send("HSET", [
+				compositeKey,
+				key,
+				serializedResponse
+			]));
+			commands.push(this.hexpire(compositeKey, key, ttlSeconds, hexOptions));
+			if (isTag) {
+				const tagsMapKey = this.addPrefix(BunCache.tagsMapKey);
+				commands.push(this.client.send("HSET", [
+					tagsMapKey,
+					key,
+					compositeKey
+				]));
+				commands.push(this.hexpire(tagsMapKey, key, ttlSeconds, hexOptions));
+			}
+			for (const table of tables) {
+				commands.push(this.client.sadd(this.addTablePrefix(table), compositeKey));
+			}
+			yield Promise.all(commands);
+		}).call(this);
+	}
+	onMutate(params) {
+		return _async_to_generator(function* () {
+			const tags = Array.isArray(params.tags) ? params.tags : params.tags ? [params.tags] : [];
+			const tables = Array.isArray(params.tables) ? params.tables : params.tables ? [params.tables] : [];
+			const tableNames = tables.map((table) => (0, drizzle_orm_entity.is)(table, drizzle_orm.Table) ? (0, drizzle_orm.getTableName)(table) : table);
+			const compositeTableSets = tableNames.map((table) => this.addTablePrefix(table));
+			const tagsMapKey = this.addPrefix(BunCache.tagsMapKey);
+			yield this.client.send("EVAL", [
+				onMutateScript,
+				(1 + compositeTableSets.length).toString(),
+				tagsMapKey,
+				...compositeTableSets,
+				...tags
+			]);
+		}).call(this);
+	}
+	/**
+	* Add the user-defined prefix to a key.
+	*/ addPrefix(key) {
+		return `${this.prefix}:${key}`;
+	}
+	/**
+	* Add the composite table set prefix with user prefix.
+	*/ addTablePrefix(table) {
+		return this.addPrefix(`${BunCache.compositeTableSetPrefix}${table}`);
+	}
+	/**
+	* Generate a composite key from sorted table names.
+	*/ getCompositeKey(tables) {
+		return this.addPrefix(`${BunCache.compositeTablePrefix}${tables.sort().join(",")}`);
+	}
+	/**
+	* Execute HEXPIRE command using send().
+	* HEXPIRE requires Redis 7.4+
+	*/ hexpire(key, field, seconds, hexOptions) {
+		if (hexOptions) {
+			return this.client.send("HEXPIRE", [
+				key,
+				seconds.toString(),
+				hexOptions,
+				"FIELDS",
+				"1",
+				field
+			]);
+		} else {
+			return this.client.send("HEXPIRE", [
+				key,
+				seconds.toString(),
+				"FIELDS",
+				"1",
+				field
+			]);
+		}
+	}
+	constructor(options) {
+		var _options_prefix, _options_global;
+		super(), _define_property(this, "client", void 0), _define_property(this, "prefix", void 0), _define_property(this, "useGlobally", void 0), _define_property(this, "internalConfig", void 0);
+		this.prefix = (_options_prefix = options.prefix) !== null && _options_prefix !== void 0 ? _options_prefix : "drizzle-redis";
+		this.useGlobally = (_options_global = options.global) !== null && _options_global !== void 0 ? _options_global : false;
+		this.internalConfig = this.toInternalConfig(options.config);
+		if ("client" in options) {
+			this.client = options.client;
+		} else {
+			this.client = new bun.RedisClient(options.url);
+		}
+	}
+};
+_define_property(BunCache, drizzle_orm_entity.entityKind, "BunCache");
+/**
+* Prefix for sets which denote the composite table names for each unique table.
+*
+* Example: In the composite table set of "table1", you may find
+* `${compositeTableSetPrefix}table1,table2` and `${compositeTableSetPrefix}table1,table3`
+*/ _define_property(BunCache, "compositeTableSetPrefix", "__CTS__");
+/**
+* Prefix for hashes which map hash or tags to cache values.
+*/ _define_property(BunCache, "compositeTablePrefix", "__CT__");
+/**
+* Key which holds the mapping of tags to composite table names.
+*
+* Using this tagsMapKey, you can find the composite table name for a given tag
+* and get the cache value for that tag.
+*/ _define_property(BunCache, "tagsMapKey", "__tagsMap__");
+/**
+* Queries whose auto invalidation is false aren't stored in their respective
+* composite table hashes because those hashes are deleted when a mutation
+* occurs on related tables.
+*
+* Instead, they are stored in a separate hash with this prefix
+* to prevent them from being deleted when a mutation occurs.
+*/ _define_property(BunCache, "nonAutoInvalidateTablePrefix", "__nonAutoInvalidate__");
+function bunCache(options) {
+	return new BunCache(options);
+}
+
+//#endregion
+exports.bunCache = bunCache;
+//# sourceMappingURL=index.cjs.map

package/build/bun/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["RedisClient","Table","getTableName","Cache","entityKind","is","getByTagScript","onMutateScript","BunCache","toInternalConfig","config","seconds","ex","hexOptions","strategy","useGlobally","get","key","tables","isTag","isAutoInvalidate","result","client","hget","addPrefix","nonAutoInvalidateTablePrefix","undefined","JSON","parse","send","tagsMapKey","compositeKey","getCompositeKey","put","response","length","ttlSeconds","internalConfig","serializedResponse","stringify","nonAutoInvalidateKey","commands","push","hexpire","Promise","all","table","sadd","addTablePrefix","onMutate","params","tags","Array","isArray","tableNames","map","compositeTableSets","toString","prefix","compositeTableSetPrefix","compositeTablePrefix","sort","join","field","options","global","url","bunCache"],"sources":["../../src/bun/cache.ts"],"sourcesContent":["import { RedisClient } from \"bun\";\nimport { Table, getTableName } from \"drizzle-orm\";\nimport type { MutationOption } from \"drizzle-orm/cache/core\";\nimport { Cache } from \"drizzle-orm/cache/core\";\nimport type { CacheConfig } from \"drizzle-orm/cache/core/types\";\nimport { entityKind, is } from \"drizzle-orm/entity\";\nimport type { BunCacheOptions } from \"../types/main\";\n\n/**\n * Lua script to atomically get a cached value by tag.\n * Looks up the composite table name from the tags map, then retrieves the value.\n */\nconst getByTagScript = `\nlocal tagsMapKey = KEYS[1] -- tags map key\nlocal tag        = ARGV[1] -- tag\n\nlocal compositeTableName = redis.call('HGET', tagsMapKey, tag)\nif not compositeTableName then\n  return nil\nend\n\nlocal value = redis.call('HGET', compositeTableName, tag)\nreturn value\n`;\n\n/**\n * Lua script to atomically invalidate cache entries on mutation.\n * Handles both tag-based and table-based invalidation.\n */\nconst onMutateScript = `\nlocal tagsMapKey = KEYS[1] -- tags map key\nlocal tables     = {}      -- initialize tables array\nlocal tags       = ARGV    -- tags array\n\nfor i = 2, #KEYS do\n  tables[#tables + 1] = KEYS[i] -- add all keys except the first one to tables\nend\n\nif #tags > 0 then\n  for _, tag in ipairs(tags) do\n    if tag ~= nil and tag ~= '' then\n      local compositeTableName = redis.call('HGET', tagsMapKey, tag)\n      if compositeTableName then\n        redis.call('HDEL', compositeTableName, tag)\n      end\n    end\n  end\n  redis.call('HDEL', tagsMapKey, unpack(tags))\nend\n\nlocal keysToDelete = {}\n\nif #tables > 0 then\n  local compositeTableNames = redis.call('SUNION', unpack(tables))\n  for _, compositeTableName in ipairs(compositeTableNames) do\n    keysToDelete[#keysToDelete + 1] = compositeTableName\n  end\n  for _, table in ipairs(tables) do\n    keysToDelete[#keysToDelete + 1] = table\n  end\n  redis.call('DEL', unpack(keysToDelete))\nend\n`;\n\ninterface InternalConfig {\n  seconds: number;\n  hexOptions?: \"NX\" | \"nx\" | \"XX\" | \"xx\" | \"GT\" | \"gt\" | \"LT\" | \"lt\";\n}\n\nexport class BunCache extends Cache {\n  static override readonly [entityKind]: string = \"BunCache\";\n\n  private readonly client: RedisClient;\n  private readonly prefix: string;\n  private readonly useGlobally: boolean;\n  private readonly internalConfig: InternalConfig;\n\n  /**\n   * Prefix for sets which denote the composite table names for each unique table.\n   *\n   * Example: In the composite table set of \"table1\", you may find\n   * `${compositeTableSetPrefix}table1,table2` and `${compositeTableSetPrefix}table1,table3`\n   */\n  private static readonly compositeTableSetPrefix = \"__CTS__\";\n\n  /**\n   * Prefix for hashes which map hash or tags to cache values.\n   */\n  private static readonly compositeTablePrefix = \"__CT__\";\n\n  /**\n   * Key which holds the mapping of tags to composite table names.\n   *\n   * Using this tagsMapKey, you can find the composite table name for a given tag\n   * and get the cache value for that tag.\n   */\n  private static readonly tagsMapKey = \"__tagsMap__\";\n\n  /**\n   * Queries whose auto invalidation is false aren't stored in their respective\n   * composite table hashes because those hashes are deleted when a mutation\n   * occurs on related tables.\n   *\n   * Instead, they are stored in a separate hash with this prefix\n   * to prevent them from being deleted when a mutation occurs.\n   */\n  private static readonly nonAutoInvalidateTablePrefix =\n    \"__nonAutoInvalidate__\";\n\n  constructor(options: BunCacheOptions) {\n    super();\n    this.prefix = options.prefix ?? \"drizzle-redis\";\n    this.useGlobally = options.global ?? false;\n    this.internalConfig = this.toInternalConfig(options.config);\n\n    if (\"client\" in options) {\n      this.client = options.client;\n    } else {\n      this.client = new RedisClient(options.url);\n    }\n  }\n\n  private toInternalConfig(config?: CacheConfig): InternalConfig {\n    return config\n      ? {\n          seconds: config.ex ?? 1,\n          hexOptions: config.hexOptions,\n        }\n      : {\n          seconds: 1,\n        };\n  }\n\n  override strategy(): \"explicit\" | \"all\" {\n    return this.useGlobally ? \"all\" : \"explicit\";\n  }\n\n  override async get(\n    key: string,\n    tables: string[],\n    isTag: boolean,\n    isAutoInvalidate?: boolean\n  ): Promise<any[] | undefined> {\n    // Handle non-auto-invalidate queries\n    if (!isAutoInvalidate) {\n      const result = await this.client.hget(\n        this.addPrefix(BunCache.nonAutoInvalidateTablePrefix),\n        key\n      );\n      return result === null ? undefined : JSON.parse(result);\n    }\n\n    // Handle tag-based lookup using Lua script\n    if (isTag) {\n      const result = await this.client.send(\"EVAL\", [\n        getByTagScript,\n        \"1\",\n        this.addPrefix(BunCache.tagsMapKey),\n        key,\n      ]);\n      if (result === null) {\n        return undefined;\n      }\n      return JSON.parse(result as string);\n    }\n\n    // Handle normal table-based lookup\n    const compositeKey = this.getCompositeKey(tables);\n    const result = await this.client.hget(compositeKey, key);\n    return result === null ? undefined : JSON.parse(result);\n  }\n\n  override async put(\n    key: string,\n    response: any,\n    tables: string[],\n    isTag: boolean = false,\n    config?: CacheConfig\n  ): Promise<void> {\n    const isAutoInvalidate = tables.length !== 0;\n    const ttlSeconds =\n      config && config.ex ? config.ex : this.internalConfig.seconds;\n    const hexOptions =\n      config && config.hexOptions\n        ? config.hexOptions\n        : this.internalConfig?.hexOptions;\n\n    const serializedResponse = JSON.stringify(response);\n\n    // Handle non-auto-invalidate queries\n    if (!isAutoInvalidate) {\n      const nonAutoInvalidateKey = this.addPrefix(\n        BunCache.nonAutoInvalidateTablePrefix\n      );\n\n      const commands: Promise<any>[] = [];\n\n      if (isTag) {\n        const tagsMapKey = this.addPrefix(BunCache.tagsMapKey);\n        commands.push(\n          this.client.send(\"HSET\", [tagsMapKey, key, nonAutoInvalidateKey])\n        );\n        commands.push(this.hexpire(tagsMapKey, key, ttlSeconds, hexOptions));\n      }\n\n      commands.push(\n        this.client.send(\"HSET\", [\n          nonAutoInvalidateKey,\n          key,\n          serializedResponse,\n        ])\n      );\n      commands.push(\n        this.hexpire(nonAutoInvalidateKey, key, ttlSeconds, hexOptions)\n      );\n\n      await Promise.all(commands);\n      return;\n    }\n\n    // Handle auto-invalidate queries\n    const compositeKey = this.getCompositeKey(tables);\n    const commands: Promise<any>[] = [];\n\n    commands.push(\n      this.client.send(\"HSET\", [compositeKey, key, serializedResponse])\n    );\n    commands.push(this.hexpire(compositeKey, key, ttlSeconds, hexOptions));\n\n    if (isTag) {\n      const tagsMapKey = this.addPrefix(BunCache.tagsMapKey);\n      commands.push(this.client.send(\"HSET\", [tagsMapKey, key, compositeKey]));\n      commands.push(this.hexpire(tagsMapKey, key, ttlSeconds, hexOptions));\n    }\n\n    // Track composite keys for each table (for invalidation)\n    for (const table of tables) {\n      commands.push(this.client.sadd(this.addTablePrefix(table), compositeKey));\n    }\n\n    await Promise.all(commands);\n  }\n\n  override async onMutate(params: MutationOption): Promise<void> {\n    const tags = Array.isArray(params.tags)\n      ? params.tags\n      : params.tags\n      ? [params.tags]\n      : [];\n\n    const tables = Array.isArray(params.tables)\n      ? params.tables\n      : params.tables\n      ? [params.tables]\n      : [];\n\n    // Extract table names, handling Table objects via is() + getTableName\n    const tableNames = tables.map((table) =>\n      is(table, Table) ? getTableName(table) : (table as string)\n    );\n\n    const compositeTableSets = tableNames.map((table) =>\n      this.addTablePrefix(table)\n    );\n\n    const tagsMapKey = this.addPrefix(BunCache.tagsMapKey);\n\n    // Execute the Lua script for atomic invalidation\n    await this.client.send(\"EVAL\", [\n      onMutateScript,\n      (1 + compositeTableSets.length).toString(),\n      tagsMapKey,\n      ...compositeTableSets,\n      ...tags,\n    ]);\n  }\n\n  /**\n   * Add the user-defined prefix to a key.\n   */\n  private addPrefix(key: string): string {\n    return `${this.prefix}:${key}`;\n  }\n\n  /**\n   * Add the composite table set prefix with user prefix.\n   */\n  private addTablePrefix(table: string): string {\n    return this.addPrefix(`${BunCache.compositeTableSetPrefix}${table}`);\n  }\n\n  /**\n   * Generate a composite key from sorted table names.\n   */\n  private getCompositeKey(tables: string[]): string {\n    return this.addPrefix(\n      `${BunCache.compositeTablePrefix}${tables.sort().join(\",\")}`\n    );\n  }\n\n  /**\n   * Execute HEXPIRE command using send().\n   * HEXPIRE requires Redis 7.4+\n   */\n  private hexpire(\n    key: string,\n    field: string,\n    seconds: number,\n    hexOptions?: \"NX\" | \"nx\" | \"XX\" | \"xx\" | \"GT\" | \"gt\" | \"LT\" | \"lt\"\n  ): Promise<any> {\n    if (hexOptions) {\n      return this.client.send(\"HEXPIRE\", [\n        key,\n        seconds.toString(),\n        hexOptions,\n        \"FIELDS\",\n        \"1\",\n        field,\n      ]);\n    } else {\n      return this.client.send(\"HEXPIRE\", [\n        key,\n        seconds.toString(),\n        \"FIELDS\",\n        \"1\",\n        field,\n      ]);\n    }\n  }\n}\n\nexport function bunCache(options: BunCacheOptions): BunCache {\n  return new BunCache(options);\n}\n"],"mappings":"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"}

package/build/bun/index.d.cts

@@ -0,0 +1,130 @@
+import { Cache, MutationOption } from "drizzle-orm/cache/core";
+import { CacheConfig } from "drizzle-orm/cache/core/types";
+import { entityKind } from "drizzle-orm/entity";
+import { RedisClient } from "bun";
+import { Redis } from "ioredis";
+
+//#region src/types/main.d.ts
+interface RedisCacheWithClient {
+  /**
+   * The Redis client to use for the cache.
+   */
+  client: Redis;
+}
+interface RedisCacheWithConnection {
+  /**
+   * The URL to use to connect to the Redis server.
+   */
+  url: string;
+}
+type RedisCacheOptions = (RedisCacheWithClient | RedisCacheWithConnection) & {
+  /**
+   * The prefix to use for the cache keys. Defaults to "drizzle-redis".
+   * @default "drizzle-redis"
+   */
+  prefix?: string;
+  /**
+   * Default cache configuration (TTL settings).
+   */
+  config?: CacheConfig;
+  /**
+   * Whether to enable global caching for all queries.
+   * When true, all queries will be cached automatically.
+   * When false (default), only queries with explicit .cache() will be cached.
+   * @default false
+   */
+  global?: boolean;
+};
+interface BunCacheWithClient {
+  /**
+   * The Bun RedisClient instance to use for the cache.
+   */
+  client: RedisClient;
+}
+interface BunCacheWithConnection {
+  /**
+   * The URL to use to connect to the Redis server.
+   */
+  url: string;
+}
+type BunCacheOptions = (BunCacheWithClient | BunCacheWithConnection) & {
+  /**
+   * The prefix to use for the cache keys. Defaults to "drizzle-redis".
+   * @default "drizzle-redis"
+   */
+  prefix?: string;
+  /**
+   * Default cache configuration (TTL settings).
+   */
+  config?: CacheConfig;
+  /**
+   * Whether to enable global caching for all queries.
+   * When true, all queries will be cached automatically.
+   * When false (default), only queries with explicit .cache() will be cached.
+   * @default false
+   */
+  global?: boolean;
+};
+//#endregion
+//#region src/bun/cache.d.ts
+declare class BunCache extends Cache {
+  static readonly [entityKind]: string;
+  private readonly client;
+  private readonly prefix;
+  private readonly useGlobally;
+  private readonly internalConfig;
+  /**
+   * Prefix for sets which denote the composite table names for each unique table.
+   *
+   * Example: In the composite table set of "table1", you may find
+   * `${compositeTableSetPrefix}table1,table2` and `${compositeTableSetPrefix}table1,table3`
+   */
+  private static readonly compositeTableSetPrefix;
+  /**
+   * Prefix for hashes which map hash or tags to cache values.
+   */
+  private static readonly compositeTablePrefix;
+  /**
+   * Key which holds the mapping of tags to composite table names.
+   *
+   * Using this tagsMapKey, you can find the composite table name for a given tag
+   * and get the cache value for that tag.
+   */
+  private static readonly tagsMapKey;
+  /**
+   * Queries whose auto invalidation is false aren't stored in their respective
+   * composite table hashes because those hashes are deleted when a mutation
+   * occurs on related tables.
+   *
+   * Instead, they are stored in a separate hash with this prefix
+   * to prevent them from being deleted when a mutation occurs.
+   */
+  private static readonly nonAutoInvalidateTablePrefix;
+  constructor(options: BunCacheOptions);
+  private toInternalConfig;
+  strategy(): "explicit" | "all";
+  get(key: string, tables: string[], isTag: boolean, isAutoInvalidate?: boolean): Promise<any[] | undefined>;
+  put(key: string, response: any, tables: string[], isTag?: boolean, config?: CacheConfig): Promise<void>;
+  onMutate(params: MutationOption): Promise<void>;
+  /**
+   * Add the user-defined prefix to a key.
+   */
+  private addPrefix;
+  /**
+   * Add the composite table set prefix with user prefix.
+   */
+  private addTablePrefix;
+  /**
+   * Generate a composite key from sorted table names.
+   */
+  private getCompositeKey;
+  /**
+   * Execute HEXPIRE command using send().
+   * HEXPIRE requires Redis 7.4+
+   */
+  private hexpire;
+}
+declare function bunCache(options: BunCacheOptions): BunCache;
+//#endregion
+export { type BunCacheOptions, bunCache };
+//# sourceMappingURL=index.d.cts.map

package/build/bun/index.d.mts

@@ -0,0 +1,130 @@
+import { RedisClient } from "bun";
+import { Cache, MutationOption } from "drizzle-orm/cache/core";
+import { entityKind } from "drizzle-orm/entity";
+import { CacheConfig } from "drizzle-orm/cache/core/types";
+import { Redis } from "ioredis";
+
+//#region src/types/main.d.ts
+interface RedisCacheWithClient {
+  /**
+   * The Redis client to use for the cache.
+   */
+  client: Redis;
+}
+interface RedisCacheWithConnection {
+  /**
+   * The URL to use to connect to the Redis server.
+   */
+  url: string;
+}
+type RedisCacheOptions = (RedisCacheWithClient | RedisCacheWithConnection) & {
+  /**
+   * The prefix to use for the cache keys. Defaults to "drizzle-redis".
+   * @default "drizzle-redis"
+   */
+  prefix?: string;
+  /**
+   * Default cache configuration (TTL settings).
+   */
+  config?: CacheConfig;
+  /**
+   * Whether to enable global caching for all queries.
+   * When true, all queries will be cached automatically.
+   * When false (default), only queries with explicit .cache() will be cached.
+   * @default false
+   */
+  global?: boolean;
+};
+interface BunCacheWithClient {
+  /**
+   * The Bun RedisClient instance to use for the cache.
+   */
+  client: RedisClient;
+}
+interface BunCacheWithConnection {
+  /**
+   * The URL to use to connect to the Redis server.
+   */
+  url: string;
+}
+type BunCacheOptions = (BunCacheWithClient | BunCacheWithConnection) & {
+  /**
+   * The prefix to use for the cache keys. Defaults to "drizzle-redis".
+   * @default "drizzle-redis"
+   */
+  prefix?: string;
+  /**
+   * Default cache configuration (TTL settings).
+   */
+  config?: CacheConfig;
+  /**
+   * Whether to enable global caching for all queries.
+   * When true, all queries will be cached automatically.
+   * When false (default), only queries with explicit .cache() will be cached.
+   * @default false
+   */
+  global?: boolean;
+};
+//#endregion
+//#region src/bun/cache.d.ts
+declare class BunCache extends Cache {
+  static readonly [entityKind]: string;
+  private readonly client;
+  private readonly prefix;
+  private readonly useGlobally;
+  private readonly internalConfig;
+  /**
+   * Prefix for sets which denote the composite table names for each unique table.
+   *
+   * Example: In the composite table set of "table1", you may find
+   * `${compositeTableSetPrefix}table1,table2` and `${compositeTableSetPrefix}table1,table3`
+   */
+  private static readonly compositeTableSetPrefix;
+  /**
+   * Prefix for hashes which map hash or tags to cache values.
+   */
+  private static readonly compositeTablePrefix;
+  /**
+   * Key which holds the mapping of tags to composite table names.
+   *
+   * Using this tagsMapKey, you can find the composite table name for a given tag
+   * and get the cache value for that tag.
+   */
+  private static readonly tagsMapKey;
+  /**
+   * Queries whose auto invalidation is false aren't stored in their respective
+   * composite table hashes because those hashes are deleted when a mutation
+   * occurs on related tables.
+   *
+   * Instead, they are stored in a separate hash with this prefix
+   * to prevent them from being deleted when a mutation occurs.
+   */
+  private static readonly nonAutoInvalidateTablePrefix;
+  constructor(options: BunCacheOptions);
+  private toInternalConfig;
+  strategy(): "explicit" | "all";
+  get(key: string, tables: string[], isTag: boolean, isAutoInvalidate?: boolean): Promise<any[] | undefined>;
+  put(key: string, response: any, tables: string[], isTag?: boolean, config?: CacheConfig): Promise<void>;
+  onMutate(params: MutationOption): Promise<void>;
+  /**
+   * Add the user-defined prefix to a key.
+   */
+  private addPrefix;
+  /**
+   * Add the composite table set prefix with user prefix.
+   */
+  private addTablePrefix;
+  /**
+   * Generate a composite key from sorted table names.
+   */
+  private getCompositeKey;
+  /**
+   * Execute HEXPIRE command using send().
+   * HEXPIRE requires Redis 7.4+
+   */
+  private hexpire;
+}
+declare function bunCache(options: BunCacheOptions): BunCache;
+//#endregion
+export { type BunCacheOptions, bunCache };
+//# sourceMappingURL=index.d.mts.map