@prosopo/user-access-policy 3.3.0 → 3.3.2

package/dist/api/insertRulesEndpoint.js

@@ -1,62 +1,62 @@
-import { ApiEndpointResponseStatus, } from "@prosopo/api-route";
-import { LogLevel, getLogger } from "@prosopo/common";
+import { ApiEndpointResponseStatus } from "@prosopo/api-route";
+import { getLogger, LogLevel } from "@prosopo/common";
 import { z } from "zod";
-import { accessPolicySchema, policyScopeSchema, userScopeInputSchema, } from "#policy/accessPolicy.js";
-export const insertRulesEndpointSchema = z.object({
-    accessPolicy: accessPolicySchema,
-    policyScope: policyScopeSchema.optional(),
-    userScopes: z.array(userScopeInputSchema),
-    expirationTimestamp: z
-        .number()
-        .optional()
-        .transform((val) => (val !== undefined ? Math.floor(val) : val)),
+import { userScopeInputSchema, policyScopeSchema, accessPolicySchema } from "../accessPolicy.js";
+const insertRulesEndpointSchema = z.object({
+  accessPolicy: accessPolicySchema,
+  policyScope: policyScopeSchema.optional(),
+  userScopes: z.array(userScopeInputSchema),
+  expirationTimestamp: z.number().optional().transform((val) => val !== void 0 ? Math.floor(val) : val)
 });
-export class InsertRulesEndpoint {
-    constructor(accessRulesWriter) {
-        this.accessRulesWriter = accessRulesWriter;
-    }
-    async processRequest(args, logger) {
-        logger = logger || getLogger(LogLevel.enum.info, "InsertRulesEndpoint");
-        const timeoutPromise = new Promise((resolve) => {
-            setTimeout(() => {
-                resolve({
-                    status: ApiEndpointResponseStatus.PROCESSING,
-                });
-            }, 5000);
-        });
-        const createRulesPromise = this.createRules(args)
-            .then(() => ({
-            status: ApiEndpointResponseStatus.SUCCESS,
-        }))
-            .catch((error) => {
-            if (logger?.getLogLevel() === LogLevel.enum.debug) {
-                logger.error(() => ({
-                    err: error,
-                    data: { args },
-                    msg: "Failed to insert access rules",
-                }));
-            }
-            return {
-                status: ApiEndpointResponseStatus.FAIL,
-            };
+class InsertRulesEndpoint {
+  constructor(accessRulesWriter) {
+    this.accessRulesWriter = accessRulesWriter;
+  }
+  async processRequest(args, logger) {
+    logger = logger || getLogger(LogLevel.enum.info, "InsertRulesEndpoint");
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve({
+          status: ApiEndpointResponseStatus.PROCESSING
         });
-        return Promise.race([timeoutPromise, createRulesPromise]);
-    }
-    getRequestArgsSchema() {
-        return insertRulesEndpointSchema;
-    }
-    async createRules(args) {
-        const policyScope = args.policyScope || {};
-        const createPromises = [];
-        for (const userScope of args.userScopes) {
-            const rule = {
-                ...args.accessPolicy,
-                ...policyScope,
-                ...userScope,
-            };
-            createPromises.push(this.accessRulesWriter.insertRule(rule, args.expirationTimestamp));
-        }
-        return Promise.all(createPromises);
+      }, 5e3);
+    });
+    const createRulesPromise = this.createRules(args).then(() => ({
+      status: ApiEndpointResponseStatus.SUCCESS
+    })).catch((error) => {
+      if (logger?.getLogLevel() === LogLevel.enum.debug) {
+        logger.error(() => ({
+          err: error,
+          data: { args },
+          msg: "Failed to insert access rules"
+        }));
+      }
+      return {
+        status: ApiEndpointResponseStatus.FAIL
+      };
+    });
+    return Promise.race([timeoutPromise, createRulesPromise]);
+  }
+  getRequestArgsSchema() {
+    return insertRulesEndpointSchema;
+  }
+  async createRules(args) {
+    const policyScope = args.policyScope || {};
+    const createPromises = [];
+    for (const userScope of args.userScopes) {
+      const rule = {
+        ...args.accessPolicy,
+        ...policyScope,
+        ...userScope
+      };
+      createPromises.push(
+        this.accessRulesWriter.insertRule(rule, args.expirationTimestamp)
+      );
     }
+    return Promise.all(createPromises);
+  }
 }
-//# sourceMappingURL=insertRulesEndpoint.js.map
+export {
+  InsertRulesEndpoint,
+  insertRulesEndpointSchema
+};

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,119 +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, skipEmptyUserScopes = true) => {
-            const query = getRedisAccessRulesQuery(filter);
-            if (skipEmptyUserScopes && query === "ismissing(@clientId)") {
-                return [];
+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 }
+              )
             }
-            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: filter,
-                                searchReply: searchReply,
-                                query: 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}*`);
-            if (keys.length === 0)
-                return 0;
-            return await client.del(keys);
-        },
-    };
+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,89 +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 = 1000;
+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,
+const accessRulesRedisSearchOptions = {
+  // #2 is a required option when the 'ismissing()' function is in the query body
+  DIALECT: 2
 };
-export const accessRulesRedisDeleteOptions = {
-    DIALECT: 2,
-    LIMIT: {
-        from: 0,
-        size: DEFAULT_SEARCH_LIMIT,
-    },
+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
+  }
 };
-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 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
+};