@prosopo/user-access-policy 3.5.19 → 3.5.28

package/dist/api/write/insertRules.js

@@ -0,0 +1,102 @@
+import { ApiEndpointResponseStatus } from "@prosopo/api-route";
+import { LogLevel } from "@prosopo/common";
+import { z } from "zod";
+import { policyScopeInput, accessPolicyInput } from "../../ruleInput/policyInput.js";
+import { userScopeInput } from "../../ruleInput/userScopeInput.js";
+class InsertRulesEndpoint {
+  constructor(accessRulesWriter, logger) {
+    this.accessRulesWriter = accessRulesWriter;
+    this.logger = logger;
+  }
+  getRequestArgsSchema() {
+    return z.array(
+      z.object({
+        accessPolicy: accessPolicyInput,
+        policyScopes: z.array(policyScopeInput).optional(),
+        groupId: z.string().optional(),
+        userScopes: z.array(userScopeInput),
+        expiresUnixTimestamp: z.number().optional()
+      })
+    );
+  }
+  async processRequest(args) {
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve({
+          status: 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: ApiEndpointResponseStatus.SUCCESS
+      };
+    }).catch((error) => {
+      if (LogLevel.enum.debug === this.logger.getLogLevel()) {
+        this.logger.error(() => ({
+          err: error,
+          data: { args },
+          msg: "Failed to insert access rules"
+        }));
+      }
+      return {
+        status: 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);
+  }
+}
+export {
+  InsertRulesEndpoint
+};

package/dist/api/write/rehashRules.js

@@ -0,0 +1,57 @@
+import { ApiEndpointResponseStatus } from "@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: ApiEndpointResponseStatus.SUCCESS,
+      data: {}
+    };
+  }
+}
+export {
+  RehashRulesEndpoint
+};

package/dist/cjs/.export.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./ruleInput/.export.cjs");
+const transformRule = require("./transformRule.cjs");
+const rule = require("./rule.cjs");
+const rulesStorage = require("./rulesStorage.cjs");
+const ruleRecord = require("./ruleRecord.cjs");
+const ruleInput = require("./ruleInput/ruleInput.cjs");
+const policyInput = require("./ruleInput/policyInput.cjs");
+const userScopeInput = require("./ruleInput/userScopeInput.cjs");
+exports.makeAccessRuleHash = transformRule.makeAccessRuleHash;
+exports.transformAccessRuleIntoRecord = transformRule.transformAccessRuleIntoRecord;
+exports.transformAccessRuleRecordIntoRule = transformRule.transformAccessRuleRecordIntoRule;
+exports.AccessPolicyType = rule.AccessPolicyType;
+exports.FilterScopeMatch = rulesStorage.FilterScopeMatch;
+exports.getUserScopeRecordFromAccessRuleRecord = ruleRecord.getUserScopeRecordFromAccessRuleRecord;
+exports.userScopeRecordFields = ruleRecord.userScopeRecordFields;
+exports.accessRuleInput = ruleInput.accessRuleInput;
+exports.accessPolicyInput = policyInput.accessPolicyInput;
+exports.policyScopeInput = policyInput.policyScopeInput;
+exports.userScopeInput = userScopeInput.userScopeInput;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./delete/.export.cjs");
+require("./read/.export.cjs");
+require("./write/.export.cjs");
+const ruleApiRoutes = require("./ruleApiRoutes.cjs");
+const rulesApiClient = require("./rulesApiClient.cjs");
+exports.AccessRuleApiRoutes = ruleApiRoutes.AccessRuleApiRoutes;
+exports.accessRuleApiPaths = ruleApiRoutes.accessRuleApiPaths;
+exports.getExpressApiRuleRateLimits = ruleApiRoutes.getExpressApiRuleRateLimits;
+exports.AccessRulesApiClient = rulesApiClient.AccessRulesApiClient;

package/dist/cjs/api/delete/.export.cjs

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

package/dist/cjs/api/{deleteAllRulesEndpoint.cjs → delete/deleteAllRules.cjs}

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const apiRoute = require("@prosopo/api-route");
-const zod = require("zod");
-const deleteAllRulesEndpointSchema = zod.z.object({});
 class DeleteAllRulesEndpoint {
-  constructor(accessRulesStorage) {
+  constructor(accessRulesStorage, logger) {
     this.accessRulesStorage = accessRulesStorage;
+    this.logger = logger;
   }
-  async processRequest(args) {
+  getRequestArgsSchema() {
+  }
+  async processRequest() {
     const deletedCount = await this.accessRulesStorage.deleteAllRules();
+    this.logger.info(() => ({
+      msg: "Endpoint deleted all access rules",
+      data: { deletedCount }
+    }));
     return {
       status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
       data: {
@@ -16,9 +21,5 @@ class DeleteAllRulesEndpoint {
       }
     };
   }
-  getRequestArgsSchema() {
-    return deleteAllRulesEndpointSchema;
-  }
 }
 exports.DeleteAllRulesEndpoint = DeleteAllRulesEndpoint;
-exports.deleteAllRulesEndpointSchema = deleteAllRulesEndpointSchema;

package/dist/cjs/api/delete/deleteRuleGroups.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const apiRoute = require("@prosopo/api-route");
+const zod = require("zod");
+const rulesStorage = require("../../rulesStorage.cjs");
+class DeleteRuleGroupsEndpoint {
+  constructor(accessRulesStorage, logger) {
+    this.accessRulesStorage = accessRulesStorage;
+    this.logger = logger;
+  }
+  getRequestArgsSchema() {
+    return zod.z.array(
+      zod.z.object({
+        clientIds: zod.z.string().array(),
+        groupId: zod.z.string()
+      })
+    );
+  }
+  async processRequest(args) {
+    const foundRuleIdPromises = args.flatMap(
+      (ruleToDelete) => ruleToDelete.clientIds.map(
+        (clientId) => this.accessRulesStorage.findRuleIds({
+          policyScope: {
+            clientId
+          },
+          policyScopeMatch: rulesStorage.FilterScopeMatch.Exact,
+          groupId: ruleToDelete.groupId
+        })
+      )
+    );
+    const foundRuleIds = await Promise.all(foundRuleIdPromises);
+    const ruleIds = foundRuleIds.flat();
+    const uniqueRuleIds = [...new Set(ruleIds)];
+    if (uniqueRuleIds.length > 0) {
+      await this.accessRulesStorage.deleteRules(uniqueRuleIds);
+    }
+    this.logger.info(() => ({
+      msg: "Endpoint deleted rule groups",
+      data: {
+        args,
+        uniqueRuleIds
+      }
+    }));
+    return {
+      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
+      data: {
+        deleted_count: uniqueRuleIds.length
+      }
+    };
+  }
+}
+exports.DeleteRuleGroupsEndpoint = DeleteRuleGroupsEndpoint;

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;