@prosopo/user-access-policy 3.12.8 → 3.12.10

package/dist/redis/redisRulesWriter.js

@@ -1,117 +1,86 @@
-import { chunkIntoBatches, executeBatchesSequentially } from "@prosopo/common";
-import { REDIS_BATCH_SIZE } from "./redisClient.js";
+import "../_virtual/_rolldown/runtime.js";
 import { GLOBAL_CLIENT_SCOPE_SENTINEL } from "../rule.js";
+import { REDIS_BATCH_SIZE } from "./redisClient.js";
 import { ACCESS_RULE_REDIS_KEY_PREFIX, getAccessRuleRedisKey } from "./redisRuleIndex.js";
-class RedisRulesWriter {
-  constructor(client, logger) {
-    this.client = client;
-    this.logger = logger;
-  }
-  async insertRules(ruleEntries) {
-    const entryBatches = chunkIntoBatches(ruleEntries, REDIS_BATCH_SIZE);
-    const keyBatches = await executeBatchesSequentially(
-      entryBatches,
-      async (entriesBatch) => this.insertRuleEntries(entriesBatch)
-    );
-    return keyBatches.flatMap(
-      (ruleKey) => ruleKey.slice(ACCESS_RULE_REDIS_KEY_PREFIX.length)
-    );
-  }
-  async deleteRules(ruleIds) {
-    const ruleKeys = ruleIds.map(
-      (ruleId) => ACCESS_RULE_REDIS_KEY_PREFIX + ruleId
-    );
-    const keyBatches = chunkIntoBatches(ruleKeys, REDIS_BATCH_SIZE);
-    await executeBatchesSequentially(keyBatches, async (keysBatch) => {
-      const queries = this.client.multi();
-      for (const ruleKey of keysBatch) {
-        queries.del(ruleKey);
-      }
-      await queries.exec();
-    });
-  }
-  async deleteAllRules() {
-    let cursor = "0";
-    let total = 0;
-    do {
-      const reply = await this.client.scan(cursor, {
-        MATCH: `${ACCESS_RULE_REDIS_KEY_PREFIX}*`,
-        COUNT: REDIS_BATCH_SIZE
-      });
-      const ids = reply.keys.map(
-        (key) => key.slice(ACCESS_RULE_REDIS_KEY_PREFIX.length)
-      );
-      await this.deleteRules(ids);
-      total += ids.length;
-      cursor = reply.cursor;
-    } while ("0" !== cursor);
-    return total;
-  }
-  async insertRuleEntries(ruleEntries) {
-    const queries = this.client.multi();
-    const ruleKeys = ruleEntries.map((ruleEntry) => {
-      const { rule, expiresUnixTimestamp } = ruleEntry;
-      const ruleKey = getAccessRuleRedisKey(rule);
-      const ruleValue = getRedisRuleValue(rule);
-      queries.hSet(ruleKey, ruleValue);
-      if (expiresUnixTimestamp) {
-        const MILLISECOND_THRESHOLD = 1e10;
-        if (expiresUnixTimestamp > MILLISECOND_THRESHOLD) {
-          throw new Error(
-            `Invalid expiry timestamp: ${expiresUnixTimestamp}. Timestamp must be in seconds, not milliseconds.`
-          );
-        }
-        queries.expireAt(ruleKey, expiresUnixTimestamp);
-      }
-      return ruleKey;
-    });
-    await queries.exec();
-    return ruleKeys;
-  }
-}
-const getRedisRuleValue = (rule) => {
-  const record = {};
-  for (const [key, value] of Object.entries(rule)) {
-    if (value === void 0) {
-      continue;
-    }
-    record[key] = String(value);
-  }
-  if (record.clientId === void 0) {
-    record.clientId = GLOBAL_CLIENT_SCOPE_SENTINEL;
-  }
-  return record;
+import { chunkIntoBatches, executeBatchesSequentially } from "@prosopo/common";
+//#region src/redis/redisRulesWriter.ts
+var RedisRulesWriter = class {
+	constructor(client, logger) {
+		this.client = client;
+		this.logger = logger;
+	}
+	async insertRules(ruleEntries) {
+		return (await executeBatchesSequentially(chunkIntoBatches(ruleEntries, REDIS_BATCH_SIZE), async (entriesBatch) => this.insertRuleEntries(entriesBatch))).flatMap((ruleKey) => ruleKey.slice(ACCESS_RULE_REDIS_KEY_PREFIX.length));
+	}
+	async deleteRules(ruleIds) {
+		await executeBatchesSequentially(chunkIntoBatches(ruleIds.map((ruleId) => ACCESS_RULE_REDIS_KEY_PREFIX + ruleId), REDIS_BATCH_SIZE), async (keysBatch) => {
+			const queries = this.client.multi();
+			for (const ruleKey of keysBatch) queries.del(ruleKey);
+			await queries.exec();
+		});
+	}
+	async deleteAllRules() {
+		let cursor = "0";
+		let total = 0;
+		do {
+			const reply = await this.client.scan(cursor, {
+				MATCH: `${ACCESS_RULE_REDIS_KEY_PREFIX}*`,
+				COUNT: REDIS_BATCH_SIZE
+			});
+			const ids = reply.keys.map((key) => key.slice(ACCESS_RULE_REDIS_KEY_PREFIX.length));
+			await this.deleteRules(ids);
+			total += ids.length;
+			cursor = reply.cursor;
+		} while ("0" !== cursor);
+		return total;
+	}
+	async insertRuleEntries(ruleEntries) {
+		const queries = this.client.multi();
+		const ruleKeys = ruleEntries.map((ruleEntry) => {
+			const { rule, expiresUnixTimestamp } = ruleEntry;
+			const ruleKey = getAccessRuleRedisKey(rule);
+			const ruleValue = getRedisRuleValue(rule);
+			queries.hSet(ruleKey, ruleValue);
+			if (expiresUnixTimestamp) {
+				if (expiresUnixTimestamp > 1e10) throw new Error(`Invalid expiry timestamp: ${expiresUnixTimestamp}. Timestamp must be in seconds, not milliseconds.`);
+				queries.expireAt(ruleKey, expiresUnixTimestamp);
+			}
+			return ruleKey;
+		});
+		await queries.exec();
+		return ruleKeys;
+	}
+};
+var getRedisRuleValue = (rule) => {
+	const record = {};
+	for (const [key, value] of Object.entries(rule)) {
+		if (value === void 0) continue;
+		record[key] = String(value);
+	}
+	if (record.clientId === void 0) record.clientId = GLOBAL_CLIENT_SCOPE_SENTINEL;
+	return record;
 };
-class DummyRedisRulesWriter {
-  constructor(logger) {
-    this.logger = logger;
-  }
-  async insertRules(ruleEntries) {
-    this.logger.info(() => ({
-      msg: "Dummy insertRules() has no effect (redis is not ready)",
-      data: {
-        ruleEntries
-      }
-    }));
-    return [];
-  }
-  async deleteRules(ruleIds) {
-    this.logger.info(() => ({
-      msg: "Dummy deleteRules() has no effect (redis is not ready)",
-      data: {
-        ruleIds
-      }
-    }));
-  }
-  async deleteAllRules() {
-    this.logger.info(() => ({
-      msg: "Dummy deleteAllRules() has no effect (redis is not ready)"
-    }));
-    return 0;
-  }
-}
-export {
-  DummyRedisRulesWriter,
-  RedisRulesWriter,
-  getRedisRuleValue
+var DummyRedisRulesWriter = class {
+	constructor(logger) {
+		this.logger = logger;
+	}
+	async insertRules(ruleEntries) {
+		this.logger.info(() => ({
+			msg: "Dummy insertRules() has no effect (redis is not ready)",
+			data: { ruleEntries }
+		}));
+		return [];
+	}
+	async deleteRules(ruleIds) {
+		this.logger.info(() => ({
+			msg: "Dummy deleteRules() has no effect (redis is not ready)",
+			data: { ruleIds }
+		}));
+	}
+	async deleteAllRules() {
+		this.logger.info(() => ({ msg: "Dummy deleteAllRules() has no effect (redis is not ready)" }));
+		return 0;
+	}
 };
+//#endregion
+export { DummyRedisRulesWriter, RedisRulesWriter, getRedisRuleValue };

package/dist/rule.js

@@ -1,10 +1,10 @@
-var AccessPolicyType = /* @__PURE__ */ ((AccessPolicyType2) => {
-  AccessPolicyType2["Block"] = "block";
-  AccessPolicyType2["Restrict"] = "restrict";
-  return AccessPolicyType2;
-})(AccessPolicyType || {});
-const GLOBAL_CLIENT_SCOPE_SENTINEL = "global";
-export {
-  AccessPolicyType,
-  GLOBAL_CLIENT_SCOPE_SENTINEL
-};
+import "./_virtual/_rolldown/runtime.js";
+//#region src/rule.ts
+var AccessPolicyType = /* @__PURE__ */ function(AccessPolicyType) {
+	AccessPolicyType["Block"] = "block";
+	AccessPolicyType["Restrict"] = "restrict";
+	return AccessPolicyType;
+}({});
+var GLOBAL_CLIENT_SCOPE_SENTINEL = "global";
+//#endregion
+export { AccessPolicyType, GLOBAL_CLIENT_SCOPE_SENTINEL };

package/dist/ruleInput/.export.js

@@ -1,9 +1,5 @@
-import { accessRuleInput } from "./ruleInput.js";
+import "../_virtual/_rolldown/runtime.js";
 import { accessPolicyInput, policyScopeInput } from "./policyInput.js";
 import { userScopeInput } from "./userScopeInput.js";
-export {
-  accessPolicyInput,
-  accessRuleInput,
-  policyScopeInput,
-  userScopeInput
-};
+import { accessRuleInput } from "./ruleInput.js";
+export { accessPolicyInput, accessRuleInput, policyScopeInput, userScopeInput };

package/dist/ruleInput/policyInput.js

@@ -1,65 +1,39 @@
-import { CaptchaTypeSchema } from "@prosopo/types";
+import "../_virtual/_rolldown/runtime.js";
+import { AccessPolicyType } from "../rule.js";
 import { z } from "zod";
-import { AccessPolicyType, GLOBAL_CLIENT_SCOPE_SENTINEL } from "../rule.js";
-const accessPolicyInputShape = z.object({
-  type: z.nativeEnum(AccessPolicyType),
-  captchaType: CaptchaTypeSchema.optional(),
-  description: z.coerce.string().optional(),
-  // Redis stores values as strings, so coerce is needed to parse properly
-  solvedImagesCount: z.coerce.number().optional(),
-  // the percentage of image panels that must be solved per image CAPTCHA
-  imageThreshold: z.coerce.number().optional(),
-  // the Proof-of-Work difficulty level
-  powDifficulty: z.coerce.number().optional(),
-  // the number of unsolved image CAPTCHA challenges to serve
-  unsolvedImagesCount: z.coerce.number().optional(),
-  // used to increase the user's score
-  frictionlessScore: z.coerce.number().optional(),
-  // Skip the request-time block middleware and only fire at verify.
-  // Redis stores booleans as strings — preprocess so "true"/"false"
-  // round-trip to the JS boolean the matcher expects.
-  deferToVerify: z.preprocess((v) => typeof v === "string" ? v === "true" : v, z.boolean()).optional()
+import { CaptchaTypeSchema } from "@prosopo/types";
+//#region src/ruleInput/policyInput.ts
+var accessPolicyInputShape = z.object({
+	type: z.nativeEnum(AccessPolicyType),
+	captchaType: CaptchaTypeSchema.optional(),
+	description: z.coerce.string().optional(),
+	solvedImagesCount: z.coerce.number().optional(),
+	imageThreshold: z.coerce.number().optional(),
+	powDifficulty: z.coerce.number().optional(),
+	unsolvedImagesCount: z.coerce.number().optional(),
+	frictionlessScore: z.coerce.number().optional(),
+	deferToVerify: z.preprocess((v) => typeof v === "string" ? v === "true" : v, z.boolean()).optional()
 });
-const accessPolicyInput = accessPolicyInputShape.superRefine(
-  (policy, ctx) => {
-    if (policy.type !== AccessPolicyType.Block) return;
-    if (policy.captchaType !== void 0) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["captchaType"],
-        message: "Block policies cannot pin a captchaType — Block always applies to every captcha type. Use a Restrict policy if you want to narrow the effect to one captcha type."
-      });
-    }
-    if (policy.solvedImagesCount !== void 0) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["solvedImagesCount"],
-        message: "Block policies cannot set solvedImagesCount — the field only applies to Restrict policies that adjust image-captcha rounds."
-      });
-    }
-  }
-);
-const sanitizeAccessPolicy = (policy) => {
-  if (policy.type === AccessPolicyType.Block) {
-    const { captchaType, solvedImagesCount, ...blockPolicy } = policy;
-    return blockPolicy;
-  }
-  return policy;
-};
-const policyScopeInput = z.object({
-  // `getRedisRuleValue` stamps a sentinel string on global rules so the
-  // read-time query can probe `@clientId:{global}` cheaply. Undo the
-  // stamp here so consumers (rankCandidateRules, response payloads,
-  // tests) continue to see `undefined` for global rules — the mongoose
-  // side and the API input side never emit the sentinel.
-  clientId: z.preprocess(
-    (v) => v === GLOBAL_CLIENT_SCOPE_SENTINEL ? void 0 : v,
-    z.coerce.string().optional()
-  )
+var accessPolicyInput = accessPolicyInputShape.superRefine((policy, ctx) => {
+	if (policy.type !== AccessPolicyType.Block) return;
+	if (policy.captchaType !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["captchaType"],
+		message: "Block policies cannot pin a captchaType — Block always applies to every captcha type. Use a Restrict policy if you want to narrow the effect to one captcha type."
+	});
+	if (policy.solvedImagesCount !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["solvedImagesCount"],
+		message: "Block policies cannot set solvedImagesCount — the field only applies to Restrict policies that adjust image-captcha rounds."
+	});
 });
