@prosopo/provider 4.15.13 → 4.15.15

package/dist/cjs/util/usageCounters.cjs

@@ -1,218 +1,227 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("@prosopo/types");
-const INCR_WITH_TTL_LUA = `local count = redis.call('INCR', KEYS[1])
+let _prosopo_types = require("@prosopo/types");
+//#region src/util/usageCounters.ts
+/** Lua: INCR + EXPIRE only on first transition to 1. No TTL refresh. */
+var INCR_WITH_TTL_LUA = `local count = redis.call('INCR', KEYS[1])
 if count == 1 then
   redis.call('EXPIRE', KEYS[1], tonumber(ARGV[1]))
 end
 return count`;
-class UsageCounters {
-  constructor(connection, logger) {
-    this.scriptShaPromise = null;
-    this.connection = connection;
-    this.logger = logger;
-  }
-  async getClient() {
-    if (!this.connection.isReady()) {
-      return null;
-    }
-    try {
-      return await this.connection.getClient();
-    } catch {
-      return null;
-    }
-  }
-  async getScriptSha(client) {
-    if (!this.scriptShaPromise) {
-      this.scriptShaPromise = client.scriptLoad(INCR_WITH_TTL_LUA).then(
-        (sha) => sha,
-        (error) => {
-          this.scriptShaPromise = null;
-          throw error;
-        }
-      );
-    }
-    return this.scriptShaPromise;
-  }
-  /**
-   * Atomically increment a counter. Sets TTL only on the first write within
-   * the window. Returns the post-increment value, or null on Redis failure.
-   */
-  async incr(dappAccount, spec, value) {
-    const client = await this.getClient();
-    if (!client) {
-      return null;
-    }
-    const key = types.encodeCounterKey(dappAccount, spec, value);
-    const ttlSeconds = types.COUNTER_WINDOW_SECONDS[spec.window];
-    try {
-      const sha = await this.getScriptSha(client);
-      const result = await client.evalSha(sha, {
-        keys: [key],
-        arguments: [String(ttlSeconds)]
-      });
-      return Number(result);
-    } catch (error) {
-      this.logger.warn(() => ({
-        msg: "Counter incr failed",
-        err: error,
-        data: { key }
-      }));
-      return null;
-    }
-  }
-  /**
-   * Fire-and-forget increment. Errors are logged but do not propagate.
-   */
-  incrAsync(dappAccount, spec, value) {
-    this.incr(dappAccount, spec, value).catch((error) => {
-      this.logger.error(() => ({
-        msg: "Counter incrAsync rejected",
-        err: error,
-        data: { dappAccount, spec, value }
-      }));
-    });
-  }
-  /**
-   * Fire-and-forget increment of multiple counters in parallel.
-   */
-  incrManyAsync(dappAccount, increments) {
-    for (const { spec, value } of increments) {
-      this.incrAsync(dappAccount, spec, value);
-    }
-  }
-  /**
-   * Delete every counter key matching the given dapp (or all counters when
-   * dappAccount is omitted). Intended for admin manual-testing flows — not
-   * for the hot path. Uses SCAN + DEL in chunks; returns the number of keys
-   * deleted. Returns null on Redis failure.
-   */
-  async clearAll(dappAccount) {
-    const client = await this.getClient();
-    if (!client) {
-      return null;
-    }
-    const pattern = dappAccount ? `cnt:${dappAccount}:*` : "cnt:*";
-    let deleted = 0;
-    try {
-      const batchSize = 500;
-      let batch = [];
-      for await (const key of client.scanIterator({
-        MATCH: pattern,
-        COUNT: 200
-      })) {
-        if (Array.isArray(key)) {
-          for (const k of key) batch.push(k);
-        } else {
-          batch.push(key);
-        }
-        if (batch.length >= batchSize) {
-          deleted += Number(await client.del(batch));
-          batch = [];
-        }
-      }
-      if (batch.length > 0) {
-        deleted += Number(await client.del(batch));
-      }
-      return deleted;
-    } catch (error) {
-      this.logger.warn(() => ({
-        msg: "Counter clearAll failed",
-        err: error,
-        data: { pattern, deleted }
-      }));
-      return null;
-    }
-  }
-  /**
-   * Bulk read counters via MGET. Missing keys map to 0. Returns a record
-   * keyed by encoded counter key. Returns null on Redis failure so callers
-   * can fall back.
-   */
-  async batchGet(dappAccount, reads) {
-    if (reads.length === 0) {
-      return {};
-    }
-    const client = await this.getClient();
-    if (!client) {
-      return null;
-    }
-    const keys = reads.map(
-      (r) => types.encodeCounterKey(dappAccount, r.spec, r.value)
-    );
-    try {
-      const values = await client.mGet(keys);
-      const out = {};
-      for (let i = 0; i < keys.length; i++) {
-        const raw = values[i];
-        const key = keys[i];
-        if (key === void 0) continue;
-        out[key] = raw === null || raw === void 0 ? 0 : Number(raw);
-      }
-      return out;
-    } catch (error) {
-      this.logger.warn(() => ({
-        msg: "Counter batchGet failed",
-        err: error,
-        data: { keyCount: keys.length }
-      }));
-      return null;
-    }
-  }
-}
-const buildAllWindowIncrements = (kind, captchaType, ip, userAccount, peerIp) => {
-  const out = [];
-  for (const window of [
-    "1m",
-    "10m",
-    "1h",
-    "3h",
-    "6h",
-    "24h"
-  ]) {
-    out.push(
-      { spec: { kind, captchaType, dimension: "ip", window }, value: ip },
-      {
-        spec: { kind, captchaType, dimension: "userAccount", window },
-        value: userAccount
-      }
-    );
-    if (peerIp && peerIp !== ip) {
-      out.push({
-        spec: { kind, captchaType, dimension: "peerIp", window },
-        value: peerIp
-      });
-    }
-    if (captchaType !== "any") {
-      out.push(
-        {
-          spec: { kind, captchaType: "any", dimension: "ip", window },
-          value: ip
-        },
-        {
-          spec: {
-            kind,
-            captchaType: "any",
-            dimension: "userAccount",
-            window
-          },
-          value: userAccount
-        }
-      );
-      if (peerIp && peerIp !== ip) {
-        out.push({
-          spec: {
-            kind,
-            captchaType: "any",
-            dimension: "peerIp",
-            window
-          },
-          value: peerIp
-        });
-      }
-    }
-  }
-  return out;
+/**
+* Per-sitekey usage counters backed by Redis. Writes are atomic via a Lua
+* script that only sets TTL on first transition to 1 — subsequent INCRs
+* within the same window do not refresh the TTL.
+*
+* All operations gracefully no-op (or return zeros) when Redis is unavailable
+* so the caller can fall back to baseline behaviour.
+*/
+var UsageCounters = class {
+	constructor(connection, logger) {
+		this.scriptShaPromise = null;
+		this.connection = connection;
+		this.logger = logger;
+	}
+	async getClient() {
+		if (!this.connection.isReady()) return null;
+		try {
+			return await this.connection.getClient();
+		} catch {
+			return null;
+		}
+	}
+	async getScriptSha(client) {
+		if (!this.scriptShaPromise) this.scriptShaPromise = client.scriptLoad(INCR_WITH_TTL_LUA).then((sha) => sha, (error) => {
+			this.scriptShaPromise = null;
+			throw error;
+		});
+		return this.scriptShaPromise;
+	}
+	/**
+	* Atomically increment a counter. Sets TTL only on the first write within
+	* the window. Returns the post-increment value, or null on Redis failure.
+	*/
+	async incr(dappAccount, spec, value) {
+		const client = await this.getClient();
+		if (!client) return null;
+		const key = (0, _prosopo_types.encodeCounterKey)(dappAccount, spec, value);
+		const ttlSeconds = _prosopo_types.COUNTER_WINDOW_SECONDS[spec.window];
+		try {
+			const sha = await this.getScriptSha(client);
+			const result = await client.evalSha(sha, {
+				keys: [key],
+				arguments: [String(ttlSeconds)]
+			});
+			return Number(result);
+		} catch (error) {
+			this.logger.warn(() => ({
+				msg: "Counter incr failed",
+				err: error,
+				data: { key }
+			}));
+			return null;
+		}
+	}
+	/**
+	* Fire-and-forget increment. Errors are logged but do not propagate.
+	*/
+	incrAsync(dappAccount, spec, value) {
+		this.incr(dappAccount, spec, value).catch((error) => {
+			this.logger.error(() => ({
+				msg: "Counter incrAsync rejected",
+				err: error,
+				data: {
+					dappAccount,
+					spec,
+					value
+				}
+			}));
+		});
+	}
+	/**
+	* Fire-and-forget increment of multiple counters in parallel.
+	*/
+	incrManyAsync(dappAccount, increments) {
+		for (const { spec, value } of increments) this.incrAsync(dappAccount, spec, value);
+	}
+	/**
+	* Delete every counter key matching the given dapp (or all counters when
+	* dappAccount is omitted). Intended for admin manual-testing flows — not
+	* for the hot path. Uses SCAN + DEL in chunks; returns the number of keys
+	* deleted. Returns null on Redis failure.
+	*/
+	async clearAll(dappAccount) {
+		const client = await this.getClient();
+		if (!client) return null;
+		const pattern = dappAccount ? `cnt:${dappAccount}:*` : "cnt:*";
+		let deleted = 0;
+		try {
+			const batchSize = 500;
+			let batch = [];
+			for await (const key of client.scanIterator({
+				MATCH: pattern,
+				COUNT: 200
+			})) {
+				if (Array.isArray(key)) for (const k of key) batch.push(k);
+				else batch.push(key);
+				if (batch.length >= batchSize) {
+					deleted += Number(await client.del(batch));
+					batch = [];
+				}
+			}
+			if (batch.length > 0) deleted += Number(await client.del(batch));
+			return deleted;
+		} catch (error) {
+			this.logger.warn(() => ({
+				msg: "Counter clearAll failed",
+				err: error,
+				data: {
+					pattern,
+					deleted
+				}
+			}));
+			return null;
+		}
+	}
+	/**
+	* Bulk read counters via MGET. Missing keys map to 0. Returns a record
+	* keyed by encoded counter key. Returns null on Redis failure so callers
+	* can fall back.
+	*/
+	async batchGet(dappAccount, reads) {
+		if (reads.length === 0) return {};
+		const client = await this.getClient();
+		if (!client) return null;
+		const keys = reads.map((r) => (0, _prosopo_types.encodeCounterKey)(dappAccount, r.spec, r.value));
+		try {
+			const values = await client.mGet(keys);
+			const out = {};
+			for (let i = 0; i < keys.length; i++) {
+				const raw = values[i];
+				const key = keys[i];
+				if (key === void 0) continue;
+				out[key] = raw === null || raw === void 0 ? 0 : Number(raw);
+			}
+			return out;
+		} catch (error) {
+			this.logger.warn(() => ({
+				msg: "Counter batchGet failed",
+				err: error,
+				data: { keyCount: keys.length }
+			}));
+			return null;
+		}
+	}
 };
+/**
+* Helper: produce the standard 24-counter served/solved write set for a given
+* captcha challenge. Used by both served (post-session) and solved hooks.
+*/
+var buildAllWindowIncrements = (kind, captchaType, ip, userAccount, peerIp) => {
+	const out = [];
+	for (const window of [
+		"1m",
+		"10m",
+		"1h",
+		"3h",
+		"6h",
+		"24h"
+	]) {
+		out.push({
+			spec: {
+				kind,
+				captchaType,
+				dimension: "ip",
+				window
+			},
+			value: ip
+		}, {
+			spec: {
+				kind,
+				captchaType,
+				dimension: "userAccount",
+				window
+			},
+			value: userAccount
+		});
+		if (peerIp && peerIp !== ip) out.push({
+			spec: {
+				kind,
+				captchaType,
+				dimension: "peerIp",
+				window
+			},
+			value: peerIp
+		});
+		if (captchaType !== "any") {
+			out.push({
+				spec: {
+					kind,
+					captchaType: "any",
+					dimension: "ip",
+					window
+				},
+				value: ip
+			}, {
+				spec: {
+					kind,
+					captchaType: "any",
+					dimension: "userAccount",
+					window
+				},
+				value: userAccount
+			});
+			if (peerIp && peerIp !== ip) out.push({
+				spec: {
+					kind,
+					captchaType: "any",
+					dimension: "peerIp",
+					window
+				},
+				value: peerIp
+			});
+		}
+	}
+	return out;
+};
+//#endregion
 exports.UsageCounters = UsageCounters;
 exports.buildAllWindowIncrements = buildAllWindowIncrements;