@prosopo/user-access-policy 3.4.0 → 3.5.27

package/dist/cjs/api/delete/deleteRules.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const apiRoute = require("@prosopo/api-route");
+const common = require("@prosopo/common");
+const zod = require("zod");
+const ruleInput = require("../../ruleInput/ruleInput.cjs");
+class DeleteRulesEndpoint {
+  constructor(accessRulesStorage, logger) {
+    this.accessRulesStorage = accessRulesStorage;
+    this.logger = logger;
+  }
+  getRequestArgsSchema() {
+    return zod.z.array(ruleInput.accessRulesFilterInput);
+  }
+  async processRequest(args) {
+    let deletedCount = 0;
+    for (const rulesFilterInput of args) {
+      const ruleFilters = ruleInput.getAccessRuleFiltersFromInput(rulesFilterInput);
+      await common.executeBatchesSequentially(ruleFilters, async (ruleFilter) => {
+        const ruleIds = await this.accessRulesStorage.findRuleIds(ruleFilter);
+        const uniqueRuleIds = [...new Set(ruleIds)];
+        if (uniqueRuleIds.length > 0) {
+          await this.accessRulesStorage.deleteRules(uniqueRuleIds);
+          deletedCount += uniqueRuleIds.length;
+          this.logger.info(() => ({
+            msg: "Endpoint deleted rules",
+            data: {
+              rulesFilterInput,
+              uniqueRuleIds
+            }
+          }));
+        }
+      });
+    }
+    return {
+      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
+      data: {
+        deleted_count: deletedCount
+      }
+    };
+  }
+}
+exports.DeleteRulesEndpoint = DeleteRulesEndpoint;

package/dist/cjs/api/read/.export.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/api/read/fetchRules.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const apiRoute = require("@prosopo/api-route");
+const zod = require("zod");
+const ruleInput = require("../../ruleInput/ruleInput.cjs");
+const fetchRulesResponse = zod.z.object({
+  ruleEntries: ruleInput.ruleEntryInput.array()
+});
+class FetchRulesEndpoint {
+  constructor(accessRulesStorage, logger) {
+    this.accessRulesStorage = accessRulesStorage;
+    this.logger = logger;
+  }
+  getRequestArgsSchema() {
+    return zod.z.object({
+      ids: zod.z.string().array()
+    });
+  }
+  async processRequest(args) {
+    const ruleEntries = await this.accessRulesStorage.fetchRules(args.ids);
+    this.logger.info(() => ({
+      msg: "Endpoint fetched rules",
+      data: {
+        requestedCount: args.ids.length,
+        foundCount: ruleEntries.length
+      }
+    }));
+    this.logger.debug(() => ({
+      msg: "Fetched rule details",
+      data: {
+        ruleEntries
+      }
+    }));
+    return {
+      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
+      data: {
+        ruleEntries
+      }
+    };
+  }
+}
+exports.FetchRulesEndpoint = FetchRulesEndpoint;
+exports.fetchRulesResponse = fetchRulesResponse;

package/dist/cjs/api/read/findRuleIds.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const apiRoute = require("@prosopo/api-route");
+const common = require("@prosopo/common");
+const zod = require("zod");
+const ruleInput = require("../../ruleInput/ruleInput.cjs");
+const ruleIdsResponse = zod.z.object({
+  ruleIds: zod.z.string().array()
+});
+class FindRuleIdsEndpoint {
+  constructor(accessRulesStorage, logger) {
+    this.accessRulesStorage = accessRulesStorage;
+    this.logger = logger;
+  }
+  getRequestArgsSchema() {
+    return zod.z.array(ruleInput.accessRulesFilterInput);
+  }
+  async processRequest(args) {
+    const ruleIdBatches = await common.executeBatchesSequentially(
+      args,
+      async (rulesFilterInput) => {
+        const ruleFilters = ruleInput.getAccessRuleFiltersFromInput(rulesFilterInput);
+        const ruleIds2 = await common.executeBatchesSequentially(
+          ruleFilters,
+          (ruleFilter) => this.accessRulesStorage.findRuleIds(ruleFilter)
+        );
+        return ruleIds2.flat();
+      }
+    );
+    const ruleIds = ruleIdBatches.flat();
+    const uniqueRuleIds = [...new Set(ruleIds)];
+    this.logger.info(() => ({
+      msg: "Endpoint found rules",
+      data: {
+        totalFoundCount: ruleIds.length,
+        uniqueFoundCount: uniqueRuleIds.length,
+        searchFilters: args,
+        foundIds: uniqueRuleIds
+      }
+    }));
+    return {
+      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
+      data: {
+        ruleIds: uniqueRuleIds
+      }
+    };
+  }
+}
+exports.FindRuleIdsEndpoint = FindRuleIdsEndpoint;
+exports.ruleIdsResponse = ruleIdsResponse;

