@devvit/cache 0.12.1-next-2025-10-02-22-58-58-07942952e.0

package/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2023 Reddit Inc.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

package/PromiseCache.d.ts

@@ -0,0 +1,87 @@
+import type { RedisClient } from '@devvit/redis';
+import type { JsonValue } from '@devvit/shared-types/json.js';
+export type CacheEntry = {
+    value: JsonValue | null;
+    expires: number;
+    error: string | null;
+    errorTime: number | null;
+    checkedAt: number;
+    errorCount: number;
+};
+/**
+ * A class that provides a random number between 0 and 1. It is helpful to extract this for testing purposes.
+ */
+export type Randomizer = {
+    random(): number;
+};
+export declare const MathRandomizer: Randomizer;
+/**
+ * A class that provides the current time. It is helpful to extract this for testing purposes.
+ */
+export type Clock = {
+    now(): Date;
+};
+export declare const SystemClock: Clock;
+export type CacheOptions = {
+    /**
+     * Time to live in milliseconds.
+     */
+    ttl: number;
+    /**
+     * Key to use for caching.
+     */
+    key: string;
+};
+export type LocalCache = {
+    [key: string]: CacheEntry;
+};
+export declare function _namespaced(key: string): string;
+export declare function _lock(key: string): string;
+export declare const retryLimit: number;
+export declare const clientRetryDelay: number;
+export declare const allowStaleFor: number;
+/**
+ * This class is responsible for managing the caching of promises. It is a layered cache, meaning it will first check
+ * the local in-memory cache, then the redis cache, and finally the source of truth. It will also handle refreshing the cache according
+ * to the TTL and error handling.
+ *
+ * The local cache is shared across all requests to a given pod, while the redis cache is shared across all requests to all pods.
+ *
+ * Please note that in order to prevent a stampede of requests to the source of truth, we use a lock in redis to ensure only one
+ * request is made to the source of truth at a time. If the lock is obtained, the cache will be updated and the lock will be released.
+ *
+ * Additionally, we use a polling mechanism to fetch the cache if the lock is not obtained. This is to prevent unnecessary errors.
+ *
+ * Finally, we also want to prevent stampedes against redis for the lock election and the retries. We use a ramping probability to ease in the
+ * attempts to get the lock, and not every error will trigger a retry.
+ *
+ * This means that the cache will be eventually consistent, but will not be immediately consistent. This is a tradeoff we are willing to make.
+ * Additionally, this means that the TTL is not precise. The cache may be updated a bit more often than the TTL, but it will not be updated less often.
+ *
+ * @example
+ * ```tsx
+ *   import { cache, reddit } from "@devvit/web/server";
+ *   export function fetchSnoovatarUrl(username: string): Promise<string> {
+ *     return await cache(
+ *       async () => {
+ *         const url = await reddit.getSnoovatarUrl(username)
+ *         console.log(`snoovatar URL cache busted for ${username}`)
+ *         if (!url) {
+ *           throw new Error(`Failed to fetch snoovatar URL for user ${username}`);
+ *         }
+ *         return url;
+ *       },
+ *       {
+ *         key: `snoovatar_by_${username}`,
+ *         ttl: 24 * 60 * 60 * 1000 // expire after one day.
+ *       }
+ *     );
+ *   }
+ * ```
+ */
+export declare class PromiseCache {
+    #private;
+    constructor(redis: RedisClient, localCache: LocalCache, clock: Clock, randomizer: Randomizer);
+    cache<T extends JsonValue>(closure: () => Promise<T>, options: CacheOptions): Promise<T>;
+}
+//# sourceMappingURL=PromiseCache.d.ts.map

package/PromiseCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromiseCache.d.ts","sourceRoot":"","sources":["../src/PromiseCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,MAAM,MAAM,UAAU,GAAG;IAEvB,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IAExB,OAAO,EAAE,MAAM,CAAC;IAEhB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAErB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzB,SAAS,EAAE,MAAM,CAAC;IAElB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,IAAI,MAAM,CAAC;CAClB,CAAC;AAGF,eAAO,MAAM,cAAc,EAAE,UAI5B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,IAAI,IAAI,CAAC;CACb,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAIzB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAC;AAEvD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AACD,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAKD,eAAO,MAAM,UAAU,EAAE,MAAU,CAAC;AAEpC,eAAO,MAAM,gBAAgB,EAAE,MAAc,CAAC;AAC9C,eAAO,MAAM,aAAa,EAAE,MAAe,CAAC;AAS5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,YAAY;;gBAMX,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU;IAgBtF,KAAK,CAAC,CAAC,SAAS,SAAS,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC;CA2M/F"}

