@milkio/redis 1.0.0-beta.83 → 1.0.0-beta.86

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"]>> | undefined>;
+        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

@@ -8,8 +8,8 @@ async function createRedis(options) {
   const NodeRedis = await import("./chunk-c39qv53g.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, JSON.stringify(value));
         return value;
@@ -17,14 +17,14 @@ async function createRedis(options) {
       get: async () => {
         const result = await redis.GET(key);
         if (result === null)
-          return defaultValue;
+          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 options2?.defaultValue;
         return reviveJSONParse(JSON.parse(result));
       },
       has: async () => {
@@ -35,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);
@@ -49,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 = reviveJSONParse(JSON.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), JSON.stringify(result));
-      return result.R;
-    },
     useClockIn: (key, cleanDate) => ({
       clockIn: async (offset) => {
         await redis.MULTI().SETBIT(key, offset, 1).PEXPIREAT(key, cleanDate.getTime()).EXEC();
@@ -136,5 +222,5 @@ export {
   createRedis
 };
 
-//# debugId=95724C45208C800264756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["..\\index.ts"],
  "sourcesContent": [
    "import type { RedisClientOptions } from \"redis\";\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, JSON.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 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 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    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 } = reviveJSONParse(JSON.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), JSON.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\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": "95724C45208C800264756E2164756E21",
  "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\"]>> | undefined> => {\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\"]>> | undefined;\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.83","type":"module","module":"./index.js","types":"./index.d.ts","dependencies":{}}
+{"name":"@milkio/redis","version":"1.0.0-beta.86","type":"module","module":"./index.js","types":"./index.d.ts","dependencies":{}}