package/dist/cjs/api/read/getMissingIds.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const apiRoute = require("@prosopo/api-route");
+const zod = require("zod");
+const missingIdsResponse = zod.z.object({
+  ids: zod.z.string().array()
+});
+class GetMissingIdsEndpoint {
+  constructor(accessRulesStorage, logger) {
+    this.accessRulesStorage = accessRulesStorage;
+    this.logger = logger;
+  }
+  getRequestArgsSchema() {
+    return zod.z.string().array();
+  }
+  async processRequest(args) {
+    const missingIds = await this.accessRulesStorage.getMissingRuleIds(args);
+    this.logger.info(() => ({
+      msg: "Endpoint checked missing ids",
+      data: {
+        idsToCheck: args.length,
+        missingIds: missingIds.length
+      }
+    }));
+    this.logger.debug(() => ({
+      msg: "Missing id details",
+      data: {
+        idsToCheck: args,
+        missingIds
+      }
+    }));
+    return {
+      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
+      data: {
+        ids: missingIds
+      }
+    };
+  }
+}
+exports.GetMissingIdsEndpoint = GetMissingIdsEndpoint;
+exports.missingIdsResponse = missingIdsResponse;

package/dist/cjs/api/ruleApiRoutes.cjs

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fetchRules = require("./read/fetchRules.cjs");
+const findRuleIds = require("./read/findRuleIds.cjs");
+const getMissingIds = require("./read/getMissingIds.cjs");
+const rehashRules = require("./write/rehashRules.cjs");
+const deleteAllRules = require("./delete/deleteAllRules.cjs");
+const deleteRuleGroups = require("./delete/deleteRuleGroups.cjs");
+const deleteRules = require("./delete/deleteRules.cjs");
+const insertRules = require("./write/insertRules.cjs");
+var accessRuleApiPaths = /* @__PURE__ */ ((accessRuleApiPaths2) => {
+  accessRuleApiPaths2["DELETE_ALL"] = "/v1/prosopo/user-access-policy/rules/delete-all";
+  accessRuleApiPaths2["DELETE_GROUPS"] = "/v1/prosopo/user-access-policy/rules/delete-groups";
+  accessRuleApiPaths2["DELETE_MANY"] = "/v1/prosopo/user-access-policy/rules/delete-many";
+  accessRuleApiPaths2["FETCH_MANY"] = "/v1/prosopo/user-access-policy/rules/fetch-many";
+  accessRuleApiPaths2["FIND_IDS"] = "/v1/prosopo/user-access-policy/rules/find-ids";
+  accessRuleApiPaths2["GET_MISSING_IDS"] = "/v1/prosopo/user-access-policy/rules/get-missing-ids";
+  accessRuleApiPaths2["INSERT_MANY"] = "/v1/prosopo/user-access-policy/rules/insert-many";
+  accessRuleApiPaths2["REHASH_ALL"] = "/v1/prosopo/user-access-policy/rules/rehash-all";
+  return accessRuleApiPaths2;
+})(accessRuleApiPaths || {});
+class AccessRuleApiRoutes {
+  constructor(accessRulesStorage, logger) {
+    this.accessRulesStorage = accessRulesStorage;
+    this.logger = logger;
+  }
+  getRoutes() {
+    return {
+      ...this.makeDeleteEndpoints(),
+      ...this.makeReadEndpoints(),
+      ...this.makeWriteEndpoints()
+    };
+  }
+  makeDeleteEndpoints() {
+    return {
+      [
+        "/v1/prosopo/user-access-policy/rules/delete-all"
+        /* DELETE_ALL */
+      ]: new deleteAllRules.DeleteAllRulesEndpoint(
+        this.accessRulesStorage,
+        this.logger
+      ),
+      [
+        "/v1/prosopo/user-access-policy/rules/delete-groups"
+        /* DELETE_GROUPS */
+      ]: new deleteRuleGroups.DeleteRuleGroupsEndpoint(
+        this.accessRulesStorage,
+        this.logger
+      ),
+      [
+        "/v1/prosopo/user-access-policy/rules/delete-many"
+        /* DELETE_MANY */
+      ]: new deleteRules.DeleteRulesEndpoint(
+        this.accessRulesStorage,
+        this.logger
+      )
+    };
+  }
+  makeReadEndpoints() {
+    return {
+      [
+        "/v1/prosopo/user-access-policy/rules/fetch-many"
+        /* FETCH_MANY */
+      ]: new fetchRules.FetchRulesEndpoint(
+        this.accessRulesStorage,
+        this.logger
+      ),
+      [
+        "/v1/prosopo/user-access-policy/rules/find-ids"
+        /* FIND_IDS */
+      ]: new findRuleIds.FindRuleIdsEndpoint(
+        this.accessRulesStorage,
+        this.logger
+      ),
+      [
+        "/v1/prosopo/user-access-policy/rules/get-missing-ids"
+        /* GET_MISSING_IDS */
+      ]: new getMissingIds.GetMissingIdsEndpoint(
+        this.accessRulesStorage,
+        this.logger
+      )
+    };
+  }
+  makeWriteEndpoints() {
+    return {
+      [
+        "/v1/prosopo/user-access-policy/rules/insert-many"
+        /* INSERT_MANY */
+      ]: new insertRules.InsertRulesEndpoint(
+        this.accessRulesStorage,
+        this.logger
+      ),
+      [
+        "/v1/prosopo/user-access-policy/rules/rehash-all"
+        /* REHASH_ALL */
+      ]: new rehashRules.RehashRulesEndpoint(
+        this.accessRulesStorage,
+        this.logger
+      )
+    };
+  }
+}
+const getExpressApiRuleRateLimits = () => {
+  const defaults = {
+    limit: 5,
+    windowSeconds: 10
+  };
+  const defaultWindowMs = defaults.windowSeconds * 1e3;
+  const rateLimitEntries = Object.entries(accessRuleApiPaths).map(
+    ([endpointName, endpointPath]) => [
+      endpointPath,
+      {
+        windowMs: getIntEnvironmentVariable(
+          `PROSOPO_USER_ACCESS_POLICY_RULE_${endpointName}_WINDOW`
+        ) || defaultWindowMs,
+        limit: getIntEnvironmentVariable(
+          `PROSOPO_USER_ACCESS_POLICY_RULE_${endpointName}_LIMIT`
+        ) || defaults.limit
+      }
+    ]
+  );
+  return Object.fromEntries(rateLimitEntries);
+};
+const getIntEnvironmentVariable = (variableName) => {
+  const variableValue = process.env[variableName];
+  const numericValue = variableValue ? Number.parseInt(variableValue) : Number.NaN;
+  return Number.isInteger(numericValue) ? numericValue : void 0;
+};
+exports.AccessRuleApiRoutes = AccessRuleApiRoutes;
+exports.accessRuleApiPaths = accessRuleApiPaths;
+exports.getExpressApiRuleRateLimits = getExpressApiRuleRateLimits;

