@prosopo/user-access-policy 3.2.1 → 3.3.1

package/dist/cjs/accessPolicy.cjs

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const types = require("@prosopo/types");
+const util = require("@prosopo/util");
 const ipAddress = require("ip-address");
 const zod = require("zod");
-const util = require("./util.cjs");
+const util$1 = require("./util.cjs");
 var AccessPolicyType = /* @__PURE__ */ ((AccessPolicyType2) => {
   AccessPolicyType2["Block"] = "block";
   AccessPolicyType2["Restrict"] = "restrict";
@@ -49,7 +50,7 @@ const userScopeInputSchema = userScopeSchema.extend({
 }).transform((inputUserScope) => {
   const { ip, ipMask, userAgent, ...userScope } = inputUserScope;
   if ("string" === typeof ip) {
-    userScope.numericIp = new ipAddress.Address4(ip).bigInt();
+    userScope.numericIp = util.getIPAddress(ip).bigInt();
   }
   if ("string" === typeof ipMask) {
     const ipObject = new ipAddress.Address4(ipMask);
@@ -57,7 +58,7 @@ const userScopeInputSchema = userScopeSchema.extend({
     userScope.numericIpMaskMax = ipObject.endAddress().bigInt();
   }
   if ("string" === typeof userAgent) {
-    userScope.userAgentHash = util.hashUserAgent(userAgent);
+    userScope.userAgentHash = util$1.hashUserAgent(userAgent);
   }
   return userScope;
 });

package/dist/cjs/redis/redisAccessRules.cjs

@@ -22,8 +22,11 @@ function _interopNamespaceDefault(e) {
 const util__namespace = /* @__PURE__ */ _interopNamespaceDefault(util);
 const createRedisAccessRulesReader = (client, logger) => {
   return {
-    findRules: async (filter) => {
+    findRules: async (filter, skipEmptyUserScopes = true) => {
       const query = redisAccessRulesIndex.getRedisAccessRulesQuery(filter);
+      if (skipEmptyUserScopes && query === "ismissing(@clientId)") {
+        return [];
+      }
       let searchReply;
       try {
         searchReply = await client.ft.search(
@@ -31,19 +34,21 @@ const createRedisAccessRulesReader = (client, logger) => {
           query,
           redisAccessRulesIndex.accessRulesRedisSearchOptions
         );
-        logger.debug(() => ({
-          msg: "Executed search query",
-          data: {
-            inspect: util__namespace.inspect(
-              {
-                filter,
-                searchReply,
-                query
-              },
-              { depth: null }
-            )
-          }
-        }));
+        if (searchReply.total > 0) {
+          logger.debug(() => ({
+            msg: "Executed search query",
+            data: {
+              inspect: util__namespace.inspect(
+                {
+                  filter,
+                  searchReply,
+                  query
+                },
+                { depth: null }
+              )
+            }
+          }));
+        }
       } catch (e) {
         logger.error(() => ({
           err: e,
@@ -115,7 +120,8 @@ const createRedisAccessRulesWriter = (client) => {
     deleteRules: async (ruleIds) => void await client.del(ruleIds),
     deleteAllRules: async () => {
       const keys = await client.keys(`${redisAccessRulesIndex.accessRuleRedisKeyPrefix}*`);
-      return keys.length > 0 ? await client.del(keys) : 0;
+      if (keys.length === 0) return 0;
+      return await client.del(keys);
     }
   };
 };

package/dist/cjs/redis/redisAccessRulesIndex.cjs

@@ -7,7 +7,7 @@ const redisIndex = require("./redisIndex.cjs");
 const accessRulesRedisIndexName = "index:user-access-rules";
 const accessRuleRedisKeyPrefix = "uar:";
 const accessRuleContentHashAlgorithm = "md5";
-const DEFAULT_SEARCH_LIMIT = 1e4;
+const DEFAULT_SEARCH_LIMIT = 1e3;
 const accessRulesIndex = {
   name: accessRulesRedisIndexName,
   /**
@@ -35,7 +35,7 @@ const accessRulesIndex = {
   // the satisfy statement is to guarantee that the keys are right
   options: {
     ON: "HASH",
-    PREFIX: accessRuleRedisKeyPrefix
+    PREFIX: [accessRuleRedisKeyPrefix]
   }
 };
 const createRedisAccessRulesIndex = async (client) => redisIndex.createRedisIndex(client, accessRulesIndex);
@@ -48,6 +48,10 @@ const greedyFieldComparisons = {
   numericIp: (value) => `( @numericIp:[${value}] | ( @numericIpMaskMin:[-inf ${value}] @numericIpMaskMax:[${value} +inf] ) )`
 };
 const accessRulesRedisSearchOptions = {
+  // #2 is a required option when the 'ismissing()' function is in the query body
+  DIALECT: 2
+};
+const accessRulesRedisDeleteOptions = {
   // #2 is a required option when the 'ismissing()' function is in the query body
   DIALECT: 2,
   LIMIT: {
@@ -100,6 +104,7 @@ const getRedisAccessRuleValue = (rule) => Object.fromEntries(
   Object.entries(rule).map(([key, value]) => [key, String(value)])
 );
 exports.accessRuleRedisKeyPrefix = accessRuleRedisKeyPrefix;
+exports.accessRulesRedisDeleteOptions = accessRulesRedisDeleteOptions;
 exports.accessRulesRedisIndexName = accessRulesRedisIndexName;
 exports.accessRulesRedisSearchOptions = accessRulesRedisSearchOptions;
 exports.createRedisAccessRulesIndex = createRedisAccessRulesIndex;

package/dist/index.js

@@ -1,15 +1,28 @@
-import { AccessPolicyType, accessPolicySchema, policyScopeSchema, } from "#policy/accessPolicy.js";
-import { createAccessPolicyResolver, } from "#policy/accessPolicyResolver.js";
-import { ScopeMatch } from "#policy/accessPolicyResolver.js";
-import { AccessRuleApiRoutes, accessRuleApiPaths, getExpressApiRuleRateLimits, } from "#policy/api/accessRuleApiRoutes.js";
-import { deleteAllRulesEndpointSchema } from "#policy/api/deleteAllRulesEndpoint.js";
-import { deleteRulesEndpointSchema, } from "#policy/api/deleteRulesEndpoint.js";
-import { insertRulesEndpointSchema, } from "#policy/api/insertRulesEndpoint.js";
-import { createRedisAccessRulesStorage } from "#policy/redis/redisAccessRules.js";
-import { createRedisAccessRulesIndex } from "#policy/redis/redisAccessRulesIndex.js";
-import { userScopeInputSchema } from "./accessPolicy.js";
-export const createApiRuleRoutesProvider = (rulesStorage) => {
-    return new AccessRuleApiRoutes(rulesStorage);
+import { AccessPolicyType, accessPolicySchema, policyScopeSchema, userScopeInputSchema } from "./accessPolicy.js";
+import { ScopeMatch, createAccessPolicyResolver } from "./accessPolicyResolver.js";
+import { AccessRuleApiRoutes } from "./api/accessRuleApiRoutes.js";
+import { accessRuleApiPaths, getExpressApiRuleRateLimits } from "./api/accessRuleApiRoutes.js";
+import { deleteAllRulesEndpointSchema } from "./api/deleteAllRulesEndpoint.js";
+import { deleteRulesEndpointSchema } from "./api/deleteRulesEndpoint.js";
+import { insertRulesEndpointSchema } from "./api/insertRulesEndpoint.js";
+import { createRedisAccessRulesStorage } from "./redis/redisAccessRules.js";
+import { createRedisAccessRulesIndex } from "./redis/redisAccessRulesIndex.js";
+const createApiRuleRoutesProvider = (rulesStorage) => {
+  return new AccessRuleApiRoutes(rulesStorage);
+};
+export {
+  AccessPolicyType,
+  ScopeMatch,
+  accessPolicySchema,
+  accessRuleApiPaths,
+  createAccessPolicyResolver,
+  createApiRuleRoutesProvider,
+  createRedisAccessRulesIndex,
+  createRedisAccessRulesStorage,
+  deleteAllRulesEndpointSchema,
+  deleteRulesEndpointSchema,
+  getExpressApiRuleRateLimits,
+  insertRulesEndpointSchema,
+  policyScopeSchema,
+  userScopeInputSchema
 };
-export { createAccessPolicyResolver, AccessPolicyType, ScopeMatch, createRedisAccessRulesIndex, createRedisAccessRulesStorage, accessRuleApiPaths, accessPolicySchema, policyScopeSchema, insertRulesEndpointSchema, deleteAllRulesEndpointSchema, deleteRulesEndpointSchema, getExpressApiRuleRateLimits, userScopeInputSchema, };
-//# sourceMappingURL=index.js.map

package/dist/redis/redisAccessRules.js

@@ -1,112 +1,135 @@
 import * as util from "node:util";
-import { accessRuleSchema, } from "#policy/accessRules.js";
-import { accessRuleRedisKeyPrefix, accessRulesRedisIndexName, accessRulesRedisSearchOptions, getRedisAccessRuleKey, getRedisAccessRuleValue, getRedisAccessRulesQuery, } from "#policy/redis/redisAccessRulesIndex.js";
-export const createRedisAccessRulesReader = (client, logger) => {
-    return {
-        findRules: async (filter) => {
-            const query = getRedisAccessRulesQuery(filter);
-            let searchReply;
-            try {
-                searchReply = await client.ft.search(accessRulesRedisIndexName, query, accessRulesRedisSearchOptions);
-                logger.debug(() => ({
-                    msg: "Executed search query",
-                    data: {
-                        inspect: util.inspect({
-                            filter: filter,
-                            searchReply: searchReply,
-                            query: query,
-                        }, { depth: null }),
-                    },
-                }));
+import { accessRuleSchema } from "../accessRules.js";
+import { getRedisAccessRulesQuery, accessRulesRedisIndexName, accessRulesRedisSearchOptions, accessRuleRedisKeyPrefix, getRedisAccessRuleKey, getRedisAccessRuleValue } from "./redisAccessRulesIndex.js";
+const createRedisAccessRulesReader = (client, logger) => {
+  return {
+    findRules: async (filter, skipEmptyUserScopes = true) => {
+      const query = getRedisAccessRulesQuery(filter);
+      if (skipEmptyUserScopes && query === "ismissing(@clientId)") {
+        return [];
+      }
+      let searchReply;
+      try {
+        searchReply = await client.ft.search(
+          accessRulesRedisIndexName,
+          query,
+          accessRulesRedisSearchOptions
+        );
+        if (searchReply.total > 0) {
+          logger.debug(() => ({
+            msg: "Executed search query",
+            data: {
+              inspect: util.inspect(
+                {
+                  filter,
+                  searchReply,
+                  query
+                },
+                { depth: null }
+              )
             }
-            catch (e) {
-                logger.error(() => ({
-                    err: e,
-                    data: {
-                        inspect: util.inspect({
-                            query: query,
-                            filter: filter,
-                        }, {
-                            depth: null,
-                        }),
-                    },
-                    msg: "failed to execute search query",
-                }));
-                return [];
-            }
-            return extractAccessRulesFromSearchReply(searchReply, logger);
-        },
-        findRuleIds: async (filter) => {
-            const query = getRedisAccessRulesQuery(filter);
-            let searchReply;
-            try {
-                searchReply = await client.ft.searchNoContent(accessRulesRedisIndexName, query, accessRulesRedisSearchOptions);
-            }
-            catch (e) {
-                logger.error(() => ({
-                    err: e,
-                    data: {
-                        inspect: util.inspect({
-                            query: query,
-                            filter: filter,
-                        }, {
-                            depth: null,
-                        }),
-                    },
-                    msg: "Failed to execute search query for rule IDs",
-                }));
-                return [];
-            }
-            return searchReply.documents;
-        },
-    };
+          }));
+        }
+      } catch (e) {
+        logger.error(() => ({
+          err: e,
+          data: {
+            inspect: util.inspect(
+              {
+                query,
+                filter
+              },
+              {
+                depth: null
+              }
+            )
+          },
+          msg: "failed to execute search query"
+        }));
+        return [];
+      }
+      return extractAccessRulesFromSearchReply(searchReply, logger);
+    },
+    findRuleIds: async (filter) => {
+      const query = getRedisAccessRulesQuery(filter);
+      let searchReply;
+      try {
+        searchReply = await client.ft.searchNoContent(
+          accessRulesRedisIndexName,
+          query,
+          accessRulesRedisSearchOptions
+        );
+      } catch (e) {
+        logger.error(() => ({
+          err: e,
+          data: {
+            inspect: util.inspect(
+              {
+                query,
+                filter
+              },
+              {
+                depth: null
+              }
+            )
+          },
+          msg: "Failed to execute search query for rule IDs"
+        }));
+        return [];
+      }
+      return searchReply.documents;
+    }
+  };
 };
-export const createRedisAccessRulesWriter = (client) => {
-    return {
-        insertRule: async (rule, expirationTimestamp) => {
-            const ruleKey = getRedisAccessRuleKey(rule);
-            const ruleValue = getRedisAccessRuleValue(rule);
-            await client.hSet(ruleKey, ruleValue);
-            if (expirationTimestamp) {
-                const expiryDate = new Date(expirationTimestamp);
-                if (expiryDate.getUTCFullYear() === 1970) {
-                    await client.expireAt(ruleKey, expirationTimestamp);
-                }
-                else {
-                    const timestampInSeconds = Math.floor(expirationTimestamp / 1000);
-                    await client.expireAt(ruleKey, timestampInSeconds);
-                }
-            }
-            return ruleKey;
-        },
-        deleteRules: async (ruleIds) => void (await client.del(ruleIds)),
-        deleteAllRules: async () => {
-            const keys = await client.keys(`${accessRuleRedisKeyPrefix}*`);
-            return keys.length > 0 ? await client.del(keys) : 0;
-        },
-    };
+const createRedisAccessRulesWriter = (client) => {
+  return {
+    insertRule: async (rule, expirationTimestamp) => {
+      const ruleKey = getRedisAccessRuleKey(rule);
+      const ruleValue = getRedisAccessRuleValue(rule);
+      await client.hSet(ruleKey, ruleValue);
+      if (expirationTimestamp) {
+        const expiryDate = new Date(expirationTimestamp);
+        if (expiryDate.getUTCFullYear() === 1970) {
+          await client.expireAt(ruleKey, expirationTimestamp);
+        } else {
+          const timestampInSeconds = Math.floor(expirationTimestamp / 1e3);
+          await client.expireAt(ruleKey, timestampInSeconds);
+        }
+      }
+      return ruleKey;
+    },
+    deleteRules: async (ruleIds) => void await client.del(ruleIds),
+    deleteAllRules: async () => {
+      const keys = await client.keys(`${accessRuleRedisKeyPrefix}*`);
+      if (keys.length === 0) return 0;
+      return await client.del(keys);
+    }
+  };
 };
-export const createRedisAccessRulesStorage = (client, logger) => {
-    return {
-        ...createRedisAccessRulesReader(client, logger),
-        ...createRedisAccessRulesWriter(client),
-    };
+const createRedisAccessRulesStorage = (client, logger) => {
+  return {
+    ...createRedisAccessRulesReader(client, logger),
+    ...createRedisAccessRulesWriter(client)
+  };
 };
 const extractAccessRulesFromSearchReply = (searchReply, logger) => {
-    const accessRules = [];
-    searchReply.documents.map(({ id, value: document }) => {
-        const parsedDocument = accessRuleSchema.safeParse(document);
-        if (parsedDocument.success) {
-            accessRules.push(parsedDocument.data);
-        }
-        else {
-            logger.debug(() => ({
-                msg: "Failed to parse access rule from search reply",
-                id: id,
-                error: parsedDocument.error,
-            }));
-        }
-    });
-    return accessRules;
+  const accessRules = [];
+  searchReply.documents.map(({ id, value: document }) => {
+    const parsedDocument = accessRuleSchema.safeParse(document);
+    if (parsedDocument.success) {
+      accessRules.push(parsedDocument.data);
+    } else {
+      logger.debug(() => ({
+        msg: "Failed to parse access rule from search reply",
+        id,
+        error: parsedDocument.error
+      }));
+    }
+  });
+  return accessRules;
+};
+export {
+  createRedisAccessRulesReader,
+  createRedisAccessRulesStorage,
+  createRedisAccessRulesWriter
 };
-//# sourceMappingURL=redisAccessRules.js.map

package/dist/redis/redisAccessRulesIndex.js

@@ -1,86 +1,113 @@
 import crypto from "node:crypto";
 import { SCHEMA_FIELD_TYPE } from "@redis/search";
-import { ScopeMatch } from "#policy/accessPolicyResolver.js";
-import { createRedisIndex } from "#policy/redis/redisIndex.js";
-export const accessRulesRedisIndexName = "index:user-access-rules";
-export const accessRuleRedisKeyPrefix = "uar:";
+import { ScopeMatch } from "../accessPolicyResolver.js";
+import { createRedisIndex } from "./redisIndex.js";
+const accessRulesRedisIndexName = "index:user-access-rules";
+const accessRuleRedisKeyPrefix = "uar:";
 const accessRuleContentHashAlgorithm = "md5";
-const DEFAULT_SEARCH_LIMIT = 10000;
+const DEFAULT_SEARCH_LIMIT = 1e3;
 const accessRulesIndex = {
-    name: accessRulesRedisIndexName,
-    schema: {
-        clientId: {
-            type: SCHEMA_FIELD_TYPE.TAG,
-            INDEXMISSING: true,
-        },
-        numericIpMaskMin: SCHEMA_FIELD_TYPE.NUMERIC,
-        numericIpMaskMax: SCHEMA_FIELD_TYPE.NUMERIC,
-        userId: SCHEMA_FIELD_TYPE.TAG,
-        numericIp: { type: SCHEMA_FIELD_TYPE.NUMERIC, INDEXMISSING: true },
-        ja4Hash: SCHEMA_FIELD_TYPE.TAG,
-        headersHash: SCHEMA_FIELD_TYPE.TAG,
-        userAgentHash: SCHEMA_FIELD_TYPE.TAG,
-    },
-    options: {
-        ON: "HASH",
-        PREFIX: accessRuleRedisKeyPrefix,
+  name: accessRulesRedisIndexName,
+  /**
+   * 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
+   */
+  schema: {
+    clientId: {
+      type: SCHEMA_FIELD_TYPE.TAG,
+      // necessary to make possible use of the ismissing() function on this field in the search
+      INDEXMISSING: true
     },
+    numericIpMaskMin: SCHEMA_FIELD_TYPE.NUMERIC,
+    numericIpMaskMax: SCHEMA_FIELD_TYPE.NUMERIC,
+    userId: SCHEMA_FIELD_TYPE.TAG,
+    numericIp: { type: SCHEMA_FIELD_TYPE.NUMERIC, INDEXMISSING: true },
+    ja4Hash: SCHEMA_FIELD_TYPE.TAG,
+    headersHash: SCHEMA_FIELD_TYPE.TAG,
+    userAgentHash: SCHEMA_FIELD_TYPE.TAG
+  },
+  // the satisfy statement is to guarantee that the keys are right
+  options: {
+    ON: "HASH",
+    PREFIX: [accessRuleRedisKeyPrefix]
+  }
 };
-export const createRedisAccessRulesIndex = async (client) => createRedisIndex(client, accessRulesIndex);
+const createRedisAccessRulesIndex = async (client) => createRedisIndex(client, accessRulesIndex);
 const numericIndexFields = [
-    "numericIp",
-    "numericIpMaskMin",
-    "numericIpMaskMax",
+  "numericIp",
+  "numericIpMaskMin",
+  "numericIpMaskMax"
 ];
 const greedyFieldComparisons = {
-    numericIp: (value) => `( @numericIp:[${value}] | ( @numericIpMaskMin:[-inf ${value}] @numericIpMaskMax:[${value} +inf] ) )`,
+  numericIp: (value) => `( @numericIp:[${value}] | ( @numericIpMaskMin:[-inf ${value}] @numericIpMaskMax:[${value} +inf] ) )`
 };
-export const accessRulesRedisSearchOptions = {
-    DIALECT: 2,
-    LIMIT: {
-        from: 0,
-        size: DEFAULT_SEARCH_LIMIT,
-    },
+const accessRulesRedisSearchOptions = {
+  // #2 is a required option when the 'ismissing()' function is in the query body
+  DIALECT: 2
 };
-export const getRedisAccessRulesQuery = (filter) => {
-    const { policyScope, userScope } = filter;
-    const policyScopeFilter = getPolicyScopeQuery(policyScope, filter.policyScopeMatch);
-    if (userScope && Object.keys(userScope).length > 0) {
-        const userScopeFilter = getUserScopeQuery(userScope, filter.userScopeMatch);
-        return `${policyScopeFilter} ( ${userScopeFilter} )`;
-    }
-    return policyScopeFilter ? policyScopeFilter : "*";
+const accessRulesRedisDeleteOptions = {
+  // #2 is a required option when the 'ismissing()' function is in the query body
+  DIALECT: 2,
+  LIMIT: {
+    from: 0,
+    size: DEFAULT_SEARCH_LIMIT
+  }
+};
+const getRedisAccessRulesQuery = (filter) => {
+  const { policyScope, userScope } = filter;
+  const policyScopeFilter = getPolicyScopeQuery(
+    policyScope,
+    filter.policyScopeMatch
+  );
+  if (userScope && Object.keys(userScope).length > 0) {
+    const userScopeFilter = getUserScopeQuery(userScope, filter.userScopeMatch);
+    return `${policyScopeFilter} ( ${userScopeFilter} )`;
+  }
+  return policyScopeFilter ? policyScopeFilter : "*";
 };
 const getPolicyScopeQuery = (policyScope, scopeMatchType) => {
-    const clientId = policyScope?.clientId;
-    if ("string" === typeof clientId) {
-        return ScopeMatch.Exact === scopeMatchType
-            ? `@clientId:{${clientId}}`
-            : `( @clientId:{${clientId}} | ismissing(@clientId) )`;
-    }
-    return ScopeMatch.Exact === scopeMatchType ? "ismissing(@clientId)" : "";
+  const clientId = policyScope?.clientId;
+  if ("string" === typeof clientId) {
+    return ScopeMatch.Exact === scopeMatchType ? `@clientId:{${clientId}}` : `( @clientId:{${clientId}} | ismissing(@clientId) )`;
+  }
+  return ScopeMatch.Exact === scopeMatchType ? "ismissing(@clientId)" : "";
 };
 const getUserScopeQuery = (userScope, scopeMatchType) => {
-    const scopeEntries = Object.entries(userScope)
-        .filter(([_, value]) => value !== undefined);
-    const scopeJoinType = ScopeMatch.Exact === scopeMatchType ? " " : " | ";
-    return scopeEntries
-        .map(([scopeFieldName, scopeFieldValue]) => getUserScopeFieldQuery(scopeFieldName, scopeFieldValue, scopeMatchType))
-        .join(scopeJoinType);
+  const scopeEntries = Object.entries(userScope).filter(([_, value]) => value !== void 0);
+  const scopeJoinType = ScopeMatch.Exact === scopeMatchType ? " " : " | ";
+  return scopeEntries.map(
+    ([scopeFieldName, scopeFieldValue]) => getUserScopeFieldQuery(scopeFieldName, scopeFieldValue, scopeMatchType)
+  ).join(scopeJoinType);
 };
 const getUserScopeFieldQuery = (fieldName, fieldValue, matchType) => {
-    if (ScopeMatch.Greedy === matchType &&
-        "function" === typeof greedyFieldComparisons[fieldName]) {
-        return greedyFieldComparisons[fieldName](fieldValue);
-    }
-    return numericIndexFields.includes(fieldName)
-        ? `@${fieldName}:[${fieldValue}]`
-        : `@${fieldName}:{${fieldValue}}`;
+  if (ScopeMatch.Greedy === matchType && "function" === typeof greedyFieldComparisons[fieldName]) {
+    return greedyFieldComparisons[fieldName](fieldValue);
+  }
+  return numericIndexFields.includes(fieldName) ? `@${fieldName}:[${fieldValue}]` : `@${fieldName}:{${fieldValue}}`;
+};
+const getRedisAccessRuleKey = (rule) => accessRuleRedisKeyPrefix + crypto.createHash(accessRuleContentHashAlgorithm).update(
+  JSON.stringify(
+    rule,
+    (key, value) => (
+      // JSON.stringify can't handle BigInt itself: throws "Do not know how to serialize a BigInt"
+      "bigint" === typeof value ? value.toString() : value
+    )
+  )
+).digest("hex");
+const getRedisAccessRuleValue = (rule) => Object.fromEntries(
+  Object.entries(rule).map(([key, value]) => [key, String(value)])
+);
+export {
+  accessRuleRedisKeyPrefix,
+  accessRulesRedisDeleteOptions,
+  accessRulesRedisIndexName,
+  accessRulesRedisSearchOptions,
+  createRedisAccessRulesIndex,
+  getRedisAccessRuleKey,
+  getRedisAccessRuleValue,
+  getRedisAccessRulesQuery
 };
-export const getRedisAccessRuleKey = (rule) => accessRuleRedisKeyPrefix +
-    crypto
-        .createHash(accessRuleContentHashAlgorithm)
-        .update(JSON.stringify(rule, (key, value) => "bigint" === typeof value ? value.toString() : value))
-        .digest("hex");
-export const getRedisAccessRuleValue = (rule) => Object.fromEntries(Object.entries(rule).map(([key, value]) => [key, String(value)]));
-//# sourceMappingURL=redisAccessRulesIndex.js.map

package/dist/redis/redisIndex.js

@@ -1,23 +1,22 @@
 import crypto from "node:crypto";
 const redisIndexHashesRecordKey = "_index_hashes";
 const redisIndexHashAlgorithm = "sha256";
-export const createRedisIndex = async (client, index) => {
-    const indexHash = createIndexHash(index);
-    const existingIndexes = await client.ft._LIST();
-    if (existingIndexes.includes(index.name)) {
-        const existingIndexHash = await fetchIndexHash(client, index.name);
-        if (indexHash === existingIndexHash) {
-            return;
-        }
-        await client.ft.dropIndex(index.name);
+const createRedisIndex = async (client, index) => {
+  const indexHash = createIndexHash(index);
+  const existingIndexes = await client.ft._LIST();
+  if (existingIndexes.includes(index.name)) {
+    const existingIndexHash = await fetchIndexHash(client, index.name);
+    if (indexHash === existingIndexHash) {
+      return;
     }
-    await client.ft.create(index.name, index.schema, index.options);
-    await saveIndexHash(client, index.name, indexHash);
+    await client.ft.dropIndex(index.name);
+  }
+  await client.ft.create(index.name, index.schema, index.options);
+  await saveIndexHash(client, index.name, indexHash);
 };
-const createIndexHash = (index) => crypto
-    .createHash(redisIndexHashAlgorithm)
-    .update(JSON.stringify(index))
-    .digest("hex");
+const createIndexHash = (index) => crypto.createHash(redisIndexHashAlgorithm).update(JSON.stringify(index)).digest("hex");
 const fetchIndexHash = async (client, indexName) => client.hGet(redisIndexHashesRecordKey, indexName);
 const saveIndexHash = async (client, indexName, indexHash) => client.hSet(redisIndexHashesRecordKey, indexName, indexHash);
-//# sourceMappingURL=redisIndex.js.map
+export {
+  createRedisIndex
+};

package/dist/util.js

@@ -1,3 +1,5 @@
 import crypto from "node:crypto";
-export const hashUserAgent = (userAgent) => crypto.createHash("sha256").update(userAgent).digest("hex");
-//# sourceMappingURL=util.js.map
+const hashUserAgent = (userAgent) => crypto.createHash("sha256").update(userAgent).digest("hex");
+export {
+  hashUserAgent
+};