package/PromiseCache.js

@@ -0,0 +1,263 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PromiseCache_instances, _PromiseCache_redis, _PromiseCache_localCache, _PromiseCache_clock, _PromiseCache_randomizer, _PromiseCache_localCachedAnswer, _PromiseCache_maybeRefreshCache, _PromiseCache_refreshCache, _PromiseCache_pollForCache, _PromiseCache_updateCache, _PromiseCache_calculateRamp, _PromiseCache_redisEntry, _PromiseCache_enforceTTL;
+// Isolate the random() method to avoid passing the Math package around
+export const MathRandomizer = {
+    random() {
+        return Math.random();
+    },
+};
+export const SystemClock = {
+    now() {
+        return new Date();
+    },
+};
+export function _namespaced(key) {
+    return `__devvit_cache_val__${key}`;
+}
+export function _lock(key) {
+    return `__devvit_cache_lock__${key}`;
+}
+const pollEvery = 300; // milliseconds
+const maxPollingTimeout = 1000; // milliseconds
+const minTtlValue = 5000; // milliseconds
+export const retryLimit = 3;
+const errorRetryProbability = 0.1;
+export const clientRetryDelay = 1000; // milliseconds
+export const allowStaleFor = 30000; // milliseconds
+function _unwrap(entry) {
+    if (entry.error) {
+        throw new Error(entry.error);
+    }
+    return entry.value;
+}
+/**
+ * This class is responsible for managing the caching of promises. It is a layered cache, meaning it will first check
+ * the local in-memory cache, then the redis cache, and finally the source of truth. It will also handle refreshing the cache according
+ * to the TTL and error handling.
+ *
+ * The local cache is shared across all requests to a given pod, while the redis cache is shared across all requests to all pods.
+ *
+ * Please note that in order to prevent a stampede of requests to the source of truth, we use a lock in redis to ensure only one
+ * request is made to the source of truth at a time. If the lock is obtained, the cache will be updated and the lock will be released.
+ *
+ * Additionally, we use a polling mechanism to fetch the cache if the lock is not obtained. This is to prevent unnecessary errors.
+ *
+ * Finally, we also want to prevent stampedes against redis for the lock election and the retries. We use a ramping probability to ease in the
+ * attempts to get the lock, and not every error will trigger a retry.
+ *
+ * This means that the cache will be eventually consistent, but will not be immediately consistent. This is a tradeoff we are willing to make.
+ * Additionally, this means that the TTL is not precise. The cache may be updated a bit more often than the TTL, but it will not be updated less often.
+ *
+ * @example
+ * ```tsx
+ *   import { cache, reddit } from "@devvit/web/server";
+ *   export function fetchSnoovatarUrl(username: string): Promise<string> {
+ *     return await cache(
+ *       async () => {
+ *         const url = await reddit.getSnoovatarUrl(username)
+ *         console.log(`snoovatar URL cache busted for ${username}`)
+ *         if (!url) {
+ *           throw new Error(`Failed to fetch snoovatar URL for user ${username}`);
+ *         }
+ *         return url;
+ *       },
+ *       {
+ *         key: `snoovatar_by_${username}`,
+ *         ttl: 24 * 60 * 60 * 1000 // expire after one day.
+ *       }
+ *     );
+ *   }
+ * ```
+ */
+export class PromiseCache {
+    constructor(redis, localCache, clock, randomizer) {
+        _PromiseCache_instances.add(this);
+        _PromiseCache_redis.set(this, void 0);
+        _PromiseCache_localCache.set(this, void 0);
+        _PromiseCache_clock.set(this, void 0);
+        _PromiseCache_randomizer.set(this, void 0);
+        __classPrivateFieldSet(this, _PromiseCache_redis, redis, "f");
+        __classPrivateFieldSet(this, _PromiseCache_localCache, localCache, "f");
+        __classPrivateFieldSet(this, _PromiseCache_clock, clock, "f");
+        __classPrivateFieldSet(this, _PromiseCache_randomizer, randomizer, "f");
+    }
+    /*
+     * Main entry point for caching a promise.  This will first check the local cache, then the redis cache, and finally
+     * call the provided closure to get the value.  It will also handle refreshing the cache according to the TTL and error handling.
+     *
+     * When interacting with redis, this method may run:
+     * - GET __autocache__${key} to get the cached value for a given key
+     * - SET __autocache__${key} ${value} to set the cached value for a given key
+     * - SET __lock__${key} '1' and DEL __lock__${key} to acquire and release a lock for a given key
+     */
+    async cache(closure, options) {
+        __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_enforceTTL).call(this, options);
+        const localCachedAnswer = __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_localCachedAnswer).call(this, options.key);
+        if (localCachedAnswer !== undefined) {
+            return localCachedAnswer;
+        }
+        const existing = await __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_redisEntry).call(this, options.key);
+        const entry = await __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_maybeRefreshCache).call(this, options, existing, closure);
+        return _unwrap(entry);
+    }
+}
+_PromiseCache_redis = new WeakMap(), _PromiseCache_localCache = new WeakMap(), _PromiseCache_clock = new WeakMap(), _PromiseCache_randomizer = new WeakMap(), _PromiseCache_instances = new WeakSet(), _PromiseCache_localCachedAnswer = function _PromiseCache_localCachedAnswer(key) {
+    const val = __classPrivateFieldGet(this, _PromiseCache_localCache, "f")[key];
+    if (val) {
+        const now = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime();
+        const hasRetryableError = val?.error &&
+            val?.errorTime &&
+            val.errorCount < retryLimit &&
+            __classPrivateFieldGet(this, _PromiseCache_randomizer, "f").random() < errorRetryProbability &&
+            val.errorTime + clientRetryDelay < now;
+        const expired = val?.expires && val.expires < now && val.checkedAt + clientRetryDelay < now;
+        if (expired || hasRetryableError) {
+            delete __classPrivateFieldGet(this, _PromiseCache_localCache, "f")[key];
+            return undefined;
+        }
+        else {
+            return _unwrap(val);
+        }
+    }
+    return undefined;
+}, _PromiseCache_maybeRefreshCache = 
+/**
+ * If we've bothered to check redis, we're already on the backend.  Let's see if the cache either (1) contains an error, (2)
+ * is expired, (3) is missing, or (4) is about to expire.  If any of these are true, we'll refresh the cache based on heuristics.
+ *
+ * We'll always refresh if missing or expired, but its probabilistic if we'll refresh if about to expire or if we have an error.
+ */
+async function _PromiseCache_maybeRefreshCache(options, entry, closure) {
+    const expires = entry?.expires;
+    const rampProbability = expires ? __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_calculateRamp).call(this, expires) : 1;
+    if (!entry ||
+        (entry?.error &&
+            entry.errorCount < retryLimit &&
+            errorRetryProbability > __classPrivateFieldGet(this, _PromiseCache_randomizer, "f").random()) ||
+        rampProbability > __classPrivateFieldGet(this, _PromiseCache_randomizer, "f").random()) {
+        return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_refreshCache).call(this, options, entry, closure);
+    }
+    else {
+        return entry;
+    }
+}, _PromiseCache_refreshCache = 
+/**
+ * The conditions for refreshing the cache are handled in the calling method, which should be
+ * #maybeRefreshCache.
+ *
+ * If you don't win the lock, you'll poll for the cache.  If you don't get the cache within maxPollingTimeout, you'll throw an error.
+ */
+async function _PromiseCache_refreshCache(options, entry, closure) {
+    const lockKey = _lock(options.key);
+    const now = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime();
+    /**
+     * The write lock should last for a while, but not the full TTL.  Hopefully write attempts settle down after a while.
+     */
+    const lockExpiration = new Date(now + options.ttl / 2);
+    const lockObtained = await __classPrivateFieldGet(this, _PromiseCache_redis, "f").set(lockKey, '1', {
+        expiration: lockExpiration,
+        nx: true,
+    });
+    if (lockObtained) {
+        return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_updateCache).call(this, options.key, entry, closure, options.ttl);
+    }
+    else if (entry) {
+        // This entry is still valid, return it
+        return entry;
+    }
+    else {
+        const start = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now();
+        return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_pollForCache).call(this, start, options.key, options.ttl);
+    }
+}, _PromiseCache_pollForCache = async function _PromiseCache_pollForCache(start, key, ttl) {
+    const pollingTimeout = Math.min(ttl, maxPollingTimeout);
+    const existing = await __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_redisEntry).call(this, key);
+    if (existing) {
+        return existing;
+    }
+    if (__classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime() - start.getTime() >= pollingTimeout) {
+        throw new Error(`Cache request timed out trying to get data at key: ${key}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollEvery));
+    return __classPrivateFieldGet(this, _PromiseCache_instances, "m", _PromiseCache_pollForCache).call(this, start, key, ttl);
+}, _PromiseCache_updateCache = 
+/**
+ * Actually update the cache.  This is the method that will be called if we have the lock.
+ */
+async function _PromiseCache_updateCache(key, entry, closure, ttl) {
+    const expires = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime() + ttl;
+    entry = entry ?? {
+        value: null,
+        expires,
+        errorCount: 0,
+        error: null,
+        errorTime: null,
+        checkedAt: 0,
+    };
+    try {
+        entry.value = await closure();
+        entry.error = null;
+        entry.errorCount = 0;
+        entry.errorTime = null;
+    }
+    catch (err) {
+        entry.value = null;
+        entry.error = err instanceof Error ? err.message : 'unknown error';
+        entry.errorTime = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime();
+        entry.errorCount++;
+    }
+    __classPrivateFieldGet(this, _PromiseCache_localCache, "f")[key] = entry;
+    await __classPrivateFieldGet(this, _PromiseCache_redis, "f").set(_namespaced(key), JSON.stringify(entry), {
+        expiration: new Date(expires + allowStaleFor),
+    });
+    /**
+     * Unlocking will allow retries to happen if there was an error.  Otherwise we don't unlock, because the lock
+     * will expire on its own.
+     */
+    if (entry.error && entry.errorCount < retryLimit) {
+        await __classPrivateFieldGet(this, _PromiseCache_redis, "f").del(_lock(key));
+    }
+    return entry;
+}, _PromiseCache_calculateRamp = function _PromiseCache_calculateRamp(expiry) {
+    const now = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime();
+    const remaining = expiry - now;
+    if (remaining < 0) {
+        return 1;
+    }
+    else if (remaining < 1000) {
+        return 0.1;
+    }
+    else if (remaining < 2000) {
+        return 0.01;
+    }
+    else if (remaining < 3000) {
+        return 0.001;
+    }
+    else {
+        return 0;
+    }
+}, _PromiseCache_redisEntry = async function _PromiseCache_redisEntry(key) {
+    const val = await __classPrivateFieldGet(this, _PromiseCache_redis, "f").get(_namespaced(key));
+    if (val) {
+        const entry = JSON.parse(val);
+        entry.checkedAt = __classPrivateFieldGet(this, _PromiseCache_clock, "f").now().getTime();
+        __classPrivateFieldGet(this, _PromiseCache_localCache, "f")[key] = entry;
+        return entry;
+    }
+    return undefined;
+}, _PromiseCache_enforceTTL = function _PromiseCache_enforceTTL(options) {
+    if (options.ttl < minTtlValue) {
+        console.warn(`Cache TTL cannot be less than ${minTtlValue} milliseconds! Updating ttl value of ${options.ttl} to ${minTtlValue}.`);
+        options.ttl = minTtlValue;
+    }
+};

package/README.md

@@ -0,0 +1,5 @@
+# @devvit/cache
+
+A promise cache helper for caching requests
+
+Sign up for Reddit's Developer Platform [here!](https://developers.reddit.com)

package/cache.d.ts

@@ -0,0 +1,10 @@
+import { type RedisClient } from '@devvit/redis';
+import type { JsonValue } from '@devvit/shared-types/json.js';
+import type { CacheOptions, Clock, LocalCache, Randomizer } from './PromiseCache.js';
+export type CacheHelper = <T extends JsonValue>(fn: () => Promise<T>, options: CacheOptions) => Promise<T>;
+/**
+ * @internal
+ */
+export declare function makeCache(redis: RedisClient, localCache: LocalCache, clock: Clock, randomizer: Randomizer): CacheHelper;
+export declare const cache: CacheHelper;
+//# sourceMappingURL=cache.d.ts.map

package/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGrF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,SAAS,SAAS,EAC5C,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,EAAE,YAAY,KAClB,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhB;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,UAAU,GACrB,WAAW,CAGb;AAED,eAAO,MAAM,KAAK,EAAE,WAA+D,CAAC"}

package/cache.js

@@ -0,0 +1,10 @@
+import { redis } from '@devvit/redis';
+import { MathRandomizer, PromiseCache, SystemClock } from './PromiseCache.js';
+/**
+ * @internal
+ */
+export function makeCache(redis, localCache, clock, randomizer) {
+    const pc = new PromiseCache(redis, localCache, clock, randomizer);
+    return pc.cache.bind(pc);
+}
+export const cache = makeCache(redis, {}, SystemClock, MathRandomizer);

package/cache.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.test.d.ts","sourceRoot":"","sources":["../src/cache.test.ts"],"names":[],"mappings":""}

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cache.js';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/index.js

@@ -0,0 +1 @@
+export * from './cache.js';

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@devvit/cache",
+  "version": "0.12.1-next-2025-10-02-22-58-58-07942952e.0",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "https://developers.reddit.com/"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "browser": "./serverImportInClientCodePanic.js",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "**"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf .turbo coverage dist",
+    "clobber": "yarn clean && rm -rf node_modules",
+    "dev": "tsc -w",
+    "lint": "redlint .",
+    "lint:fix": "yarn lint --fix",
+    "prepublishOnly": "publish-package-json",
+    "test": "yarn test:unit && yarn test:types && yarn lint",
+    "test:types": "tsc --noEmit",
+    "test:unit": "vitest run",
+    "test:unit-with-coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@devvit/redis": "0.12.1-next-2025-10-02-22-58-58-07942952e.0",
+    "@devvit/shared-types": "0.12.1-next-2025-10-02-22-58-58-07942952e.0"
+  },
+  "devDependencies": {
+    "@devvit/repo-tools": "0.12.1-next-2025-10-02-22-58-58-07942952e.0",
+    "@devvit/tsconfig": "0.12.1-next-2025-10-02-22-58-58-07942952e.0",
+    "eslint": "9.11.1",
+    "typescript": "5.8.3",
+    "vitest": "1.6.1"
+  },
+  "gitHead": "f4532ed7df33f9251f1f1418bd7a41c9b92fbb16"
+}

package/serverImportInClientCodePanic.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hey! If you're seeing this, you're probably trying to run server code in the
+ * client context, or you have your server build environment set up incorrectly.
+ * To fix this:
+ * 1) Check that you're not importing server code in your client files. If you
+ *    are, you should import from `@devvit/web/client` instead of
+ *    `@devvit/web/server`. `@devvit/cache` is server only and has no client
+ *    support.
+ * 2) If this is coming from server code, ensure that your client's tsconfig &
+ *    build environment is set up correctly - specifically, make sure you do NOT
+ *    have `compilerOptions.customConditions` set to include `["browser"]` in
+ *    your `tsconfig.json` file. Also, verify that whatever bundler you're using
+ *    (esbuild, vite, etc.) is bundling the client code for a Node environment,
+ *    and not a web browser!
+ */
+export {};
+//# sourceMappingURL=serverImportInClientCodePanic.d.ts.map

package/serverImportInClientCodePanic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverImportInClientCodePanic.d.ts","sourceRoot":"","sources":["../src/serverImportInClientCodePanic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/serverImportInClientCodePanic.js

@@ -0,0 +1,17 @@
+/**
+ * Hey! If you're seeing this, you're probably trying to run server code in the
+ * client context, or you have your server build environment set up incorrectly.
+ * To fix this:
+ * 1) Check that you're not importing server code in your client files. If you
+ *    are, you should import from `@devvit/web/client` instead of
+ *    `@devvit/web/server`. `@devvit/cache` is server only and has no client
+ *    support.
+ * 2) If this is coming from server code, ensure that your client's tsconfig &
+ *    build environment is set up correctly - specifically, make sure you do NOT
+ *    have `compilerOptions.customConditions` set to include `["browser"]` in
+ *    your `tsconfig.json` file. Also, verify that whatever bundler you're using
+ *    (esbuild, vite, etc.) is bundling the client code for a Node environment,
+ *    and not a web browser!
+ */
+console.error("Can't import server code in the client!");
+export {};