@prosopo/provider 3.2.0 → 3.2.2

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @prosopo/provider
 
+## 3.2.2
+### Patch Changes
+
+- 9e4e7ca: better key logging
+
+## 3.2.1
+### Patch Changes
+
+- 2f0c830: Remove node-fetch
+- 52dbf21: bumping deps
+- 3573f0b: fix npm scripts bundle command
+- 3573f0b: build using vite, typecheck using tsc
+- efd8102: Add tests for unwrap error helper
+- 63519d7: Tests
+- f29fc7e: Refining API error handling. Adding more language strings
+- 3573f0b: standardise all vite based npm scripts for bundling
+- 2d0dd8a: Integration tests for UAPs
+- Updated dependencies [52dbf21]
+- Updated dependencies [93d5e50]
+- Updated dependencies [3573f0b]
+- Updated dependencies [8a64429]
+- Updated dependencies [3573f0b]
+- Updated dependencies [efd8102]
+- Updated dependencies [93d5e50]
+- Updated dependencies [63519d7]
+- Updated dependencies [f29fc7e]
+- Updated dependencies [3573f0b]
+- Updated dependencies [2d0dd8a]
+- Updated dependencies [6d604ad]
+  - @prosopo/util@3.0.3
+  - @prosopo/util-crypto@13.5.2
+  - @prosopo/types-env@2.7.14
+  - @prosopo/keyring@2.8.7
+  - @prosopo/types@3.0.4
+  - @prosopo/api-express-router@3.0.4
+  - @prosopo/user-access-policy@3.3.1
+  - @prosopo/types-database@3.0.10
+  - @prosopo/api-route@2.6.8
+  - @prosopo/database@3.0.10
+  - @prosopo/datasets@3.0.10
+  - @prosopo/common@3.1.0
+  - @prosopo/env@3.1.1
+  - @prosopo/config@3.1.1
+
 ## 3.2.0
 ### Minor Changes
 

package/dist/api/admin/apiAdminRoutesProvider.js

@@ -3,25 +3,30 @@ import { ApiRegisterSiteKeyEndpoint } from "./apiRegisterSiteKeyEndpoint.js";
 import { ApiRemoveDetectorKeyEndpoint } from "./apiRemoveDetectorKeyEndpoint.js";
 import { ApiUpdateDetectorKeyEndpoint } from "./apiUpdateDetectorKeyEndpoint.js";
 class ApiAdminRoutesProvider {
-    constructor(tasks) {
-        this.tasks = tasks;
-    }
-    getRoutes() {
-        return [
-            {
-                path: AdminApiPaths.SiteKeyRegister,
-                endpoint: new ApiRegisterSiteKeyEndpoint(this.tasks.clientTaskManager),
-            },
-            {
-                path: AdminApiPaths.UpdateDetectorKey,
-                endpoint: new ApiUpdateDetectorKeyEndpoint(this.tasks.clientTaskManager),
-            },
-            {
-                path: AdminApiPaths.RemoveDetectorKey,
-                endpoint: new ApiRemoveDetectorKeyEndpoint(this.tasks.clientTaskManager),
-            },
-        ];
-    }
+  constructor(tasks) {
+    this.tasks = tasks;
+  }
+  getRoutes() {
+    return [
+      {
+        path: AdminApiPaths.SiteKeyRegister,
+        endpoint: new ApiRegisterSiteKeyEndpoint(this.tasks.clientTaskManager)
+      },
+      {
+        path: AdminApiPaths.UpdateDetectorKey,
+        endpoint: new ApiUpdateDetectorKeyEndpoint(
+          this.tasks.clientTaskManager
+        )
+      },
+      {
+        path: AdminApiPaths.RemoveDetectorKey,
+        endpoint: new ApiRemoveDetectorKeyEndpoint(
+          this.tasks.clientTaskManager
+        )
+      }
+    ];
+  }
 }
-export { ApiAdminRoutesProvider };
-//# sourceMappingURL=apiAdminRoutesProvider.js.map
+export {
+  ApiAdminRoutesProvider
+};

package/dist/api/admin/apiRegisterSiteKeyEndpoint.js