-export {
-  accessPolicyInput,
-  accessPolicyInputShape,
-  policyScopeInput,
-  sanitizeAccessPolicy
+var sanitizeAccessPolicy = (policy) => {
+	if (policy.type === AccessPolicyType.Block) {
+		const { captchaType, solvedImagesCount, ...blockPolicy } = policy;
+		return blockPolicy;
+	}
+	return policy;
 };
+var policyScopeInput = z.object({ clientId: z.preprocess((v) => v === "global" ? void 0 : v, z.coerce.string().optional()) });
+//#endregion
+export { accessPolicyInput, accessPolicyInputShape, policyScopeInput, sanitizeAccessPolicy };

package/dist/ruleInput/ruleInput.js

@@ -1,51 +1,43 @@
-import { z } from "zod";
+import "../_virtual/_rolldown/runtime.js";
 import { FilterScopeMatch } from "../rulesStorage.js";
-import { policyScopeInput, accessPolicyInputShape } from "./policyInput.js";
+import { accessPolicyInputShape, policyScopeInput } from "./policyInput.js";
 import { userScopeInput } from "./userScopeInput.js";
-const ruleGroupInput = z.object({
-  groupId: z.coerce.string().optional(),
-  ruleGroupId: z.coerce.string().optional()
-}).transform((ruleGroupInput2) => {
-  const { ruleGroupId, ...ruleGroup } = ruleGroupInput2;
-  if ("string" === typeof ruleGroupId) {
-    ruleGroup.groupId = ruleGroupId;
-  }
-  return ruleGroup;
+import { z } from "zod";
+//#region src/ruleInput/ruleInput.ts
+var ruleGroupInput = z.object({
+	groupId: z.coerce.string().optional(),
+	ruleGroupId: z.coerce.string().optional()
+}).transform((ruleGroupInput) => {
+	const { ruleGroupId, ...ruleGroup } = ruleGroupInput;
+	if ("string" === typeof ruleGroupId) ruleGroup.groupId = ruleGroupId;
+	return ruleGroup;
 });
-const accessRuleInput = z.object({
-  ...accessPolicyInputShape.shape,
-  ...policyScopeInput.shape
+var accessRuleInput = z.object({
+	...accessPolicyInputShape.shape,
+	...policyScopeInput.shape
 }).and(userScopeInput).and(ruleGroupInput).transform((ruleInput) => ruleInput);
-const ruleEntryInput = z.object({
-  rule: accessRuleInput,
-  expiresUnixTimestamp: z.coerce.number().optional()
+var ruleEntryInput = z.object({
+	rule: accessRuleInput,
+	expiresUnixTimestamp: z.coerce.number().optional()
 });
-const accessRulesFilterInput = z.object({
-  policyScope: policyScopeInput.optional(),
-  policyScopes: z.array(policyScopeInput).optional(),
-  policyScopeMatch: z.nativeEnum(FilterScopeMatch).default(FilterScopeMatch.Exact),
-  userScope: userScopeInput.optional(),
-  userScopeMatch: z.nativeEnum(FilterScopeMatch).default(FilterScopeMatch.Exact),
-  groupId: z.string().optional(),
-  blockOnly: z.boolean().optional()
+var accessRulesFilterInput = z.object({
+	policyScope: policyScopeInput.optional(),
+	policyScopes: z.array(policyScopeInput).optional(),
+	policyScopeMatch: z.nativeEnum(FilterScopeMatch).default(FilterScopeMatch.Exact),
+	userScope: userScopeInput.optional(),
+	userScopeMatch: z.nativeEnum(FilterScopeMatch).default(FilterScopeMatch.Exact),
+	groupId: z.string().optional(),
+	blockOnly: z.boolean().optional()
 });
-const getAccessRuleFiltersFromInput = (filterInput) => {
-  const { policyScopes, policyScope, ...filterBase } = filterInput;
-  const allPolicyScopes = policyScopes || [];
-  if (policyScope) {
-    allPolicyScopes.push(policyScope);
-  }
-  if (allPolicyScopes.length > 0) {
-    return allPolicyScopes.map((policyScope2) => ({
-      ...filterBase,
-      policyScope: policyScope2
-    }));
-  }
-  return [filterBase];
-};
-export {
-  accessRuleInput,
-  accessRulesFilterInput,
-  getAccessRuleFiltersFromInput,
-  ruleEntryInput
+var getAccessRuleFiltersFromInput = (filterInput) => {
+	const { policyScopes, policyScope, ...filterBase } = filterInput;
+	const allPolicyScopes = policyScopes || [];
+	if (policyScope) allPolicyScopes.push(policyScope);
+	if (allPolicyScopes.length > 0) return allPolicyScopes.map((policyScope) => ({
+		...filterBase,
+		policyScope
+	}));
+	return [filterBase];
 };
+//#endregion
+export { accessRuleInput, accessRulesFilterInput, getAccessRuleFiltersFromInput, ruleEntryInput };

package/dist/ruleInput/userScopeInput.js

@@ -1,63 +1,52 @@
+import "../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
 import crypto from "node:crypto";
 import { getIPAddress } from "@prosopo/util";
 import { Address4, Address6 } from "ip-address";
-import { z } from "zod";
-const userAttributesSchema = z.object({
-  // coerce is used for safety, as e.g., incoming userId can be digital
-  userId: z.coerce.string().optional(),
-  ja4Hash: z.coerce.string().optional(),
-  headersHash: z.coerce.string().optional(),
-  userAgentHash: z.coerce.string().optional(),
-  headHash: z.coerce.string().optional(),
-  coords: z.coerce.string().optional(),
-  countryCode: z.coerce.string().optional(),
-  asn: z.coerce.number().int().nonnegative().optional(),
-  // Plain lowercase OS tag (see `classifyOs`). Loose `string` like
-  // countryCode: a stale/unknown value just never matches a request rather
-  // than failing the whole rule parse.
-  os: z.coerce.string().optional()
+//#region src/ruleInput/userScopeInput.ts
+var userAttributesSchema = z.object({
+	userId: z.coerce.string().optional(),
+	ja4Hash: z.coerce.string().optional(),
+	headersHash: z.coerce.string().optional(),
+	userAgentHash: z.coerce.string().optional(),
+	headHash: z.coerce.string().optional(),
+	coords: z.coerce.string().optional(),
+	countryCode: z.coerce.string().optional(),
+	asn: z.coerce.number().int().nonnegative().optional(),
+	os: z.coerce.string().optional()
 });
-const userAttributesInput = z.object({
-  ...userAttributesSchema.shape,
-  userAgent: z.coerce.string().optional()
-}).transform((userAttributesInput2) => {
-  const { userAgent, ...userScope } = userAttributesInput2;
-  if ("string" === typeof userAgent) {
-    userScope.userAgentHash = hashUserAgent(userAgent);
-  }
-  return userScope;
+var userAttributesInput = z.object({
+	...userAttributesSchema.shape,
+	userAgent: z.coerce.string().optional()
+}).transform((userAttributesInput) => {
+	const { userAgent, ...userScope } = userAttributesInput;
+	if ("string" === typeof userAgent) userScope.userAgentHash = hashUserAgent(userAgent);
+	return userScope;
 });
-const hashUserAgent = (userAgent) => crypto.createHash("sha256").update(userAgent).digest("hex");
-const userIpSchema = z.object({
-  numericIp: z.coerce.bigint().optional(),
-  numericIpMaskMin: z.coerce.bigint().optional(),
-  numericIpMaskMax: z.coerce.bigint().optional()
+var hashUserAgent = (userAgent) => crypto.createHash("sha256").update(userAgent).digest("hex");
+var userIpSchema = z.object({
+	numericIp: z.coerce.bigint().optional(),
+	numericIpMaskMin: z.coerce.bigint().optional(),
+	numericIpMaskMax: z.coerce.bigint().optional()
 });
-const userIpInput = z.object({
-  ...userIpSchema.shape,
-  ip: z.string().optional(),
-  ipMask: z.string().optional()
-}).transform((userIpInput2) => {
-  const { ip, ipMask, ...numericUserIp } = userIpInput2;
-  if ("string" === typeof ip) {
-    numericUserIp.numericIp = getIPAddress(ip).bigInt();
-  }
-  if ("string" === typeof ipMask) {
-    const ipObject = Address4.isValid(ipMask) ? new Address4(ipMask) : new Address6(ipMask);
-    numericUserIp.numericIpMaskMin = ipObject.startAddress().bigInt();
-    numericUserIp.numericIpMaskMax = ipObject.endAddress().bigInt();
-  }
-  return numericUserIp;
+var userIpInput = z.object({
+	...userIpSchema.shape,
+	ip: z.string().optional(),
+	ipMask: z.string().optional()
+}).transform((userIpInput) => {
+	const { ip, ipMask, ...numericUserIp } = userIpInput;
+	if ("string" === typeof ip) numericUserIp.numericIp = getIPAddress(ip).bigInt();
+	if ("string" === typeof ipMask) {
+		const ipObject = Address4.isValid(ipMask) ? new Address4(ipMask) : new Address6(ipMask);
+		numericUserIp.numericIpMaskMin = ipObject.startAddress().bigInt();
+		numericUserIp.numericIpMaskMax = ipObject.endAddress().bigInt();
+	}
+	return numericUserIp;
 });
-const userScopeSchema = z.object({
-  ...userIpSchema.shape,
-  ...userAttributesSchema.shape
+var userScopeSchema = z.object({
+	...userIpSchema.shape,
+	...userAttributesSchema.shape
 });
-const userScopeInput = z.object({}).and(userIpInput).and(userAttributesInput).transform(
-  // transform is used for type safety only - plain "satisfies ZodType<x>" doesn't work after ".and()"
-  (userScopeInput2) => userScopeInput2
-);
-export {
-  userScopeInput,
-  userScopeSchema
-};
+var userScopeInput = z.object({}).and(userIpInput).and(userAttributesInput).transform((userScopeInput) => userScopeInput);
+//#endregion
+export { userScopeInput, userScopeSchema };

package/dist/ruleRecord.js

@@ -1,28 +1,18 @@
-const userAttributesRecordFields = [
-  "userId",
-  "ja4Hash",
-  "headersHash",
-  "userAgent",
-  "headHash",
-  "coords",
-  "countryCode",
-  "asn",
-  "os"
+import "./_virtual/_rolldown/runtime.js";
+//#region src/ruleRecord.ts
+var userAttributesRecordFields = [
+	"userId",
+	"ja4Hash",
+	"headersHash",
+	"userAgent",
+	"headHash",
+	"coords",
+	"countryCode",
+	"asn",
+	"os"
 ];
-const userIpRecordFields = [
-  "ip",
-  "ipMask"
-];
-const userScopeRecordFields = [
-  ...userAttributesRecordFields,
-  ...userIpRecordFields
-];
-const getUserScopeRecordFromAccessRuleRecord = (ruleRecord) => Object.fromEntries(
-  userScopeRecordFields.map((field) => [field, ruleRecord[field]]).filter(([, value]) => value !== void 0)
-);
-export {
-  getUserScopeRecordFromAccessRuleRecord,
-  userAttributesRecordFields,
-  userIpRecordFields,
-  userScopeRecordFields
-};
+var userIpRecordFields = ["ip", "ipMask"];
+var userScopeRecordFields = [...userAttributesRecordFields, ...userIpRecordFields];
+var getUserScopeRecordFromAccessRuleRecord = (ruleRecord) => Object.fromEntries(userScopeRecordFields.map((field) => [field, ruleRecord[field]]).filter(([, value]) => value !== void 0));
+//#endregion
+export { getUserScopeRecordFromAccessRuleRecord, userAttributesRecordFields, userIpRecordFields, userScopeRecordFields };

package/dist/rulesStorage.js

@@ -1,8 +1,9 @@
-var FilterScopeMatch = /* @__PURE__ */ ((FilterScopeMatch2) => {
-  FilterScopeMatch2["Exact"] = "exact";
-  FilterScopeMatch2["Greedy"] = "greedy";
-  return FilterScopeMatch2;
-})(FilterScopeMatch || {});
-export {
-  FilterScopeMatch
-};
+import "./_virtual/_rolldown/runtime.js";
+//#region src/rulesStorage.ts
+var FilterScopeMatch = /* @__PURE__ */ function(FilterScopeMatch) {
+	FilterScopeMatch["Exact"] = "exact";
+	FilterScopeMatch["Greedy"] = "greedy";
+	return FilterScopeMatch;
+}({});
+//#endregion
+export { FilterScopeMatch };

package/dist/tests/redis/redisRulesStorage.integration.test.js

@@ -168,9 +168,7 @@ describe("redisAccessRulesStorage", () => {
             const afterDeleteIndexRecordsCount = await getIndexRecordsCount(indexName);
             expect(afterDeleteIndexRecordsCount).toBe(0);
         });
-    }, {
-        timeout: 240_000,
-    });
+    }, 240_000);
     describe("reader", () => {
         let accessRulesReader;
         beforeAll(async () => {