package/dist/cjs/api/rulesApiClient.cjs

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const api = require("@prosopo/api");
+const fetchRules = require("./read/fetchRules.cjs");
+const findRuleIds = require("./read/findRuleIds.cjs");
+const getMissingIds = require("./read/getMissingIds.cjs");
+const ruleApiRoutes = require("./ruleApiRoutes.cjs");
+class AccessRulesApiClient extends api.ApiClient {
+  //// delete
+  deleteMany(filters, timestamp, signature) {
+    return this.post(
+      ruleApiRoutes.accessRuleApiPaths.DELETE_MANY,
+      filters,
+      this.getAuthHeaders(timestamp, signature)
+    );
+  }
+  deleteGroups(siteGroups, timestamp, signature) {
+    return this.post(
+      ruleApiRoutes.accessRuleApiPaths.DELETE_GROUPS,
+      siteGroups,
+      this.getAuthHeaders(timestamp, signature)
+    );
+  }
+  deleteAll(timestamp, signature) {
+    return this.post(
+      ruleApiRoutes.accessRuleApiPaths.DELETE_ALL,
+      {},
+      this.getAuthHeaders(timestamp, signature)
+    );
+  }
+  //// read
+  async getMissingIds(idsToCheck, timestamp, signature) {
+    const endpointResponse = await this.post(
+      ruleApiRoutes.accessRuleApiPaths.GET_MISSING_IDS,
+      idsToCheck,
+      this.getAuthHeaders(timestamp, signature)
+    );
+    const parsedData = getMissingIds.missingIdsResponse.safeParse(endpointResponse.data);
+    return {
+      ...endpointResponse,
+      data: parsedData.success ? parsedData.data : void 0
+    };
+  }
+  async fetchMany(fetchOptions, timestamp, signature) {
+    const endpointResponse = await this.post(
+      ruleApiRoutes.accessRuleApiPaths.FETCH_MANY,
+      fetchOptions,
+      this.getAuthHeaders(timestamp, signature)
+    );
+    const parsedData = fetchRules.fetchRulesResponse.safeParse(endpointResponse.data);
+    return {
+      ...endpointResponse,
+      data: parsedData.success ? parsedData.data : void 0
+    };
+  }
+  async findIds(filters, timestamp, signature) {
+    const endpointResponse = await this.post(
+      ruleApiRoutes.accessRuleApiPaths.FIND_IDS,
+      filters,
+      this.getAuthHeaders(timestamp, signature)
+    );
+    const parsedData = findRuleIds.ruleIdsResponse.safeParse(endpointResponse.data);
+    return {
+      ...endpointResponse,
+      data: parsedData.success ? parsedData.data : void 0
+    };
+  }
+  //// write
+  async rehashAll(timestamp, signature) {
+    return this.post(
+      ruleApiRoutes.accessRuleApiPaths.REHASH_ALL,
+      {},
+      this.getAuthHeaders(timestamp, signature)
+    );
+  }
+  insertMany(ruleGroups, timestamp, signature) {
+    return this.post(
+      ruleApiRoutes.accessRuleApiPaths.INSERT_MANY,
+      ruleGroups,
+      this.getAuthHeaders(timestamp, signature)
+    );
+  }
+  getAuthHeaders(timestamp, signature) {
+    return {
+      headers: {
+        "Prosopo-Site-Key": this.account,
+        timestamp,
+        signature
+      }
+    };
+  }
+}
+exports.AccessRulesApiClient = AccessRulesApiClient;