@@ -1,24 +1,25 @@
-import { ApiEndpointResponseStatus, } from "@prosopo/api-route";
+import { ApiEndpointResponseStatus } from "@prosopo/api-route";
 import { getLogger } from "@prosopo/common";
 import { ClientSettingsSchema, RegisterSitekeyBody } from "@prosopo/types";
 class ApiRegisterSiteKeyEndpoint {
-    constructor(clientTaskManager) {
-        this.clientTaskManager = clientTaskManager;
-    }
-    async processRequest(args, logger) {
-        const { siteKey, tier, settings } = args;
-        logger = logger || getLogger("info", import.meta.url);
-        const temp = settings || ClientSettingsSchema.parse({});
-        logger.info(() => ({ data: { siteKey }, msg: "`Registering site key" }));
-        await this.clientTaskManager.registerSiteKey(siteKey, tier, temp);
-        logger.info(() => ({ msg: "Site key registered" }));
-        return {
-            status: ApiEndpointResponseStatus.SUCCESS,
-        };
-    }
-    getRequestArgsSchema() {
-        return RegisterSitekeyBody;
-    }
+  constructor(clientTaskManager) {
+    this.clientTaskManager = clientTaskManager;
+  }
+  async processRequest(args, logger) {
+    const { siteKey, tier, settings } = args;
+    logger = logger || getLogger("info", import.meta.url);
+    const temp = settings || ClientSettingsSchema.parse({});
+    logger.info(() => ({ data: { siteKey }, msg: "`Registering site key" }));
+    await this.clientTaskManager.registerSiteKey(siteKey, tier, temp);
+    logger.info(() => ({ msg: "Site key registered" }));
+    return {
+      status: ApiEndpointResponseStatus.SUCCESS
+    };
+  }
+  getRequestArgsSchema() {
+    return RegisterSitekeyBody;
+  }
 }
-export { ApiRegisterSiteKeyEndpoint };
-//# sourceMappingURL=apiRegisterSiteKeyEndpoint.js.map
+export {
+  ApiRegisterSiteKeyEndpoint
+};

package/dist/api/admin/apiRemoveDetectorKeyEndpoint.js

