@milkio/redis 1.0.0-beta.9 → 1.0.0-beta.90

package/{chunk-6pvqjhjf.js → chunk-6sxyen7j.js}

@@ -20,5 +20,5 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 export { __toESM, __commonJS, __require };
 
-//# debugId=EC252AD077A7708464756E2164756E21
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFsKICBdLAogICJtYXBwaW5ncyI6ICIiLAogICJkZWJ1Z0lkIjogIkVDMjUyQUQwNzdBNzcwODQ2NDc1NkUyMTY0NzU2RTIxIiwKICAibmFtZXMiOiBbXQp9
+//# debugId=21F72A06ECE4C28164756E2164756E21
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFsKICBdLAogICJtYXBwaW5ncyI6ICIiLAogICJkZWJ1Z0lkIjogIjIxRjcyQTA2RUNFNEMyODE2NDc1NkUyMTY0NzU2RTIxIiwKICAibmFtZXMiOiBbXQp9

package/{chunk-c39qv53g.js → chunk-xt8gwvgg.js}

@@ -1,7 +1,7 @@
 import {
   __commonJS,
   __require
-} from "./chunk-6pvqjhjf.js";
+} from "./chunk-6sxyen7j.js";
 
 // packages/milkio-redis/node_modules/@redis/client/dist/lib/commands/APPEND.js
 var require_APPEND = __commonJS((exports) => {

package/index.d.ts

@@ -1,6 +1,19 @@
 import type { RedisClientOptions } from "redis";
+export type MilkioRedisCacheOptions<T> = {
+    defaultValue?: T | undefined;
+    expireMs: number;
+};
+export type MilkioRedisFetchOptions<T> = {
+    defaultValue?: T | undefined;
+    expireMs: number;
+    realExpireMs?: number;
+    lockInterval?: number;
+    refreshLockInterval?: number;
+    notFoundExpireMs?: number;
+    fetch: () => T | undefined | Promise<T | undefined>;
+};
 export declare function createRedis<Options extends RedisClientOptions>(options: Options): Promise<{
-    raw: import("@redis/client").RedisClientType<{
+    redis: import("@redis/client").RedisClientType<{
         graph: {
             CONFIG_GET: typeof import("@redis/graph/dist/commands/CONFIG_GET.js");
             configGet: typeof import("@redis/graph/dist/commands/CONFIG_GET.js");
@@ -290,22 +303,24 @@ export declare function createRedis<Options extends RedisClientOptions>(options:
             reserve: typeof import("@redis/bloom/dist/commands/top-k/RESERVE.js");
         };
     } & import("redis").RedisModules, import("redis").RedisFunctions, import("redis").RedisScripts>;
-    useCache: <T>(key: string, defaultValue?: T | undefined) => {
+    useCache: <T>(key: string, options?: MilkioRedisCacheOptions<T>) => {
         set: (value: T, expireMs: number) => Promise<T>;
-        get: () => Promise<undefined | T>;
+        get: () => Promise<T | undefined>;
         pull: () => Promise<any>;
         has: () => Promise<boolean>;
         del: () => Promise<void>;
     };
+    useFetch: <Options_1 extends MilkioRedisFetchOptions<any>>(key: string, options: Options_1) => {
+        has: () => Promise<boolean>;
+        del: () => Promise<void>;
+        fetch: () => Promise<Awaited<ReturnType<Options_1["fetch"]>>>;
+        refresh: () => Promise<void>;
+    };
     useCount: (key: string) => {
         get: () => Promise<number>;
         add: (amount: number, expireMs?: number) => Promise<number>;
-        sub: (key: string, amount: number) => Promise<number>;
+        sub: (amount: number) => Promise<number>;
     };
-    useResultCache: <Handler extends () => unknown | Promise<unknown>>(key: string, expireMs: number, handler: Handler, options?: {
-        realExpireMs?: number;
-        lockInterval?: number;
-    }) => Promise<Awaited<ReturnType<Handler>>>;
     useClockIn: (key: string, cleanDate: Date) => {
         clockIn: (offset: number) => Promise<void>;
         check: (offset: number) => Promise<boolean>;

package/index.js

@@ -1,137 +1,31 @@
 import {
   __require,
   __toESM
-} from "./chunk-6pvqjhjf.js";
-
-// packages/milkio-redis/node_modules/@southern-aurora/tson/dist/tson.js
-var c = {
-  rules: {
-    stringify: [
-      {
-        match: (t) => typeof t == "bigint",
-        handler: (t) => `t!bigint:${t.toString()}`
-      },
-      {
-        match: (t) => t instanceof Date,
-        handler: (t) => `t!Date:${t.toISOString()}`
-      },
-      {
-        match: (t) => t instanceof URL,
-        handler: (t) => `t!URL:${t.toString()}`
-      },
-      {
-        match: (t) => t instanceof RegExp,
-        handler: (t) => `t!RegExp:${t.toString()}`
-      },
-      {
-        match: (t) => t instanceof Uint8Array,
-        handler: (t) => `t!Uint8Array:${new TextDecoder().decode(t)}`
-      },
-      {
-        match: (t) => t instanceof ArrayBuffer,
-        handler: (t) => `t!ArrayBuffer:${new TextDecoder().decode(t)}`
-      }
-    ],
-    parse: [
-      {
-        match: (t) => t.startsWith("t!bigint:"),
-        handler: (t) => BigInt(t.slice(9))
-      },
-      {
-        match: (t) => t.startsWith("t!Date:"),
-        handler: (t) => new Date(t.slice(7))
-      },
-      {
-        match: (t) => t.startsWith("t!URL:"),
-        handler: (t) => new URL(t.slice(6))
-      },
-      {
-        match: (t) => t.startsWith("t!RegExp:"),
-        handler: (t) => new RegExp(t.slice(9))
-      },
-      {
-        match: (t) => t.startsWith("t!Uint8Array:"),
-        handler: (t) => new TextEncoder().encode(t.slice(13))
-      },
-      {
-        match: (t) => t.startsWith("t!ArrayBuffer:"),
-        handler: (t) => new TextEncoder().encode(t.slice(14)).buffer
-      }
-    ]
-  },
-  stringify(t) {
-    return JSON.stringify(c.encode(t));
-  },
-  parse(t) {
-    return c.decode(JSON.parse(t));
-  },
-  encode(t) {
-    function n(e) {
-      if (!e || typeof e != "object" && typeof e != "bigint")
-        return e;
-      if (e) {
-        if (Array.isArray(e)) {
-          const s = [];
-          for (let i = 0;i < e.length; i++)
-            s[i] = n(e[i]);
-          return s;
-        }
-      } else
-        return e;
-      for (const s of c.rules.stringify)
-        if (s.match(e))
-          return s.handler(e);
-      const r = {};
-      for (var a in e)
-        r[a] = n(e[a]);
-      return r;
-    }
-    return n(t);
-  },
-  decode(t) {
-    function n(e) {
-      if (Array.isArray(e))
-        return e.map(n);
-      if (typeof e == "object" && e !== null) {
-        const r = {};
-        for (const a in e)
-          e.hasOwnProperty(a) && (r[a] = n(e[a]));
-        return r;
-      } else if (typeof e == "string") {
-        for (const r of c.rules.parse)
-          if (r.match(e) === true)
-            return r.handler(e);
-        return e;
-      }
-      return e;
-    }
-    return n(t);
-  }
-};
+} from "./chunk-6sxyen7j.js";
 
 // packages/milkio-redis/index.ts
 async function createRedis(options) {
-  const NodeRedis = await import("./chunk-c39qv53g.js");
+  const NodeRedis = await import("./chunk-xt8gwvgg.js");
   const redis = await NodeRedis.default.createClient(options).connect();
   const milkioRedis = {
-    raw: redis,
-    useCache: (key, defaultValue = undefined) => ({
+    redis,
+    useCache: (key, options2) => ({
       set: async (value, expireMs) => {
-        await redis.PSETEX(key, expireMs, c.stringify(value));
+        await redis.PSETEX(key, expireMs, JSON.stringify(value));
         return value;
       },
       get: async () => {
         const result = await redis.GET(key);
         if (result === null)
-          return defaultValue;
-        return c.parse(result);
+          return options2?.defaultValue;
+        return reviveJSONParse(JSON.parse(result));
       },
       pull: async () => {
         const resultRaw = await redis.MULTI().GET(key).DEL(key).EXEC();
         const result = resultRaw[0];
         if (result === null)
-          return defaultValue;
-        return c.parse(result);
+          return options2?.defaultValue;
+        return reviveJSONParse(JSON.parse(result));
       },
       has: async () => {
         const result = await redis.GET(key);
@@ -141,6 +35,107 @@ async function createRedis(options) {
         await redis.DEL(key);
       }
     }),
+    useFetch: (key, options2) => {
+      if (typeof options2.expireMs !== "number" || options2.expireMs <= 0) {
+        throw new Error("expireMs must be a positive number");
+      }
+      if (options2.lockInterval !== undefined && (typeof options2.lockInterval !== "number" || options2.lockInterval <= 0)) {
+        throw new Error("lockInterval must be a positive number if provided");
+      }
+      if (options2.realExpireMs !== undefined && (typeof options2.realExpireMs !== "number" || options2.realExpireMs <= 0)) {
+        throw new Error("realExpireMs must be a positive number if provided");
+      }
+      if (options2.notFoundExpireMs !== undefined && (typeof options2.notFoundExpireMs !== "number" || options2.notFoundExpireMs <= 0)) {
+        throw new Error("notFoundExpireMs must be a positive number if provided");
+      }
+      if (options2.refreshLockInterval !== undefined) {
+        if (typeof options2.refreshLockInterval !== "number" || options2.refreshLockInterval <= 0) {
+          throw new Error("refreshLockInterval must be a positive number if provided");
+        }
+        const lockInterval = options2.lockInterval ?? 8192;
+        if (options2.refreshLockInterval <= lockInterval) {
+          throw new Error("refreshLockInterval must be greater than lockInterval");
+        }
+      }
+      if (typeof options2.fetch !== "function") {
+        throw new Error("fetch must be a function");
+      }
+      return {
+        has: async () => {
+          const result = await redis.GET(key);
+          return result !== null;
+        },
+        del: async () => {
+          await redis.DEL(key);
+        },
+        fetch: async () => {
+          const lockInterval = options2.lockInterval ?? 8192;
+          const realExpireMs = options2.realExpireMs ?? Math.floor(options2.expireMs * (Math.random() + 0.5)) + 8192;
+          const notFoundExpireMs = options2.notFoundExpireMs ?? Math.min(options2.expireMs, 16384);
+          const resultRaw = await redis.GET(key);
+          const result = resultRaw ? reviveJSONParse(JSON.parse(resultRaw)) : undefined;
+          const now = Date.now();
+          if (result && result.T > now) {
+            return result.R;
+          }
+          const refreshLockKey = `${key}:refresh-lock`;
+          if (await redis.EXISTS(refreshLockKey)) {
+            return result ? result.R : options2?.defaultValue;
+          }
+          const lockKey = `${key}:lock`;
+          const lockSet = await redis.SET(lockKey, "1", { PX: lockInterval, NX: true });
+          const gotLock = lockSet === "OK";
+          if (!gotLock)
+            return result ? result.R : options2.defaultValue;
+          const recheckRaw = await redis.GET(key);
+          const recheck = recheckRaw ? reviveJSONParse(JSON.parse(recheckRaw)) : undefined;
+          if (recheck && recheck.T > now) {
+            return recheck.R;
+          }
+          let data;
+          try {
+            data = await options2.fetch();
+          } catch (error) {
+            await redis.DEL(lockKey);
+            throw error;
+          }
+          const effectiveExpireMs = data !== undefined ? options2.expireMs + realExpireMs : notFoundExpireMs;
+          const cacheValue = {
+            T: now + (data !== undefined ? options2.expireMs : notFoundExpireMs),
+            R: data
+          };
+          const refreshLockExists = await redis.EXISTS(refreshLockKey);
+          if (refreshLockExists) {
+            await redis.DEL(lockKey);
+            return data;
+          }
+          await redis.MULTI().PSETEX(key, effectiveExpireMs, JSON.stringify(cacheValue)).DEL(lockKey).EXEC();
+          return data;
+        },
+        refresh: async () => {
+          const refreshLockKey = `${key}:refresh-lock`;
+          const refreshLockInterval = options2.refreshLockInterval ?? (options2.lockInterval ?? 8192) + 1024;
+          await redis.SET(refreshLockKey, "1", {
+            PX: refreshLockInterval
+          });
+          const now = Date.now();
+          let data;
+          try {
+            data = await options2.fetch();
+          } catch (error) {
+            await redis.DEL(refreshLockKey);
+            throw error;
+          }
+          const realExpireMs = options2.realExpireMs ?? Math.floor(options2.expireMs * (Math.random() + 0.5)) + 8192;
+          const effectiveExpireMs = data !== undefined ? options2.expireMs + realExpireMs : options2.notFoundExpireMs ?? Math.min(options2.expireMs, 16384);
+          const cacheValue = {
+            T: now + (data !== undefined ? options2.expireMs : options2.notFoundExpireMs ?? Math.min(options2.expireMs, 16384)),
+            R: data
+          };
+          await redis.PSETEX(key, effectiveExpireMs, JSON.stringify(cacheValue));
+        }
+      };
+    },
     useCount: (key) => ({
       get: async () => {
         const result = await redis.GET(key);
@@ -155,26 +150,11 @@ async function createRedis(options) {
           return Number(result[0]);
         }
       },
-      sub: async (key2, amount) => {
-        const result = await redis.DECRBY(key2, amount);
+      sub: async (amount) => {
+        const result = await redis.DECRBY(key, amount);
         return result;
       }
     }),
-    useResultCache: async (key, expireMs, handler, options2) => {
-      const resultRaw = await redis.get(key);
-      if (resultRaw) {
-        const result2 = c.parse(resultRaw);
-        if (result2.T > new Date().getTime())
-          return result2.R;
-        const lock = await redis.GET(`${key}:lock`);
-        if (lock === "1")
-          return result2.R;
-        await redis.PSETEX(`${key}:lock`, options2?.lockInterval ?? 6000, "1");
-      }
-      const result = { R: await handler(), T: new Date().getTime() + expireMs };
-      await redis.PSETEX(key, expireMs + (options2?.realExpireMs ?? expireMs + Math.floor(expireMs * Math.random())) + (options2?.lockInterval ?? 6000), c.stringify(result));
-      return result.R;
-    },
     useClockIn: (key, cleanDate) => ({
       clockIn: async (offset) => {
         await redis.MULTI().SETBIT(key, offset, 1).PEXPIREAT(key, cleanDate.getTime()).EXEC();
@@ -216,9 +196,31 @@ async function createRedis(options) {
   };
   return milkioRedis;
 }
+function reviveJSONParse(json) {
+  const isoDatePattern = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)(Z|[+-]\d{2}:?\d{2})?$/;
+  if (json instanceof Date)
+    return json;
+  if (Array.isArray(json)) {
+    return json.map((item) => reviveJSONParse(item));
+  }
+  if (typeof json === "object" && json !== null) {
+    return Object.entries(json).reduce((acc, [key, value]) => {
+      acc[key] = reviveJSONParse(value);
+      return acc;
+    }, {});
+  }
+  if (typeof json === "string") {
+    const match = json.match(isoDatePattern);
+    if (match) {
+      const normalizedDateString = match[2] ? `${match[1]}${match[2].replace(":", "")}` : `${match[1]}Z`;
+      return new Date(normalizedDateString);
+    }
+  }
+  return json;
+}
 export {
   createRedis
 };
 
-//# debugId=06364BA54369166064756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["..\\node_modules\\@southern-aurora\\tson\\dist\\tson.js", "..\\index.ts"],
  "sourcesContent": [
    "const c = {\n  rules: {\n    stringify: [\n      {\n        match: (t) => typeof t == \"bigint\",\n        handler: (t) => `t!bigint:${t.toString()}`\n      },\n      {\n        match: (t) => t instanceof Date,\n        handler: (t) => `t!Date:${t.toISOString()}`\n      },\n      {\n        match: (t) => t instanceof URL,\n        handler: (t) => `t!URL:${t.toString()}`\n      },\n      {\n        match: (t) => t instanceof RegExp,\n        handler: (t) => `t!RegExp:${t.toString()}`\n      },\n      {\n        match: (t) => t instanceof Uint8Array,\n        handler: (t) => `t!Uint8Array:${new TextDecoder().decode(t)}`\n      },\n      {\n        match: (t) => t instanceof ArrayBuffer,\n        handler: (t) => `t!ArrayBuffer:${new TextDecoder().decode(t)}`\n      }\n    ],\n    parse: [\n      {\n        match: (t) => t.startsWith(\"t!bigint:\"),\n        handler: (t) => BigInt(t.slice(9))\n      },\n      {\n        match: (t) => t.startsWith(\"t!Date:\"),\n        handler: (t) => new Date(t.slice(7))\n      },\n      {\n        match: (t) => t.startsWith(\"t!URL:\"),\n        handler: (t) => new URL(t.slice(6))\n      },\n      {\n        match: (t) => t.startsWith(\"t!RegExp:\"),\n        handler: (t) => new RegExp(t.slice(9))\n      },\n      {\n        match: (t) => t.startsWith(\"t!Uint8Array:\"),\n        handler: (t) => new TextEncoder().encode(t.slice(13))\n      },\n      {\n        match: (t) => t.startsWith(\"t!ArrayBuffer:\"),\n        handler: (t) => new TextEncoder().encode(t.slice(14)).buffer\n      }\n    ]\n  },\n  stringify(t) {\n    return JSON.stringify(c.encode(t));\n  },\n  parse(t) {\n    return c.decode(JSON.parse(t));\n  },\n  encode(t) {\n    function n(e) {\n      if (!e || typeof e != \"object\" && typeof e != \"bigint\")\n        return e;\n      if (e) {\n        if (Array.isArray(e)) {\n          const s = [];\n          for (let i = 0; i < e.length; i++)\n            s[i] = n(e[i]);\n          return s;\n        }\n      } else\n        return e;\n      for (const s of c.rules.stringify)\n        if (s.match(e))\n          return s.handler(e);\n      const r = {};\n      for (var a in e)\n        r[a] = n(e[a]);\n      return r;\n    }\n    return n(t);\n  },\n  decode(t) {\n    function n(e) {\n      if (Array.isArray(e))\n        return e.map(n);\n      if (typeof e == \"object\" && e !== null) {\n        const r = {};\n        for (const a in e)\n          e.hasOwnProperty(a) && (r[a] = n(e[a]));\n        return r;\n      } else if (typeof e == \"string\") {\n        for (const r of c.rules.parse)\n          if (r.match(e) === !0)\n            return r.handler(e);\n        return e;\n      }\n      return e;\n    }\n    return n(t);\n  }\n};\nexport {\n  c as TSON\n};\n",
    "import type { RedisClientOptions } from \"redis\";\nimport { TSON } from \"@southern-aurora/tson\";\n\nexport async function createRedis<Options extends RedisClientOptions>(options: Options) {\n  const NodeRedis = await import(\"redis\");\n  const redis = await NodeRedis.default.createClient(options).connect();\n\n  const milkioRedis = {\n    raw: redis,\n    useCache: <T>(key: string, defaultValue: T | undefined = undefined) => ({\n      set: async (value: T, expireMs: number): Promise<T> => {\n        await redis.PSETEX(key, expireMs, TSON.stringify(value));\n        return value;\n      },\n      get: async (): Promise<undefined | T> => {\n        const result = await redis.GET(key);\n        if (result === null) return defaultValue;\n        return TSON.parse(result);\n      },\n      pull: async () => {\n        const resultRaw = await redis.MULTI().GET(key).DEL(key).EXEC();\n        const result = resultRaw[0];\n        if (result === null) return defaultValue;\n        return TSON.parse(result as string);\n      },\n      has: async (): Promise<boolean> => {\n        const result = await redis.GET(key);\n        return result !== null;\n      },\n      del: async () => {\n        await redis.DEL(key);\n      },\n    }),\n    useCount: (key: string) => ({\n      get: async (): Promise<number> => {\n        const result = await redis.GET(key);\n        return result ? Number(result) : 0;\n      },\n      add: async (amount: number, expireMs?: number): Promise<number> => {\n        if (!expireMs) {\n          const result = await redis.INCRBY(key, amount);\n          return result;\n        } else {\n          const result = await redis.MULTI().INCRBY(key, amount).PEXPIRE(key, expireMs).EXEC();\n          return Number(result[0]);\n        }\n      },\n      sub: async (key: string, amount: number): Promise<number> => {\n        const result = await redis.DECRBY(key, amount);\n        return result;\n      },\n    }),\n    useResultCache: async <Handler extends () => unknown | Promise<unknown>>(key: string, expireMs: number, handler: Handler, options?: { realExpireMs?: number; lockInterval?: number }): Promise<Awaited<ReturnType<Handler>>> => {\n      const resultRaw = await redis.get(key);\n      if (resultRaw) {\n        const result: { T: number; R: any } = TSON.parse(resultRaw);\n        if (result.T > new Date().getTime()) return result.R;\n        const lock = await redis.GET(`${key}:lock`);\n        if (lock === \"1\") return result.R;\n        await redis.PSETEX(`${key}:lock`, options?.lockInterval ?? 6000, \"1\");\n      }\n      const result = { R: (await handler()) as Awaited<ReturnType<Handler>>, T: new Date().getTime() + expireMs };\n      await redis.PSETEX(key, expireMs + (options?.realExpireMs ?? expireMs + Math.floor(expireMs * Math.random())) + (options?.lockInterval ?? 6000), TSON.stringify(result));\n\n      return result.R;\n    },\n    useClockIn: (key: string, cleanDate: Date) => ({\n      clockIn: async (offset: number): Promise<void> => {\n        await redis.MULTI().SETBIT(key, offset, 1).PEXPIREAT(key, cleanDate.getTime()).EXEC();\n      },\n      check: async (offset: number): Promise<boolean> => {\n        const result = await redis.GETBIT(key, offset);\n        return result === 1;\n      },\n      firstClockIn: async (): Promise<number> => {\n        const result = await redis.BITPOS(key, 1);\n        return result;\n      },\n      lastClockIn: async (): Promise<number> => {\n        const result = await redis.BITPOS(key, 1, -1);\n        return result;\n      },\n      toArray: async (length: number): Promise<boolean[]> => {\n        const resultRaw = await redis.BITFIELD(key, [\n          {\n            operation: \"GET\",\n            encoding: `u${length}`,\n            offset: \"#0\",\n          },\n        ]);\n        const result = Number.parseInt(`${resultRaw}`).toString(2).split(\"\");\n        const fill = [];\n        for (let i = 0; i < length - result.length; i++) fill.push(\"0\");\n        return [...fill, ...result].map((v) => v === \"1\");\n      },\n      count: async (): Promise<number> => {\n        const result = await redis.BITCOUNT(key);\n        return result;\n      },\n      clean: async (): Promise<void> => {\n        await redis.DEL(key);\n      },\n    }),\n  };\n\n  return milkioRedis;\n}\n\nexport type Redis = Awaited<ReturnType<typeof createRedis>>;\n"
  ],
  "mappings": "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",
  "debugId": "06364BA54369166064756E2164756E21",
  "names": []
}
+//# debugId=6F6F9ACDCC3531F264756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["..\\index.ts"],
  "sourcesContent": [
    "import type { RedisClientOptions } from \"redis\";\n\nexport type MilkioRedisCacheOptions<T> = {\n  defaultValue?: T | undefined;\n  expireMs: number;\n};\n\nexport type MilkioRedisFetchOptions<T> = {\n  defaultValue?: T | undefined;\n  expireMs: number;\n  realExpireMs?: number;\n  lockInterval?: number;\n  refreshLockInterval?: number;\n  notFoundExpireMs?: number;\n  fetch: () => T | undefined | Promise<T | undefined>;\n};\n\nexport async function createRedis<Options extends RedisClientOptions>(options: Options) {\n  const NodeRedis = await import(\"redis\");\n  const redis = await NodeRedis.default.createClient(options).connect();\n\n  const milkioRedis = {\n    redis,\n    useCache: <T>(key: string, options?: MilkioRedisCacheOptions<T>) => ({\n      set: async (value: T, expireMs: number): Promise<T> => {\n        await redis.PSETEX(key, expireMs, JSON.stringify(value));\n        return value;\n      },\n      get: async (): Promise<T | undefined> => {\n        const result = await redis.GET(key);\n        if (result === null) return options?.defaultValue;\n        return reviveJSONParse(JSON.parse(result));\n      },\n      pull: async () => {\n        const resultRaw = await redis.MULTI().GET(key).DEL(key).EXEC();\n        const result = resultRaw[0];\n        if (result === null) return options?.defaultValue;\n        return reviveJSONParse(JSON.parse(result as string));\n      },\n      has: async (): Promise<boolean> => {\n        const result = await redis.GET(key);\n        return result !== null;\n      },\n      del: async () => {\n        await redis.DEL(key);\n      },\n    }),\n\n    useFetch: <Options extends MilkioRedisFetchOptions<any>>(key: string, options: Options) => {\n      if (typeof options.expireMs !== \"number\" || options.expireMs <= 0) {\n        throw new Error(\"expireMs must be a positive number\");\n      }\n\n      if (options.lockInterval !== undefined && (typeof options.lockInterval !== \"number\" || options.lockInterval <= 0)) {\n        throw new Error(\"lockInterval must be a positive number if provided\");\n      }\n\n      if (options.realExpireMs !== undefined && (typeof options.realExpireMs !== \"number\" || options.realExpireMs <= 0)) {\n        throw new Error(\"realExpireMs must be a positive number if provided\");\n      }\n\n      if (options.notFoundExpireMs !== undefined && (typeof options.notFoundExpireMs !== \"number\" || options.notFoundExpireMs <= 0)) {\n        throw new Error(\"notFoundExpireMs must be a positive number if provided\");\n      }\n\n      if (options.refreshLockInterval !== undefined) {\n        if (typeof options.refreshLockInterval !== \"number\" || options.refreshLockInterval <= 0) {\n          throw new Error(\"refreshLockInterval must be a positive number if provided\");\n        }\n\n        const lockInterval = options.lockInterval ?? 8192;\n        if (options.refreshLockInterval <= lockInterval) {\n          throw new Error(\"refreshLockInterval must be greater than lockInterval\");\n        }\n      }\n\n      if (typeof options.fetch !== \"function\") {\n        throw new Error(\"fetch must be a function\");\n      }\n\n      return {\n        has: async (): Promise<boolean> => {\n          const result = await redis.GET(key);\n          return result !== null;\n        },\n        del: async () => {\n          await redis.DEL(key);\n        },\n        fetch: async (): Promise<Awaited<ReturnType<Options[\"fetch\"]>>> => {\n          const lockInterval = options.lockInterval ?? 8192;\n          const realExpireMs = options.realExpireMs ?? Math.floor(options.expireMs * (Math.random() + 0.5)) + 8192;\n\n          const notFoundExpireMs = options.notFoundExpireMs ?? Math.min(options.expireMs, 16384);\n\n          const resultRaw = await redis.GET(key);\n          const result = resultRaw ? (reviveJSONParse(JSON.parse(resultRaw)) as { T: number; R: Awaited<ReturnType<Options[\"fetch\"]>> }) : undefined;\n\n          const now = Date.now();\n          if (result && result.T > now) {\n            return result.R;\n          }\n\n          const refreshLockKey = `${key}:refresh-lock`;\n          if (await redis.EXISTS(refreshLockKey)) {\n            return result ? result.R : options?.defaultValue;\n          }\n\n          const lockKey = `${key}:lock`;\n          const lockSet = await redis.SET(lockKey, \"1\", { PX: lockInterval, NX: true });\n          const gotLock = lockSet === \"OK\";\n\n          if (!gotLock) return result ? result.R : options.defaultValue;\n\n          const recheckRaw = await redis.GET(key);\n          const recheck = recheckRaw ? (reviveJSONParse(JSON.parse(recheckRaw)) as { T: number; R: Awaited<ReturnType<Options[\"fetch\"]>> }) : undefined;\n\n          if (recheck && recheck.T > now) {\n            return recheck.R;\n          }\n\n          let data: Awaited<ReturnType<Options[\"fetch\"]>>;\n          try {\n            data = await options.fetch();\n          } catch (error) {\n            await redis.DEL(lockKey);\n            throw error;\n          }\n\n          const effectiveExpireMs = data !== undefined ? options.expireMs + realExpireMs : notFoundExpireMs;\n\n          const cacheValue = {\n            T: now + (data !== undefined ? options.expireMs : notFoundExpireMs),\n            R: data,\n          };\n\n          const refreshLockExists = await redis.EXISTS(refreshLockKey);\n          if (refreshLockExists) {\n            await redis.DEL(lockKey);\n            return data;\n          }\n\n          await redis.MULTI().PSETEX(key, effectiveExpireMs, JSON.stringify(cacheValue)).DEL(lockKey).EXEC();\n\n          return data;\n        },\n        refresh: async (): Promise<void> => {\n          const refreshLockKey = `${key}:refresh-lock`;\n          const refreshLockInterval = options.refreshLockInterval ?? (options.lockInterval ?? 8192) + 1024;\n\n          await redis.SET(refreshLockKey, \"1\", {\n            PX: refreshLockInterval,\n          });\n\n          const now = Date.now();\n          let data: Awaited<ReturnType<Options[\"fetch\"]>> | undefined;\n          try {\n            data = await options.fetch();\n          } catch (error) {\n            await redis.DEL(refreshLockKey);\n            throw error;\n          }\n\n          const realExpireMs = options.realExpireMs ?? Math.floor(options.expireMs * (Math.random() + 0.5)) + 8192;\n          const effectiveExpireMs = data !== undefined ? options.expireMs + realExpireMs : (options.notFoundExpireMs ?? Math.min(options.expireMs, 16384));\n\n          const cacheValue = {\n            T: now + (data !== undefined ? options.expireMs : (options.notFoundExpireMs ?? Math.min(options.expireMs, 16384))),\n            R: data,\n          };\n\n          await redis.PSETEX(key, effectiveExpireMs, JSON.stringify(cacheValue)); // Do not clean the update lock! Instead, wait for it to expire naturally\n        },\n      };\n    },\n\n    useCount: (key: string) => ({\n      get: async (): Promise<number> => {\n        const result = await redis.GET(key);\n        return result ? Number(result) : 0;\n      },\n      add: async (amount: number, expireMs?: number): Promise<number> => {\n        if (!expireMs) {\n          const result = await redis.INCRBY(key, amount);\n          return result;\n        } else {\n          const result = await redis.MULTI().INCRBY(key, amount).PEXPIRE(key, expireMs).EXEC();\n          return Number(result[0]);\n        }\n      },\n      sub: async (amount: number): Promise<number> => {\n        const result = await redis.DECRBY(key, amount);\n        return result;\n      },\n    }),\n\n    useClockIn: (key: string, cleanDate: Date) => ({\n      clockIn: async (offset: number): Promise<void> => {\n        await redis.MULTI().SETBIT(key, offset, 1).PEXPIREAT(key, cleanDate.getTime()).EXEC();\n      },\n      check: async (offset: number): Promise<boolean> => {\n        const result = await redis.GETBIT(key, offset);\n        return result === 1;\n      },\n      firstClockIn: async (): Promise<number> => {\n        const result = await redis.BITPOS(key, 1);\n        return result;\n      },\n      lastClockIn: async (): Promise<number> => {\n        const result = await redis.BITPOS(key, 1, -1);\n        return result;\n      },\n      toArray: async (length: number): Promise<boolean[]> => {\n        const resultRaw = await redis.BITFIELD(key, [\n          {\n            operation: \"GET\",\n            encoding: `u${length}`,\n            offset: \"#0\",\n          },\n        ]);\n        const result = Number.parseInt(`${resultRaw}`).toString(2).split(\"\");\n        const fill = [];\n        for (let i = 0; i < length - result.length; i++) fill.push(\"0\");\n        return [...fill, ...result].map((v) => v === \"1\");\n      },\n      count: async (): Promise<number> => {\n        const result = await redis.BITCOUNT(key);\n        return result;\n      },\n      clean: async (): Promise<void> => {\n        await redis.DEL(key);\n      },\n    }),\n  };\n\n  return milkioRedis;\n}\n\nfunction reviveJSONParse<T>(json: T): T {\n  const isoDatePattern = /^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?)(Z|[+-]\\d{2}:?\\d{2})?$/;\n\n  if (json instanceof Date) return json;\n  if (Array.isArray(json)) {\n    return json.map((item) => reviveJSONParse(item)) as any;\n  }\n  if (typeof json === \"object\" && json !== null) {\n    return Object.entries(json).reduce((acc, [key, value]) => {\n      acc[key as keyof T] = reviveJSONParse(value);\n      return acc;\n    }, {} as T);\n  }\n  if (typeof json === \"string\") {\n    const match = json.match(isoDatePattern);\n    if (match) {\n      const normalizedDateString = match[2] ? `${match[1]}${match[2].replace(\":\", \"\")}` : `${match[1]}Z`;\n      return new Date(normalizedDateString) as any;\n    }\n  }\n  return json;\n}\n\nexport type Redis = Awaited<ReturnType<typeof createRedis>>;\n"
  ],
  "mappings": "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",
  "debugId": "6F6F9ACDCC3531F264756E2164756E21",
  "names": []
}

package/package.json

@@ -1 +1 @@
-{"name":"@milkio/redis","version":"1.0.0-beta.9","type":"module","module":"./index.js","types":"./index.d.ts","dependencies":{}}
+{"name":"@milkio/redis","version":"1.0.0-beta.90","type":"module","module":"./index.js","types":"./index.d.ts","dependencies":{}}