@prosopo/user-access-policy 3.12.8 → 3.12.10

package/dist/cjs/redis/reader/redisRulesSplitQuery.cjs

@@ -1,80 +1,102 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const rule = require("../../rule.cjs");
-const escapeTagValue = (value) => value.replace(/([,.<>{}\[\]"':;!@#$%^&*()\-+=~|/\\])/g, "\\$1");
-const FIELDS_REQUIRING_ESCAPE = /* @__PURE__ */ new Set([
-  "coords"
-]);
-const NUMERIC_FIELDS = /* @__PURE__ */ new Set(["asn"]);
-const SCALAR_USER_SCOPE_FIELDS = [
-  "userId",
-  "ja4Hash",
-  "headersHash",
-  "userAgentHash",
-  "headHash",
-  "coords",
-  "countryCode",
-  "asn"
+const require_rule = require("../../rule.cjs");
+//#region src/redis/reader/redisRulesSplitQuery.ts
+var escapeTagValue = (value) => value.replace(/([,.<>{}\[\]"':;!@#$%^&*()\-+=~|/\\])/g, "\\$1");
+var FIELDS_REQUIRING_ESCAPE = /* @__PURE__ */ new Set(["coords"]);
+var NUMERIC_FIELDS = /* @__PURE__ */ new Set(["asn"]);
+var SCALAR_USER_SCOPE_FIELDS = [
+	"userId",
+	"ja4Hash",
+	"headersHash",
+	"userAgentHash",
+	"headHash",
+	"coords",
+	"countryCode",
+	"asn"
 ];
-const ALL_USER_SCOPE_FIELDS = [
-  ...SCALAR_USER_SCOPE_FIELDS,
-  "numericIp",
-  "numericIpMaskMin",
-  "numericIpMaskMax"
+var ALL_USER_SCOPE_FIELDS = [
+	...SCALAR_USER_SCOPE_FIELDS,
+	"numericIp",
+	"numericIpMaskMin",
+	"numericIpMaskMax"
 ];
-const GLOBAL_SCOPE_INNER = `@clientId:{${rule.GLOBAL_CLIENT_SCOPE_SENTINEL}} | ismissing(@clientId)`;
-const buildScopeClause = (clientId) => {
-  if (clientId === void 0) {
-    return `( ${GLOBAL_SCOPE_INNER} )`;
-  }
-  return `( @clientId:{${clientId}} | ${GLOBAL_SCOPE_INNER} )`;
+var GLOBAL_SCOPE_INNER = `@clientId:{${require_rule.GLOBAL_CLIENT_SCOPE_SENTINEL}} | ismissing(@clientId)`;
+var buildScopeClause = (clientId) => {
+	if (clientId === void 0) return `( ${GLOBAL_SCOPE_INNER} )`;
+	return `( @clientId:{${clientId}} | ${GLOBAL_SCOPE_INNER} )`;
 };
-const buildFieldClause = (field, value) => {
-  if (value === void 0) {
-    return null;
-  }
-  const stringValue = String(value);
-  if (NUMERIC_FIELDS.has(field)) {
-    return `@${field}:[${stringValue} ${stringValue}]`;
-  }
-  const queryValue = FIELDS_REQUIRING_ESCAPE.has(field) ? escapeTagValue(stringValue) : stringValue;
-  return `@${field}:{${queryValue}}`;
+var buildFieldClause = (field, value) => {
+	if (value === void 0) return null;
+	const stringValue = String(value);
+	if (NUMERIC_FIELDS.has(field)) return `@${field}:[${stringValue} ${stringValue}]`;
+	return `@${field}:{${FIELDS_REQUIRING_ESCAPE.has(field) ? escapeTagValue(stringValue) : stringValue}}`;
 };
-const buildScopedRulesSubQueries = (userScope, clientId, options = {}) => {
-  const typeClause = options.blockOnly ? `@type:{${rule.AccessPolicyType.Block}} ` : "";
-  const scopeClause = buildScopeClause(clientId);
-  const prefix = `${typeClause}${scopeClause}`;
-  const subQueries = [];
-  for (const field of SCALAR_USER_SCOPE_FIELDS) {
-    const clause = buildFieldClause(field, userScope[field]);
-    if (clause === null) {
-      continue;
-    }
-    subQueries.push({
-      kind: `field:${field}`,
-      query: `${prefix} ${clause}`
-    });
-  }
-  const requestIp = userScope.numericIp;
-  if (requestIp !== void 0) {
-    subQueries.push({
-      kind: "ip:exact",
-      query: `${prefix} @numericIp:[${requestIp} ${requestIp}]`
-    });
-    subQueries.push({
-      kind: "ip:mask",
-      query: `${prefix} @numericIpMaskMin:[-inf ${requestIp}] @numericIpMaskMax:[${requestIp} +inf]`
-    });
-  }
-  const noScopeIsmissing = ALL_USER_SCOPE_FIELDS.map(
-    (field) => `ismissing(@${field})`
-  ).join(" ");
-  subQueries.push({
-    kind: "no-user-scope",
-    query: `${prefix} ${noScopeIsmissing}`
-  });
-  return subQueries;
+/**
+* Build the set of FT sub-queries that together cover every rule that
+* could apply to a request.
+*
+* The single-query design this replaces produced one FT.AGGREGATE whose
+* candidate set was the entire scope's rule pool — the APPLY / SORTBY
+* pipeline then walked every rule per request, which degrades sharply
+* once rule populations reach the 10k+ range. The split approach fires
+* one probe per populated request field. Each probe uses the field's
+* own index posting list, so a 17k IP-ban population collapses to 1
+* result (exact IP) plus a handful (CIDR ranges containing the IP)
+* instead of forcing a full-set scan.
+*
+* A single fall-through probe covers rules with no user-scope constraint
+* (client-wide restriction); those are rare so the ismissing()-heavy
+* query is cheap in practice.
+*
+* Rank + strict-match filtering happens in JS via `rankCandidateRules`
+* after the union — the FT layer is used purely as a candidate fetcher.
+*
+* `blockOnly` narrows the candidate set to rules with `type:{block}` —
+* used by the hard-block middleware which never needs Restrict rules.
+* Every other caller passes false so both Block and Restrict rules are
+* fetched; the JS-side ranker picks the right one via specificity +
+* severity. Merging the block and restrict paths behind one split-query
+* fixed the Twickets IP-rule regression: the previous FT.AGGREGATE ranker
+* used for non-block lookups was truncating specific-IP restrict rules
+* out of the top-N when many higher-specificity irrelevant rules matched
+* the greedy `ismissing()` disjunction.
+*/
+var buildScopedRulesSubQueries = (userScope, clientId, options = {}) => {
+	const prefix = `${options.blockOnly ? `@type:{${require_rule.AccessPolicyType.Block}} ` : ""}${buildScopeClause(clientId)}`;
+	const subQueries = [];
+	for (const field of SCALAR_USER_SCOPE_FIELDS) {
+		const clause = buildFieldClause(field, userScope[field]);
+		if (clause === null) continue;
+		subQueries.push({
+			kind: `field:${field}`,
+			query: `${prefix} ${clause}`
+		});
+	}
+	const requestIp = userScope.numericIp;
+	if (requestIp !== void 0) {
+		subQueries.push({
+			kind: "ip:exact",
+			query: `${prefix} @numericIp:[${requestIp} ${requestIp}]`
+		});
+		subQueries.push({
+			kind: "ip:mask",
+			query: `${prefix} @numericIpMaskMin:[-inf ${requestIp}] @numericIpMaskMax:[${requestIp} +inf]`
+		});
+	}
+	const noScopeIsmissing = ALL_USER_SCOPE_FIELDS.map((field) => `ismissing(@${field})`).join(" ");
+	subQueries.push({
+		kind: "no-user-scope",
+		query: `${prefix} ${noScopeIsmissing}`
+	});
+	return subQueries;
 };
-const buildScopedBlockSubQueries = (userScope, clientId) => buildScopedRulesSubQueries(userScope, clientId, { blockOnly: true });
+/**
+* Backwards-compatible alias for the previous block-only builder. New
+* callers should use `buildScopedRulesSubQueries` directly.
+*
+* @deprecated use `buildScopedRulesSubQueries(..., { blockOnly: true })`
+*/
+var buildScopedBlockSubQueries = (userScope, clientId) => buildScopedRulesSubQueries(userScope, clientId, { blockOnly: true });
+//#endregion
 exports.buildScopedBlockSubQueries = buildScopedBlockSubQueries;
 exports.buildScopedRulesSubQueries = buildScopedRulesSubQueries;

package/dist/cjs/redis/redisClient.cjs

@@ -1,66 +1,61 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const zod = require("zod");
-const REDIS_BATCH_SIZE = 1e3;
-const getMissingRedisKeys = async (client, keys) => {
-  const queries = client.multi();
-  keys.map((key) => {
-    queries.exists(key);
-  });
-  const records = await queries.exec();
-  const missingKeys = [];
-  records.map((exists, recordIndex) => {
-    if ("0" === String(exists)) {
-      const key = keys[recordIndex];
-      if (key) {
-        missingKeys.push(key);
-      }
-    }
-  });
-  return missingKeys;
+let zod = require("zod");
+//#region src/redis/redisClient.ts
+var REDIS_BATCH_SIZE = 1e3;
+var getMissingRedisKeys = async (client, keys) => {
+	const queries = client.multi();
+	keys.map((key) => {
+		queries.exists(key);
+	});
+	const records = await queries.exec();
+	const missingKeys = [];
+	records.map((exists, recordIndex) => {
+		if ("0" === String(exists)) {
+			const key = keys[recordIndex];
+			if (key) missingKeys.push(key);
+		}
+	});
+	return missingKeys;
 };
-const fetchRedisHashRecords = async (client, keys, logger) => {
-  const rulesPipe = client.multi();
-  const expirationPipe = client.multi();
-  for (const key of keys) {
-    rulesPipe.hGetAll(key);
-    expirationPipe.expireTime(key);
-  }
-  const records = await rulesPipe.exec();
-  const expirationRecords = await expirationPipe.exec();
-  return {
-    records,
-    expirations: parseExpirationRecords(expirationRecords, logger)
-  };
+var fetchRedisHashRecords = async (client, keys, logger) => {
+	const rulesPipe = client.multi();
+	const expirationPipe = client.multi();
+	for (const key of keys) {
+		rulesPipe.hGetAll(key);
+		expirationPipe.expireTime(key);
+	}
+	return {
+		records: await rulesPipe.exec(),
+		expirations: parseExpirationRecords(await expirationPipe.exec(), logger)
+	};
 };
-const parseRedisRecords = (records, recordSchema, logger) => records.flatMap((record) => {
-  const parseResult = recordSchema.safeParse(record);
-  if (parseResult.success) {
-    return [parseResult.data];
-  }
-  logger.error(() => ({
-    msg: "Failed to parse Redis record",
-    data: { record, error: parseResult.error }
-  }));
-  return [];
+var parseRedisRecords = (records, recordSchema, logger) => records.flatMap((record) => {
+	const parseResult = recordSchema.safeParse(record);
+	if (parseResult.success) return [parseResult.data];
+	logger.error(() => ({
+		msg: "Failed to parse Redis record",
+		data: {
+			record,
+			error: parseResult.error
+		}
+	}));
+	return [];
 });
-const expirationRecordSchema = zod.z.coerce.number();
-const UNSET_EXPIRATION_VALUE = -1;
-const parseExpirationRecords = (records, logger) => records.flatMap((record) => {
-  const parseResult = expirationRecordSchema.safeParse(record);
-  if (parseResult.success) {
-    const expiration = UNSET_EXPIRATION_VALUE === parseResult.data ? void 0 : parseResult.data;
-    return [expiration];
-  }
-  logger.error(() => ({
-    msg: "Failed to parse Redis expiration record",
-    data: {
-      record,
-      error: parseResult.error
-    }
-  }));
-  return [void 0];
+var expirationRecordSchema = zod.z.coerce.number();
+var UNSET_EXPIRATION_VALUE = -1;
+var parseExpirationRecords = (records, logger) => records.flatMap((record) => {
+	const parseResult = expirationRecordSchema.safeParse(record);
+	if (parseResult.success) return [UNSET_EXPIRATION_VALUE === parseResult.data ? void 0 : parseResult.data];
+	logger.error(() => ({
+		msg: "Failed to parse Redis expiration record",
+		data: {
+			record,
+			error: parseResult.error
+		}
+	}));
+	return [void 0];
 });
+//#endregion
 exports.REDIS_BATCH_SIZE = REDIS_BATCH_SIZE;
 exports.fetchRedisHashRecords = fetchRedisHashRecords;
 exports.getMissingRedisKeys = getMissingRedisKeys;

package/dist/cjs/redis/redisRuleIndex.cjs

@@ -1,60 +1,104 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const search = require("@redis/search");
-const transformRule = require("../transformRule.cjs");
-const rule = require("../rule.cjs");
-const userIpRedisSchema = {
-  numericIpMaskMin: { type: search.SCHEMA_FIELD_TYPE.NUMERIC, INDEXMISSING: true },
-  numericIpMaskMax: { type: search.SCHEMA_FIELD_TYPE.NUMERIC, INDEXMISSING: true },
-  numericIp: { type: search.SCHEMA_FIELD_TYPE.NUMERIC, INDEXMISSING: true }
+const require_rule = require("../rule.cjs");
+const require_transformRule = require("../transformRule.cjs");
+let _redis_search = require("@redis/search");
+//#region src/redis/redisRuleIndex.ts
+var userIpRedisSchema = {
+	numericIpMaskMin: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.NUMERIC,
+		INDEXMISSING: true
+	},
+	numericIpMaskMax: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.NUMERIC,
+		INDEXMISSING: true
+	},
+	numericIp: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.NUMERIC,
+		INDEXMISSING: true
+	}
 };
-const userAttributesRedisSchema = {
-  userId: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true },
-  ja4Hash: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true },
-  headersHash: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true },
-  userAgentHash: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true },
-  headHash: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true },
-  // Use pipe separator for coords since JSON strings contain commas
-  coords: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true, SEPARATOR: "|" },
-  countryCode: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true },
-  asn: { type: search.SCHEMA_FIELD_TYPE.NUMERIC, INDEXMISSING: true },
-  os: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true }
+var userAttributesRedisSchema = {
+	userId: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true
+	},
+	ja4Hash: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true
+	},
+	headersHash: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true
+	},
+	userAgentHash: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true
+	},
+	headHash: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true
+	},
+	coords: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true,
+		SEPARATOR: "|"
+	},
+	countryCode: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true
+	},
+	asn: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.NUMERIC,
+		INDEXMISSING: true
+	},
+	os: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true
+	}
 };
