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

package/dist/index.js

@@ -1 +1,248 @@
-import{createReactiveRedis as u,createRedisLfvTransport as b,getKeyPrefix as o,getLogger as h,prefixedKey as a,RedisAccessAssignmentStore as r,RedisAccessCatalogStore as l,RedisAccessIndex as i,RedisCustomerStore as t,RedisMagicLinkStore as c,RedisResourceStore as s,RedisSessionStore as n,RedisTenantStore as e,RedisUserStore as RR,RedisWorkloadIdentityStore as SR,RedisWorkloadTokenStore as fR}from"@ionite/redis-core";import{createClient as IR}from"redis";import{chunkedMget as J,createEvalshaRunner as M}from"@ionite/redis-core";function N(S){let I=M({eval:(R,x,V)=>S.eval(R,{keys:x,arguments:V}),evalsha:(R,x,V)=>S.evalSha(R,{keys:x,arguments:V})}),f,W,T=new Map,q=async()=>{if(f)return f;if(W)return W;return W=(async()=>{let R=S.duplicate?.();if(!R?.subscribe||!R.unsubscribe)throw Error("node-redis adapter requires client.duplicate() with subscribe/unsubscribe for Pub/Sub");return await R.connect?.(),f=R,R})().finally(()=>{W=void 0}),W};return{async get(R){return S.get(R)},async set(R,x){await S.set(R,x)},async setex(R,x,V){await S.setEx(R,x,V)},async del(R){await S.del(R)},async ttl(R){return S.ttl(R)},async getdel(R){return S.getDel(R)},async sadd(R,...x){if(x.length>0)await S.sAdd(R,x)},async srem(R,...x){if(x.length>0)await S.sRem(R,x)},async smembers(R){let x=await S.sMembers(R);return Array.from(x)},async mget(R){return J(R,(x)=>S.mGet(x))},...S.publish?{async publish(R,x){await S.publish?.(R,x)},async subscribeChannel(R,x){let V=await q(),O=T.get(R)??new Set,G=O.size===0;if(O.add(x),T.set(R,O),G)try{await V.subscribe?.(R,(K)=>{for(let H of T.get(R)??[])H(K)})}catch(K){if(O.delete(x),O.size===0)T.delete(R);if(T.size===0&&f===V)f=void 0,await V.disconnect?.();throw K}let B=!0;return async()=>{if(!B)return;B=!1;let K=T.get(R);if(K?.delete(x),K&&K.size===0)T.delete(R),await V.unsubscribe?.(R);if(T.size===0&&f===V)f=void 0,await V.disconnect?.()}}}:{},runScript:I}}var Q=N;import{createReactiveRedis as X,splitIonRedisSecret as Y}from"@ionite/redis-core";import{createClient as Z}from"redis";function D(S){let{redisUrl:I,clientOptions:f}=Y(S);if(I)f.url=I;return f}function _(S){let I=D(S);if(typeof I.url==="string"&&I.url)return I.url;let f=I.socket;if(f?.path)return f.path;if(f?.host)return`${f.host}:${f.port??6379}`;return""}async function $(S){if(typeof S.quit==="function"){await S.quit();return}if(typeof S.disconnect==="function"){await S.disconnect();return}S.destroy?.()}function E(S,I,f={}){return X({source:S,path:I,sourceName:f.sourceName,logger:f.logger,secretOptions:f.secretOptions,subscription:f.subscription,endpointOf:(W)=>_(W.data),async createClient(W){let T=Z(D(W.data));return T.on?.("error",(q)=>{f.logger?.warn?.("Reactive node-redis client error",{path:I,sourceName:f.sourceName??"redis",error:q.message})}),await T.connect(),{adapter:N(T),dispose:async()=>{await $(T)}}}})}import{createClient as F}from"redis";var j,A;async function U(){return j??=(async()=>{let S=process.env.REDIS_URL?.trim()||"redis://localhost:3503",I=F({url:S});return await I.connect(),A=I,N(I)})(),j}async function w(){let S=j;j=void 0;let I=A;if(A=void 0,S)await S.catch(()=>{});if(!I)return;try{await I.quit()}catch{I.destroy?.()}}export{a as prefixedKey,E as ionRedis,U as getSharedRedisAdapter,h as getLogger,o as getKeyPrefix,b as createRedisLfvTransport,Q as createRedisAdapterV4,N as createRedisAdapter,u as createReactiveRedis,IR as createClient,w as closeSharedRedisAdapter,fR as RedisWorkloadTokenStore,SR as RedisWorkloadIdentityStore,RR as RedisUserStore,e as RedisTenantStore,n as RedisSessionStore,s as RedisResourceStore,c as RedisMagicLinkStore,t as RedisCustomerStore,i as RedisAccessIndex,l as RedisAccessCatalogStore,r as RedisAccessAssignmentStore};
+// packages/redis/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";
+import { createClient as createClient3 } from "redis";
+
+// packages/redis/src/adapter.ts
+import { chunkedMget, createEvalshaRunner } from "@ionite/redis-core";
+function createRedisAdapter(client) {
+  const runScript = createEvalshaRunner({
+    eval: (script, keys, args) => client.eval(script, { keys, arguments: args }),
+    evalsha: (sha, keys, args) => client.evalSha(sha, { keys, arguments: args })
+  });
+  let subscriber;
+  let subscriberPromise;
+  const channelListeners = new Map;
+  const getSubscriber = async () => {
+    if (subscriber)
+      return subscriber;
+    if (subscriberPromise)
+      return subscriberPromise;
+    subscriberPromise = (async () => {
+      const next = client.duplicate?.();
+      if (!next?.subscribe || !next.unsubscribe) {
+        throw new Error("node-redis adapter requires client.duplicate() with subscribe/unsubscribe for Pub/Sub");
+      }
+      await next.connect?.();
+      subscriber = next;
+      return next;
+    })().finally(() => {
+      subscriberPromise = undefined;
+    });
+    return subscriberPromise;
+  };
+  return {
+    async get(key) {
+      return client.get(key);
+    },
+    async set(key, value) {
+      await client.set(key, value);
+    },
+    async setex(key, seconds, value) {
+      await client.setEx(key, seconds, value);
+    },
+    async del(key) {
+      await client.del(key);
+    },
+    async ttl(key) {
+      return client.ttl(key);
+    },
+    async getdel(key) {
+      return client.getDel(key);
+    },
+    async sadd(key, ...members) {
+      if (members.length > 0)
+        await client.sAdd(key, members);
+    },
+    async srem(key, ...members) {
+      if (members.length > 0)
+        await client.sRem(key, members);
+    },
+    async smembers(key) {
+      const arr = await client.sMembers(key);
+      return Array.from(arr);
+    },
+    async mget(keys) {
+      return chunkedMget(keys, (chunk) => client.mGet(chunk));
+    },
+    ...client.publish ? {
+      async publish(channel, message) {
+        await client.publish?.(channel, message);
+      },
+      async subscribeChannel(channel, listener) {
+        const active = await getSubscriber();
+        const listeners = channelListeners.get(channel) ?? new Set;
+        const isFirst = listeners.size === 0;
+        listeners.add(listener);
+        channelListeners.set(channel, listeners);
+        if (isFirst) {
+          try {
+            await active.subscribe?.(channel, (message) => {
+              for (const current of channelListeners.get(channel) ?? [])
+                current(message);
+            });
+          } catch (error) {
+            listeners.delete(listener);
+            if (listeners.size === 0)
+              channelListeners.delete(channel);
+            if (channelListeners.size === 0 && subscriber === active) {
+              subscriber = undefined;
+              await active.disconnect?.();
+            }
+            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) {
+            subscriber = undefined;
+            await active.disconnect?.();
+          }
+        };
+      }
+    } : {},
+    runScript
+  };
+}
+var createRedisAdapterV4 = createRedisAdapter;
+// packages/redis/src/ion-redis.ts
+import {
+  createReactiveRedis,
+  splitIonRedisSecret
+} from "@ionite/redis-core";
+import { createClient } from "redis";
+function normalizeClientOptions(secret) {
+  const { redisUrl, clientOptions } = splitIonRedisSecret(secret);
+  if (redisUrl) {
+    clientOptions.url = redisUrl;
+  }
+  return clientOptions;
+}
+function endpointSignature(secret) {
+  const options = normalizeClientOptions(secret);
+  if (typeof options.url === "string" && options.url)
+    return options.url;
+  const socket = options.socket;
+  if (socket?.path)
+    return socket.path;
+  if (socket?.host)
+    return `${socket.host}:${socket.port ?? 6379}`;
+  return "";
+}
+async function closeClient(client) {
+  if (typeof client.quit === "function") {
+    await client.quit();
+    return;
+  }
+  if (typeof client.disconnect === "function") {
+    await client.disconnect();
+    return;
+  }
+  client.destroy?.();
+}
+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 client = createClient(normalizeClientOptions(secret.data));
+      client.on?.("error", (error) => {
+        options.logger?.warn?.("Reactive node-redis client error", {
+          path,
+          sourceName: options.sourceName ?? "redis",
+          error: error.message
+        });
+      });
+      await client.connect();
+      return {
+        adapter: createRedisAdapter(client),
+        dispose: async () => {
+          await closeClient(client);
+        }
+      };
+    }
+  });
+}
+// packages/redis/src/shared-adapter.ts
+import { createClient as createClient2 } from "redis";
+var sharedRedisAdapterPromise;
+var sharedClient;
+async function getSharedRedisAdapter() {
+  sharedRedisAdapterPromise ??= (async () => {
+    const url = process.env.REDIS_URL?.trim() || "redis://localhost:3503";
+    const client = createClient2({ url });
+    await client.connect();
+    sharedClient = client;
+    return createRedisAdapter(client);
+  })();
+  return sharedRedisAdapterPromise;
+}
+async function closeSharedRedisAdapter() {
+  const promise = sharedRedisAdapterPromise;
+  sharedRedisAdapterPromise = undefined;
+  const client = sharedClient;
+  sharedClient = undefined;
+  if (promise)
+    await promise.catch(() => {});
+  if (!client)
+    return;
+  try {
+    await client.quit();
+  } catch {
+    client.destroy?.();
+  }
+}
+export {
+  prefixedKey,
+  ionRedis,
+  getSharedRedisAdapter,
+  getLogger,
+  getKeyPrefix,
+  createRedisLfvTransport,
+  createRedisAdapterV4,
+  createRedisAdapter,
+  createReactiveRedis2 as createReactiveRedis,
+  createClient3 as createClient,
+  closeSharedRedisAdapter,
+  RedisWorkloadTokenStore,
+  RedisWorkloadIdentityStore,
+  RedisUserStore,
+  RedisTenantStore,
+  RedisSessionStore,
+  RedisResourceStore,
+  RedisMagicLinkStore,
+  RedisCustomerStore,
+  RedisAccessIndex,
+  RedisAccessCatalogStore,
+  RedisAccessAssignmentStore
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ionite/redis",
-  "version": "0.0.24-beta.20260907.2",
+  "version": "0.0.24-beta.20260907.3",
   "description": "redis (node-redis) adapter and Redis stores for ionite. Includes createRedisAdapter (v6) and createRedisAdapterV4 (v4). Install this; redis is included.",
   "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",
     "redis": "^6.1.0"
   },
   "peerDependencies": {