@@ -1,32 +1,32 @@
-import { ApiEndpointResponseStatus, } from "@prosopo/api-route";
+import { ApiEndpointResponseStatus } from "@prosopo/api-route";
 import { getLogger } from "@prosopo/common";
 import { UpdateDetectorKeyBody } from "@prosopo/types";
 class ApiRemoveDetectorKeyEndpoint {
-    constructor(clientTaskManager) {
-        this.clientTaskManager = clientTaskManager;
-    }
-    async processRequest(args, logger) {
-        logger = logger || getLogger("info", import.meta.url);
-        try {
-            const { detectorKey } = args;
-            logger = logger || getLogger("info", import.meta.url);
-            logger.info(() => ({ msg: "Removing detector key" }));
-            await this.clientTaskManager.removeDetectorKey(detectorKey);
-            return {
-                status: ApiEndpointResponseStatus.SUCCESS,
-            };
-        }
-        catch (error) {
-            logger.error(() => ({ err: error, msg: "Error updating detector key" }));
-            return {
-                status: ApiEndpointResponseStatus.FAIL,
-                error: error.message,
-            };
-        }
-    }
-    getRequestArgsSchema() {
-        return UpdateDetectorKeyBody;
+  constructor(clientTaskManager) {
+    this.clientTaskManager = clientTaskManager;
+  }
+  async processRequest(args, logger) {
+    logger = logger || getLogger("info", import.meta.url);
+    try {
+      const { detectorKey } = args;
+      logger = logger || getLogger("info", import.meta.url);
+      logger.info(() => ({ msg: "Removing detector key" }));
+      await this.clientTaskManager.removeDetectorKey(detectorKey);
+      return {
+        status: ApiEndpointResponseStatus.SUCCESS
+      };
+    } catch (error) {
+      logger.error(() => ({ err: error, msg: "Error updating detector key" }));
+      return {
+        status: ApiEndpointResponseStatus.FAIL,
+        error: error.message
+      };
     }
+  }
+  getRequestArgsSchema() {
+    return UpdateDetectorKeyBody;
+  }
 }
-export { ApiRemoveDetectorKeyEndpoint };
-//# sourceMappingURL=apiRemoveDetectorKeyEndpoint.js.map
+export {
+  ApiRemoveDetectorKeyEndpoint
+};

package/dist/api/admin/apiUpdateDetectorKeyEndpoint.js

@@ -1,39 +1,39 @@
-import { ApiEndpointResponseStatus, } from "@prosopo/api-route";
+import { ApiEndpointResponseStatus } from "@prosopo/api-route";
 import { getLogger } from "@prosopo/common";
 import { UpdateDetectorKeyBody } from "@prosopo/types";
 class ApiUpdateDetectorKeyEndpoint {
-    constructor(clientTaskManager) {
-        this.clientTaskManager = clientTaskManager;
-    }
-    async processRequest(args, logger) {
-        logger = logger || getLogger("info", "");
-        try {
-            const { detectorKey } = args;
-            logger = logger || getLogger("info", "");
-            logger.info(() => ({ msg: "Updating detector key" }));
-            const activeDetectorKeys = await this.clientTaskManager.updateDetectorKey(detectorKey);
-            logger.info(() => ({
-                msg: "Detector key updated",
-                activeDetectorKeys,
-            }));
-            return {
-                status: ApiEndpointResponseStatus.SUCCESS,
-                data: {
-                    activeDetectorKeys,
-                },
-            };
-        }
-        catch (error) {
-            logger.error(() => ({ msg: "Error updating detector key", err: error }));
-            return {
-                status: ApiEndpointResponseStatus.FAIL,
-                error: error.message,
-            };
+  constructor(clientTaskManager) {
+    this.clientTaskManager = clientTaskManager;
+  }
+  async processRequest(args, logger) {
+    logger = logger || getLogger("info", "");
+    try {
+      const { detectorKey } = args;
+      logger = logger || getLogger("info", "");
+      logger.info(() => ({ msg: "Updating detector key" }));
+      const activeDetectorKeys = await this.clientTaskManager.updateDetectorKey(detectorKey);
+      logger.info(() => ({
+        msg: "Detector key updated",
+        activeDetectorKeys
+      }));
+      return {
+        status: ApiEndpointResponseStatus.SUCCESS,
+        data: {
+          activeDetectorKeys
         }
+      };
+    } catch (error) {
+      logger.error(() => ({ msg: "Error updating detector key", err: error }));
+      return {
+        status: ApiEndpointResponseStatus.FAIL,
+        error: error.message
+      };
     }
-    getRequestArgsSchema() {
-        return UpdateDetectorKeyBody;
-    }
+  }
+  getRequestArgsSchema() {
+    return UpdateDetectorKeyBody;
+  }
 }
-export { ApiUpdateDetectorKeyEndpoint };
-//# sourceMappingURL=apiUpdateDetectorKeyEndpoint.js.map
+export {
+  ApiUpdateDetectorKeyEndpoint
+};

package/dist/api/admin/createApiAdminRoutesProvider.js

@@ -1,7 +1,10 @@
-import { Tasks } from "../../tasks/index.js";
+import "../../tasks/index.js";
 import { ApiAdminRoutesProvider } from "./apiAdminRoutesProvider.js";
-export const createApiAdminRoutesProvider = (providerEnvironment) => {
-    const tasks = new Tasks(providerEnvironment);
-    return new ApiAdminRoutesProvider(tasks);
+import { Tasks } from "../../tasks/tasks.js";
+const createApiAdminRoutesProvider = (providerEnvironment) => {
+  const tasks = new Tasks(providerEnvironment);
+  return new ApiAdminRoutesProvider(tasks);
+};
+export {
+  createApiAdminRoutesProvider
 };
-//# sourceMappingURL=createApiAdminRoutesProvider.js.map

package/dist/api/blacklistRequestInspector.js

@@ -1,110 +1,127 @@
 import { ApiPrefix } from "@prosopo/types";
-import { AccessPolicyType, ScopeMatch, userScopeInputSchema, } from "@prosopo/user-access-policy";
+import { ScopeMatch, userScopeInputSchema, AccessPolicyType } from "@prosopo/user-access-policy";
 import { uniqueSubsets } from "@prosopo/util";
-export const getRequestUserScope = (requestHeaders, ja4, ip, user) => {
-    const userAgent = requestHeaders["user-agent"]
-        ? requestHeaders["user-agent"].toString()
-        : undefined;
-    return {
-        ...(user && { userId: user }),
-        ...(ja4 && { ja4Hash: ja4 }),
-        ...(userAgent && { userAgent: userAgent }),
-        ...(ip && { ip }),
-    };
+const getRequestUserScope = (requestHeaders, ja4, ip, user) => {
+  const userAgent = requestHeaders["user-agent"] ? requestHeaders["user-agent"].toString() : void 0;
+  return {
+    ...user && { userId: user },
+    ...ja4 && { ja4Hash: ja4 },
+    ...userAgent && { userAgent },
+    ...ip && { ip }
+  };
 };
-export const getPrioritisedAccessRule = async (userAccessRulesStorage, userScope, clientId) => {
-    const userScopeKeys = Object.keys(userScope).filter((key) => userScope[key] !== undefined);
-    const prioritisedUserScopes = uniqueSubsets(userScopeKeys)
-        .map((subset) => subset.reduce((acc, key) => {
+const getPrioritisedAccessRule = async (userAccessRulesStorage, userScope, clientId) => {
+  const userScopeKeys = Object.keys(userScope).filter(
+    (key) => userScope[key] !== void 0
+  );
+  const prioritisedUserScopes = uniqueSubsets(userScopeKeys).map(
+    (subset) => subset.reduce(
+      (acc, key) => {
         acc[key] = userScope[key];
         return acc;
-    }, {}))
-        .filter((us) => Object.keys(us).length > 0)
-        .filter((us) => Object.values(us).some((value) => value !== undefined));
-    const policyPromises = [];
-    for (const clientOrUndefined of [clientId, undefined]) {
-        for (const scope of prioritisedUserScopes) {
-            policyPromises.push(userAccessRulesStorage.findRules({
-                ...(clientOrUndefined && {
-                    policyScope: {
-                        clientId: clientOrUndefined,
-                    },
-                }),
-                policyScopeMatch: ScopeMatch.Exact,
-                userScope: userScopeInputSchema.parse(scope),
-                userScopeMatch: ScopeMatch.Exact,
-            }));
-        }
+      },
+      {}
+    )
+  ).filter((us) => Object.keys(us).length > 0).filter((us) => Object.values(us).some((value) => value !== void 0));
+  const policyPromises = [];
+  for (const clientOrUndefined of [clientId, void 0]) {
+    for (const scope of prioritisedUserScopes) {
+      policyPromises.push(
+        userAccessRulesStorage.findRules({
+          ...clientOrUndefined && {
+            policyScope: {
+              clientId: clientOrUndefined
+            }
+          },
+          policyScopeMatch: ScopeMatch.Exact,
+          userScope: userScopeInputSchema.parse(scope),
+          userScopeMatch: ScopeMatch.Exact
+        })
+      );
     }
-    return (await Promise.all(policyPromises)).flat();
+  }
+  return (await Promise.all(policyPromises)).flat();
 };
-export class BlacklistRequestInspector {
-    constructor(userAccessRulesStorage, environmentReadinessWaiter) {
-        this.userAccessRulesStorage = userAccessRulesStorage;
-        this.environmentReadinessWaiter = environmentReadinessWaiter;
+class BlacklistRequestInspector {
+  constructor(userAccessRulesStorage, environmentReadinessWaiter) {
+    this.userAccessRulesStorage = userAccessRulesStorage;
+    this.environmentReadinessWaiter = environmentReadinessWaiter;
+  }
+  async abortRequestForBlockedUsers(request, res, next) {
+    const rawIp = request.ip || "";
+    request.logger.debug(() => ({
+      data: { ja4: request.ja4 }
+    }));
+    const shouldAbortRequest = await this.shouldAbortRequest(
+      request.url,
+      rawIp,
+      request.ja4,
+      request.headers,
+      request.body,
+      request.logger
+    );
+    if (shouldAbortRequest) {
+      res.status(401).json({ error: "Unauthorized" });
+      return;
     }
-    async abortRequestForBlockedUsers(request, res, next) {
-        const rawIp = request.ip || "";
-        request.logger.debug(() => ({
-            data: { ja4: request.ja4 },
-        }));
-        const shouldAbortRequest = await this.shouldAbortRequest(request.url, rawIp, request.ja4, request.headers, request.body, request.logger);
-        if (shouldAbortRequest) {
-            res.status(401).json({ error: "Unauthorized" });
-            return;
-        }
-        next();
-    }
-    async shouldAbortRequest(requestedRoute, rawIp, ja4, requestHeaders, requestBody, logger) {
-        if (this.isApiUnrelatedRoute(requestedRoute)) {
-            return false;
-        }
-        if (!rawIp) {
-            logger.info(() => ({
-                data: {
-                    requestedRoute: requestedRoute,
-                    requestHeaders: requestHeaders,
-                    requestBody: requestBody,
-                },
-                msg: "Request without IP",
-            }));
-            return true;
-        }
-        await this.environmentReadinessWaiter();
-        try {
-            const { userId, clientId } = this.extractIdsFromRequest(requestHeaders, requestBody);
-            const accessPolicies = await getPrioritisedAccessRule(this.userAccessRulesStorage, getRequestUserScope(requestHeaders, ja4, rawIp, userId), clientId);
-            if (!accessPolicies ||
-                accessPolicies.length === 0 ||
-                !accessPolicies[0]) {
-                return false;
-            }
-            const accessPolicy = accessPolicies[0];
-            return AccessPolicyType.Block === accessPolicy.type;
-        }
-        catch (err) {
-            logger.error(() => ({
-                err,
-                msg: "Block Middleware Error",
-            }));
-            return true;
-        }
+    next();
+  }
+  async shouldAbortRequest(requestedRoute, rawIp, ja4, requestHeaders, requestBody, logger) {
+    if (this.isApiUnrelatedRoute(requestedRoute)) {
+      return false;
     }
-    isApiUnrelatedRoute(url) {
-        return !url.includes(ApiPrefix);
+    if (!rawIp) {
+      logger.info(() => ({
+        data: {
+          requestedRoute,
+          requestHeaders,
+          requestBody
+        },
+        msg: "Request without IP"
+      }));
+      return true;
     }
-    extractIdsFromRequest(requestHeaders, requestBody) {
-        const userId = this.getObjectValue(requestHeaders, "Prosopo-User") ||
-            this.getObjectValue(requestBody, "user");
-        const clientId = this.getObjectValue(requestHeaders, "Prosopo-Site-Key") ||
-            this.getObjectValue(requestBody, "dapp");
-        return {
-            userId: "string" === typeof userId ? userId : undefined,
-            clientId: "string" === typeof clientId ? clientId : undefined,
-        };
-    }
-    getObjectValue(object, key) {
-        return object[key];
+    await this.environmentReadinessWaiter();
+    try {
+      const { userId, clientId } = this.extractIdsFromRequest(
+        requestHeaders,
+        requestBody
+      );
+      const accessPolicies = await getPrioritisedAccessRule(
+        this.userAccessRulesStorage,
+        getRequestUserScope(requestHeaders, ja4, rawIp, userId),
+        clientId
+      );
+      if (!accessPolicies || accessPolicies.length === 0 || !accessPolicies[0]) {
+        return false;
+      }
+      const accessPolicy = accessPolicies[0];
+      return AccessPolicyType.Block === accessPolicy.type;
+    } catch (err) {
+      logger.error(() => ({
+        err,
+        msg: "Block Middleware Error"
+      }));
+      return true;
     }
+  }
+  isApiUnrelatedRoute(url) {
+    return !url.includes(ApiPrefix);
+  }
+  extractIdsFromRequest(requestHeaders, requestBody) {
+    const userId = this.getObjectValue(requestHeaders, "Prosopo-User") || this.getObjectValue(requestBody, "user");
+    const clientId = this.getObjectValue(requestHeaders, "Prosopo-Site-Key") || this.getObjectValue(requestBody, "dapp");
+    return {
+      userId: "string" === typeof userId ? userId : void 0,
+      clientId: "string" === typeof clientId ? clientId : void 0
+    };
+  }
+  getObjectValue(object, key) {
+    return object[key];
+  }
 }
-//# sourceMappingURL=blacklistRequestInspector.js.map
+export {
+  BlacklistRequestInspector,
+  getPrioritisedAccessRule,
+  getRequestUserScope
+};

package/dist/api/block.js

@@ -1,10 +1,15 @@
 import { BlacklistRequestInspector } from "./blacklistRequestInspector.js";
-export const blockMiddleware = (providerEnvironment) => {
-    const userAccessRulesStorage = providerEnvironment
-        .getDb()
-        .getUserAccessRulesStorage();
-    const environmentReadinessWaiter = providerEnvironment.isReady.bind(providerEnvironment);
-    const blacklistRequestInspector = new BlacklistRequestInspector(userAccessRulesStorage, environmentReadinessWaiter);
-    return blacklistRequestInspector.abortRequestForBlockedUsers.bind(blacklistRequestInspector);
+const blockMiddleware = (providerEnvironment) => {
+  const userAccessRulesStorage = providerEnvironment.getDb().getUserAccessRulesStorage();
+  const environmentReadinessWaiter = providerEnvironment.isReady.bind(providerEnvironment);
+  const blacklistRequestInspector = new BlacklistRequestInspector(
+    userAccessRulesStorage,
+    environmentReadinessWaiter
+  );
+  return blacklistRequestInspector.abortRequestForBlockedUsers.bind(
+    blacklistRequestInspector
+  );
+};
+export {
+  blockMiddleware
 };
-//# sourceMappingURL=block.js.map