package/dist/cjs/api/write/.export.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/api/write/insertRules.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const apiRoute = require("@prosopo/api-route");
+const common = require("@prosopo/common");
+const zod = require("zod");
+const policyInput = require("../../ruleInput/policyInput.cjs");
+const userScopeInput = require("../../ruleInput/userScopeInput.cjs");
+class InsertRulesEndpoint {
+  constructor(accessRulesWriter, logger) {
+    this.accessRulesWriter = accessRulesWriter;
+    this.logger = logger;
+  }
+  getRequestArgsSchema() {
+    return zod.z.array(
+      zod.z.object({
+        accessPolicy: policyInput.accessPolicyInput,
+        policyScopes: zod.z.array(policyInput.policyScopeInput).optional(),
+        groupId: zod.z.string().optional(),
+        userScopes: zod.z.array(userScopeInput.userScopeInput),
+        expiresUnixTimestamp: zod.z.number().optional()
+      })
+    );
+  }
+  async processRequest(args) {
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve({
+          status: apiRoute.ApiEndpointResponseStatus.PROCESSING
+        });
+      }, 5e3);
+    });
+    const userScopesCount = args.reduce(
+      (userScopesCount2, group) => userScopesCount2 + group.userScopes.length,
+      0
+    );
+    const createRulesPromise = this.createRuleGroups(args).then((insertedIds) => {
+      this.logger.info(() => ({
+        msg: "Endpoint inserted access rules",
+        data: {
+          userScopesCount,
+          insertedCount: insertedIds.length,
+          uniqueIdsCount: new Set(insertedIds).size
+        }
+      }));
+      this.logger.debug(() => ({
+        msg: "Inserted access rules details",
+        data: {
+          insertedIds,
+          input: args
+        }
+      }));
+      return {
+        status: apiRoute.ApiEndpointResponseStatus.SUCCESS
+      };
+    }).catch((error) => {
+      if (common.LogLevel.enum.debug === this.logger.getLogLevel()) {
+        this.logger.error(() => ({
+          err: error,
+          data: { args },
+          msg: "Failed to insert access rules"
+        }));
+      }
+      return {
+        status: apiRoute.ApiEndpointResponseStatus.FAIL
+      };
+    });
+    return Promise.race([timeoutPromise, createRulesPromise]);
+  }
+  async createRuleGroups(groups) {
+    const ruleIdPromises = groups.map((group) => this.createRulesGroup(group));
+    const ruleIdSets = await Promise.all(ruleIdPromises);
+    return ruleIdSets.flat();
+  }
+  async createRulesGroup(group) {
+    const ruleEntries = [];
+    const policyScopes = group.policyScopes || [];
+    for (const userScope of group.userScopes) {
+      const ruleBase = {
+        ...group.accessPolicy,
+        ...userScope,
+        ...group.groupId ? { groupId: group.groupId } : {}
+      };
+      if (policyScopes.length > 0) {
+        for (const policyScope of policyScopes) {
+          ruleEntries.push({
+            rule: {
+              ...ruleBase,
+              ...policyScope
+            }
+          });
+        }
+      } else {
+        ruleEntries.push({
+          rule: ruleBase,
+          expiresUnixTimestamp: group.expiresUnixTimestamp
+        });
+      }
+    }
+    return this.accessRulesWriter.insertRules(ruleEntries);
+  }
+}
+exports.InsertRulesEndpoint = InsertRulesEndpoint;