-const userScopeRedisSchema = {
-  ...userAttributesRedisSchema,
-  ...userIpRedisSchema
+var userScopeRedisSchema = {
+	...userAttributesRedisSchema,
+	...userIpRedisSchema
 };
-const policyScopeRedisSchema = {
-  clientId: {
-    type: search.SCHEMA_FIELD_TYPE.TAG,
-    INDEXMISSING: true
-  }
+var policyScopeRedisSchema = { clientId: {
+	type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+	INDEXMISSING: true
+} };
+/**
+* Note on the field type decision
+*
+* TAG is designed for the exact value matching
+* TEXT is designed for the word-based and pattern matching
+*
+* For our goal TAG fits perfectly and, more performant
+*/
+var accessRuleRedisSchema = {
+	...policyScopeRedisSchema,
+	...userScopeRedisSchema,
+	groupId: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true
+	},
+	type: {
+		type: _redis_search.SCHEMA_FIELD_TYPE.TAG,
+		INDEXMISSING: true
+	}
 };
-const accessRuleRedisSchema = {
-  ...policyScopeRedisSchema,
-  ...userScopeRedisSchema,
-  groupId: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true },
-  // Indexed so request-time callers that only care about Block policies
-  // (checkForHardBlock, blockMiddleware) can pre-filter via @type:{block}
-  // before the SERVER_SIDE_RANK_TOP_N cap kicks in. Without this, dense
-  // Restrict / routing-Block populations push the hard-block rules out
-  // of the top-N candidate set and the lookup silently misses them.
-  type: { type: search.SCHEMA_FIELD_TYPE.TAG, INDEXMISSING: true }
+var ACCESS_RULES_REDIS_INDEX_NAME = "index:user-access-rules";
+var ACCESS_RULE_REDIS_KEY_PREFIX = "uar:";
+var accessRulesRedisIndex = {
+	name: ACCESS_RULES_REDIS_INDEX_NAME,
+	schema: accessRuleRedisSchema,
+	options: {
+		ON: "HASH",
+		PREFIX: [ACCESS_RULE_REDIS_KEY_PREFIX]
+	}
 };
-const ACCESS_RULES_REDIS_INDEX_NAME = "index:user-access-rules";
-const ACCESS_RULE_REDIS_KEY_PREFIX = "uar:";
-const accessRulesRedisIndex = {
-  name: ACCESS_RULES_REDIS_INDEX_NAME,
-  schema: accessRuleRedisSchema,
-  options: {
-    ON: "HASH",
-    PREFIX: [ACCESS_RULE_REDIS_KEY_PREFIX]
-  }
-};
-const getAccessRuleRedisKey = (rule2) => ACCESS_RULE_REDIS_KEY_PREFIX + transformRule.makeAccessRuleHash(rule2);
-exports.GLOBAL_CLIENT_SCOPE_SENTINEL = rule.GLOBAL_CLIENT_SCOPE_SENTINEL;
+var getAccessRuleRedisKey = (rule) => ACCESS_RULE_REDIS_KEY_PREFIX + require_transformRule.makeAccessRuleHash(rule);
+//#endregion
 exports.ACCESS_RULES_REDIS_INDEX_NAME = ACCESS_RULES_REDIS_INDEX_NAME;
 exports.ACCESS_RULE_REDIS_KEY_PREFIX = ACCESS_RULE_REDIS_KEY_PREFIX;
+exports.GLOBAL_CLIENT_SCOPE_SENTINEL = require_rule.GLOBAL_CLIENT_SCOPE_SENTINEL;
 exports.accessRuleRedisSchema = accessRuleRedisSchema;
 exports.accessRulesRedisIndex = accessRulesRedisIndex;
 exports.getAccessRuleRedisKey = getAccessRuleRedisKey;

package/dist/cjs/redis/redisRulesStorage.cjs

@@ -1,34 +1,25 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const redisRulesReader = require("./reader/redisRulesReader.cjs");
-const redisRulesWriter = require("./redisRulesWriter.cjs");
-const createRedisAccessRulesStorage = (connection, logger) => {
-  const storage = composeStorage(
-    new redisRulesReader.DummyRedisRulesReader(logger),
-    new redisRulesWriter.DummyRedisRulesWriter(logger)
-  );
-  connection.getClient().then((client) => {
-    const realStorage = composeStorage(
-      new redisRulesReader.RedisRulesReader(client, logger),
-      new redisRulesWriter.RedisRulesWriter(client, logger)
-    );
-    Object.assign(storage, realStorage);
-    logger.info(() => ({
-      msg: "RedisAccessRules storage got a ready Redis client"
-    }));
-  });
-  return storage;
+const require_redis_reader_redisRulesReader = require("./reader/redisRulesReader.cjs");
+const require_redis_redisRulesWriter = require("./redisRulesWriter.cjs");
+//#region src/redis/redisRulesStorage.ts
+var createRedisAccessRulesStorage = (connection, logger) => {
+	const storage = composeStorage(new require_redis_reader_redisRulesReader.DummyRedisRulesReader(logger), new require_redis_redisRulesWriter.DummyRedisRulesWriter(logger));
+	connection.getClient().then((client) => {
+		const realStorage = composeStorage(new require_redis_reader_redisRulesReader.RedisRulesReader(client, logger), new require_redis_redisRulesWriter.RedisRulesWriter(client, logger));
+		Object.assign(storage, realStorage);
+		logger.info(() => ({ msg: "RedisAccessRules storage got a ready Redis client" }));
+	});
+	return storage;
 };
-const composeStorage = (reader, writer) => ({
-  // reader
-  fetchRules: reader.fetchRules.bind(reader),
-  getMissingRuleIds: reader.getMissingRuleIds.bind(reader),
-  findRules: reader.findRules.bind(reader),
-  findRuleIds: reader.findRuleIds.bind(reader),
-  fetchAllRuleIds: reader.fetchAllRuleIds.bind(reader),
-  // writer
-  insertRules: writer.insertRules.bind(writer),
-  deleteRules: writer.deleteRules.bind(writer),
-  deleteAllRules: writer.deleteAllRules.bind(writer)
+var composeStorage = (reader, writer) => ({
+	fetchRules: reader.fetchRules.bind(reader),
+	getMissingRuleIds: reader.getMissingRuleIds.bind(reader),
+	findRules: reader.findRules.bind(reader),
+	findRuleIds: reader.findRuleIds.bind(reader),
+	fetchAllRuleIds: reader.fetchAllRuleIds.bind(reader),
+	insertRules: writer.insertRules.bind(writer),
+	deleteRules: writer.deleteRules.bind(writer),
+	deleteAllRules: writer.deleteAllRules.bind(writer)
 });
+//#endregion
 exports.createRedisAccessRulesStorage = createRedisAccessRulesStorage;