@ionite/ioredis 0.0.24-beta.20260907.2 → 0.0.24-beta.20260907.3

package/dist/index.js

@@ -1 +1,201 @@
-import{createReactiveRedis as f,createRedisLfvTransport as L,getKeyPrefix as p,getLogger as v,prefixedKey as m,RedisAccessAssignmentStore as g,RedisAccessCatalogStore as y,RedisAccessIndex as d,RedisCustomerStore as k,RedisMagicLinkStore as u,RedisResourceStore as b,RedisSessionStore as o,RedisTenantStore as h,RedisUserStore as t,RedisWorkloadIdentityStore as a,RedisWorkloadTokenStore as l}from"@ionite/redis-core";import{chunkedMget as Z,createEvalshaRunner as _}from"@ionite/redis-core";function J(x){let O=_({eval:(R,S,K)=>x.eval(R,S.length,...S,...K),evalsha:(R,S,K)=>x.evalsha(R,S.length,...S,...K)}),I,W=new Map,B=(R,S)=>{for(let K of W.get(R)??[])K(S)},G=()=>{if(I)return I;return I=x.duplicate(),I.on("message",B),I};return{async get(R){return x.get(R)},async set(R,S){await x.set(R,S)},async setex(R,S,K){await x.setex(R,S,K)},async del(R){await x.del(R)},async ttl(R){return x.ttl(R)},async getdel(R){return x.getdel(R)},async sadd(R,...S){if(S.length>0)await x.sadd(R,...S)},async srem(R,...S){if(S.length>0)await x.srem(R,...S)},async smembers(R){return x.smembers(R)},async mget(R){return Z(R,(S)=>x.mget(...S))},async publish(R,S){await x.publish(R,S)},async subscribeChannel(R,S){let K=W.get(R)??new Set,Y=K.size===0;K.add(S),W.set(R,K);let A=G();if(Y)try{await A.subscribe(R)}catch(D){if(K.delete(S),K.size===0)W.delete(R);if(W.size===0&&I===A)A.removeListener("message",B),A.disconnect(),I=void 0;throw D}let Q=!0;return async()=>{if(!Q)return;Q=!1;let D=W.get(R);if(D?.delete(S),D&&D.size===0)W.delete(R),await A.unsubscribe(R);if(W.size===0&&I===A)A.removeListener("message",B),A.disconnect(),I=void 0}},runScript:O}}import{createReactiveRedis as $,splitIonRedisSecret as j}from"@ionite/redis-core";import T from"ioredis";function X(x){let{redisUrl:O,clientOptions:I}=j(x);return{redisUrl:O,clientOptions:I}}function q(x){let O=X(x);if(O.redisUrl)return O.redisUrl;let I=O.clientOptions.host,W=O.clientOptions.port;if(I)return`${I}:${W??6379}`;return""}async function N(x){await x.connect()}async function P(x){try{await x.quit()}catch{x.disconnect()}}function w(x,O,I={}){return $({source:x,path:O,sourceName:I.sourceName,logger:I.logger,secretOptions:I.secretOptions,subscription:I.subscription,endpointOf:(W)=>q(W.data),async createClient(W){let B=X(W.data),G={...B.clientOptions,lazyConnect:!0},R=B.redisUrl?new T(B.redisUrl,G):new T(G);return R.on("error",(S)=>{I.logger?.warn?.("Reactive ioredis client error",{path:O,sourceName:I.sourceName??"redis",error:S.message})}),await N(R),{adapter:J(R),dispose:async()=>{await P(R)}}}})}export{m as prefixedKey,w as ionRedis,v as getLogger,p as getKeyPrefix,L as createRedisLfvTransport,f as createReactiveRedis,J as createIoredisAdapter,l as RedisWorkloadTokenStore,a as RedisWorkloadIdentityStore,t as RedisUserStore,h as RedisTenantStore,o as RedisSessionStore,b as RedisResourceStore,u as RedisMagicLinkStore,k as RedisCustomerStore,d as RedisAccessIndex,y as RedisAccessCatalogStore,g as RedisAccessAssignmentStore};
+// packages/ioredis/src/index.ts
+import {
+  createReactiveRedis as createReactiveRedis2,
+  createRedisLfvTransport,
+  getKeyPrefix,
+  getLogger,
+  prefixedKey,
+  RedisAccessAssignmentStore,
+  RedisAccessCatalogStore,
+  RedisAccessIndex,
+  RedisCustomerStore,
+  RedisMagicLinkStore,
+  RedisResourceStore,
+  RedisSessionStore,
+  RedisTenantStore,
+  RedisUserStore,
+  RedisWorkloadIdentityStore,
+  RedisWorkloadTokenStore
+} from "@ionite/redis-core";
+
+// packages/ioredis/src/adapter.ts
+import { chunkedMget, createEvalshaRunner } from "@ionite/redis-core";
+function createIoredisAdapter(redis) {
+  const runScript = createEvalshaRunner({
+    eval: (script, keys, args) => redis.eval(script, keys.length, ...keys, ...args),
+    evalsha: (sha, keys, args) => redis.evalsha(sha, keys.length, ...keys, ...args)
+  });
+  let subscriber;
+  const channelListeners = new Map;
+  const onMessage = (channel, message) => {
+    for (const listener of channelListeners.get(channel) ?? [])
+      listener(message);
+  };
+  const getSubscriber = () => {
+    if (subscriber)
+      return subscriber;
+    subscriber = redis.duplicate();
+    subscriber.on("message", onMessage);
+    return subscriber;
+  };
+  return {
+    async get(key) {
+      return redis.get(key);
+    },
+    async set(key, value) {
+      await redis.set(key, value);
+    },
+    async setex(key, seconds, value) {
+      await redis.setex(key, seconds, value);
+    },
+    async del(key) {
+      await redis.del(key);
+    },
+    async ttl(key) {
+      return redis.ttl(key);
+    },
+    async getdel(key) {
+      return redis.getdel(key);
+    },
+    async sadd(key, ...members) {
+      if (members.length > 0)
+        await redis.sadd(key, ...members);
+    },
+    async srem(key, ...members) {
+      if (members.length > 0)
+        await redis.srem(key, ...members);
+    },
+    async smembers(key) {
+      return redis.smembers(key);
+    },
+    async mget(keys) {
+      return chunkedMget(keys, (chunk) => redis.mget(...chunk));
+    },
+    async publish(channel, message) {
+      await redis.publish(channel, message);
+    },
+    async subscribeChannel(channel, listener) {
+      const listeners = channelListeners.get(channel) ?? new Set;
+      const isFirst = listeners.size === 0;
+      listeners.add(listener);
+      channelListeners.set(channel, listeners);
+      const active = getSubscriber();
+      if (isFirst) {
+        try {
+          await active.subscribe(channel);
+        } catch (error) {
+          listeners.delete(listener);
+          if (listeners.size === 0)
+            channelListeners.delete(channel);
+          if (channelListeners.size === 0 && subscriber === active) {
+            active.removeListener("message", onMessage);
+            active.disconnect();
+            subscriber = undefined;
+          }
+          throw error;
+        }
+      }
+      let subscribed = true;
+      return async () => {
+        if (!subscribed)
+          return;
+        subscribed = false;
+        const current = channelListeners.get(channel);
+        current?.delete(listener);
+        if (current && current.size === 0) {
+          channelListeners.delete(channel);
+          await active.unsubscribe(channel);
+        }
+        if (channelListeners.size === 0 && subscriber === active) {
+          active.removeListener("message", onMessage);
+          active.disconnect();
+          subscriber = undefined;
+        }
+      };
+    },
+    runScript
+  };
+}
+// packages/ioredis/src/ion-redis.ts
+import {
+  createReactiveRedis,
+  splitIonRedisSecret
+} from "@ionite/redis-core";
+import Redis from "ioredis";
+function normalizeClientConfig(secret) {
+  const { redisUrl, clientOptions } = splitIonRedisSecret(secret);
+  return {
+    redisUrl,
+    clientOptions
+  };
+}
+function endpointSignature(secret) {
+  const config = normalizeClientConfig(secret);
+  if (config.redisUrl)
+    return config.redisUrl;
+  const host = config.clientOptions.host;
+  const port = config.clientOptions.port;
+  if (host)
+    return `${host}:${port ?? 6379}`;
+  return "";
+}
+async function waitForReady(client) {
+  await client.connect();
+}
+async function closeClient(client) {
+  try {
+    await client.quit();
+  } catch {
+    client.disconnect();
+  }
+}
+function ionRedis(source, path, options = {}) {
+  return createReactiveRedis({
+    source,
+    path,
+    sourceName: options.sourceName,
+    logger: options.logger,
+    secretOptions: options.secretOptions,
+    subscription: options.subscription,
+    endpointOf: (secret) => endpointSignature(secret.data),
+    async createClient(secret) {
+      const config = normalizeClientConfig(secret.data);
+      const clientOptions = { ...config.clientOptions, lazyConnect: true };
+      const client = config.redisUrl ? new Redis(config.redisUrl, clientOptions) : new Redis(clientOptions);
+      client.on("error", (error) => {
+        options.logger?.warn?.("Reactive ioredis client error", {
+          path,
+          sourceName: options.sourceName ?? "redis",
+          error: error.message
+        });
+      });
+      await waitForReady(client);
+      return {
+        adapter: createIoredisAdapter(client),
+        dispose: async () => {
+          await closeClient(client);
+        }
+      };
+    }
+  });
+}
+export {
+  prefixedKey,
+  ionRedis,
+  getLogger,
+  getKeyPrefix,
+  createRedisLfvTransport,
+  createReactiveRedis2 as createReactiveRedis,
+  createIoredisAdapter,
+  RedisWorkloadTokenStore,
+  RedisWorkloadIdentityStore,
+  RedisUserStore,
+  RedisTenantStore,
+  RedisSessionStore,
+  RedisResourceStore,
+  RedisMagicLinkStore,
+  RedisCustomerStore,
+  RedisAccessIndex,
+  RedisAccessCatalogStore,
+  RedisAccessAssignmentStore
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ionite/ioredis",
-  "version": "0.0.24-beta.20260907.2",
+  "version": "0.0.24-beta.20260907.3",
   "description": "ioredis adapter and Redis stores for ionite. Single package: install this and ioredis; import adapter and stores from here.",
   "private": false,
   "author": "ionite",
@@ -24,7 +24,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@ionite/redis-core": "0.0.24-beta.20260907.2"
+    "@ionite/redis-core": "0.0.24-beta.20260907.3"
   },
   "peerDependencies": {
     "ioredis": "*"