package/dist/cjs/api/write/rehashRules.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const apiRoute = require("@prosopo/api-route");
+class RehashRulesEndpoint {
+  constructor(accessRulesStorage, logger) {
+    this.accessRulesStorage = accessRulesStorage;
+    this.logger = logger;
+  }
+  getRequestArgsSchema() {
+  }
+  async processRequest() {
+    await this.accessRulesStorage.fetchAllRuleIds(async (ruleIds) => {
+      this.logger.info(() => ({
+        msg: "Fetched rule ids batch",
+        data: {
+          count: ruleIds.length,
+          ruleIds
+        }
+      }));
+      const ruleEntries = await this.accessRulesStorage.fetchRules(ruleIds);
+      this.logger.info(() => ({
+        msg: "Fetched rules",
+        data: {
+          count: ruleEntries.length
+        }
+      }));
+      if (ruleEntries.length !== ruleIds.length) {
+        this.logger.warn(() => ({
+          msg: "Fetched rules count is not equal to the requested count",
+          data: {
+            fetchedCount: ruleEntries.length,
+            requestedCount: ruleIds.length
+          }
+        }));
+      }
+      await this.accessRulesStorage.deleteRules(ruleIds);
+      this.logger.info(() => ({
+        msg: "Deleted rules",
+        data: {
+          count: ruleIds.length
+        }
+      }));
+      await this.accessRulesStorage.insertRules(ruleEntries);
+      this.logger.info(() => ({
+        msg: "Inserted rules",
+        data: {
+          count: ruleEntries.length
+        }
+      }));
+    });
+    return {
+      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
+      data: {}
+    };
+  }
+}
+exports.RehashRulesEndpoint = RehashRulesEndpoint;

package/dist/cjs/index.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const accessPolicy = require("./accessPolicy.cjs");
 const accessPolicyResolver = require("./accessPolicyResolver.cjs");
+const accessRules = require("./accessRules.cjs");
 const accessRuleApiRoutes = require("./api/accessRuleApiRoutes.cjs");
 const deleteAllRulesEndpoint = require("./api/deleteAllRulesEndpoint.cjs");
 const deleteRulesEndpoint = require("./api/deleteRulesEndpoint.cjs");
@@ -17,6 +18,7 @@ exports.accessRuleSchemaExtended = accessPolicy.accessRuleSchemaExtended;
 exports.policyScopeSchema = accessPolicy.policyScopeSchema;
 exports.userScopeInputSchema = accessPolicy.userScopeInputSchema;
 exports.ScopeMatch = accessPolicyResolver.ScopeMatch;
+exports.accessRuleSchema = accessRules.accessRuleSchema;
 exports.accessRuleApiPaths = accessRuleApiRoutes.accessRuleApiPaths;
 exports.getExpressApiRuleRateLimits = accessRuleApiRoutes.getExpressApiRuleRateLimits;
 exports.deleteAllRulesEndpointSchema = deleteAllRulesEndpoint.deleteAllRulesEndpointSchema;

package/dist/cjs/mongoose/.export.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const mongooseRuleSchema = require("./mongooseRuleSchema.cjs");
+exports.accessRuleMongooseSchema = mongooseRuleSchema.accessRuleMongooseSchema;

package/dist/cjs/mongoose/mongooseRuleSchema.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const userAttributesSchema = {
+  userId: { type: String, required: false },
+  ja4Hash: { type: String, required: false },
+  userAgent: { type: String, required: false },
+  headersHash: { type: String, required: false }
+};
+const userIpSchema = {
+  ip: { type: String, required: false },
+  ipMask: { type: String, required: false }
+};
+const userScopeSchema = {
+  ...userAttributesSchema,
+  ...userIpSchema
+};
+const policyScopeSchema = {
+  clientId: { type: String, required: false }
+};
+const accessPolicySchema = {
+  type: { type: String, required: true },
+  captchaType: { type: String, required: false },
+  description: { type: String, required: false },
+  solvedImagesCount: { type: Number, required: false },
+  imageThreshold: { type: Number, required: false },
+  powDifficulty: { type: Number, required: false },
+  unsolvedImagesCount: { type: Number, required: false },
+  frictionlessScore: { type: Number, required: false }
+};
+const accessRuleMongooseSchema = {
+  ...accessPolicySchema,
+  ...policyScopeSchema,
+  ...userScopeSchema,
+  ruleGroupId: { type: String, required: false }
+};
+exports.accessRuleMongooseSchema = accessRuleMongooseSchema;

package/dist/cjs/redis/.export.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const redisRulesStorage = require("./redisRulesStorage.cjs");
+const redisRuleIndex = require("./redisRuleIndex.cjs");
+exports.createRedisAccessRulesStorage = redisRulesStorage.createRedisAccessRulesStorage;
+exports.accessRulesRedisIndex = redisRuleIndex.accessRulesRedisIndex;