@mondaydotcomorg/monday-authorization 1.0.53-featureyardenauthorization-sdk-can-action-in-scope-support.34 → 1.0.53

package/dist/lib/authorization-service.d.ts

@@ -1,30 +1,10 @@
 import { MondayFetchOptions } from '@mondaydotcomorg/monday-fetch';
 import { Action, AuthorizationObject, Resource } from './types/general';
+import { ScopedAction, ScopedActionResponseObject, ScopeOptions } from 'lib/types/scoped-actions-contracts';
 export interface AuthorizeResponse {
     isAuthorized: boolean;
     unauthorizedIds?: number[];
 }
-export interface ScopeOptions {
-    workspaceId?: number;
-    accountProductId?: number;
-    boardId?: number;
-    pulseId?: number;
-}
-export interface Translation {
-    key: string;
-    [option: string]: string;
-}
-export interface SubjectRequestObject {
-    action: string;
-    scope: ScopeOptions;
-}
-export interface SubjectResponseObject {
-    subject: SubjectRequestObject;
-    permit: {
-        isAllowed: boolean;
-        reason: Translation;
-    };
-}
 export declare function setRequestFetchOptions(customMondayFetchOptions: MondayFetchOptions): void;
 export declare function setRedisClient(client: any, grantedFeatureRedisExpirationInSeconds?: number): void;
 export declare class AuthorizationService {
@@ -37,10 +17,10 @@ export declare class AuthorizationService {
     static isAuthorized(accountId: number, userId: number, resources: Resource[], action: Action): Promise<AuthorizeResponse>;
     static isAuthorized(accountId: number, userId: number, authorizationRequestObjects: AuthorizationObject[]): Promise<AuthorizeResponse>;
     static isUserGrantedWithFeature(accountId: number, userId: number, featureName: string): Promise<boolean>;
-    static canActionInScope(accountId: number, userId: number, action: string, scope: ScopeOptions): Promise<boolean>;
-    static canActionInScopeMultiple(accountId: number, userId: number, subjects: SubjectRequestObject[]): Promise<SubjectResponseObject[]>;
     private static fetchIsUserGrantedWithFeature;
     private static getCachedKeyName;
+    static canActionInScope(accountId: number, userId: number, action: string, scope: ScopeOptions): Promise<boolean>;
+    static canActionInScopeMultiple(accountId: number, userId: number, scopedActions: ScopedAction[]): Promise<ScopedActionResponseObject[]>;
     private static isAuthorizedSingular;
     private static isAuthorizedMultiple;
 }

package/dist/lib/authorization-service.js

@@ -29,8 +29,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthorizationService = exports.setRedisClient = exports.setRequestFetchOptions = void 0;
-const perf_hooks_1 = require("perf_hooks");
 const lodash_1 = require("lodash");
+const perf_hooks_1 = require("perf_hooks");
 const monday_jwt_1 = require("@mondaydotcomorg/monday-jwt");
 const MondayLogger = __importStar(require("@mondaydotcomorg/monday-logger"));
 const monday_fetch_1 = require("@mondaydotcomorg/monday-fetch");
@@ -89,19 +89,31 @@ class AuthorizationService {
             return grantedFeatureValue;
         });
     }
+    static fetchIsUserGrantedWithFeature(featureName, accountId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let authorizationObject = {
+                action: featureName,
+                resource_type: 'feature',
+            };
+            let authorizeResponsePromise = yield this.isAuthorized(accountId, userId, [authorizationObject]);
+            return authorizeResponsePromise.isAuthorized;
+        });
+    }
+    static getCachedKeyName(userId, featureName) {
+        return `granted-feature-${featureName}-${userId}`;
+    }
     static canActionInScope(accountId, userId, action, scope) {
         return __awaiter(this, void 0, void 0, function* () {
-            const subjects = [{ action, scope }];
-            const subjectsResponse = yield this.canActionInScopeMultiple(accountId, userId, subjects);
-            return subjectsResponse[0].permit.isAllowed;
+            const scopedActions = [{ action, scope }];
+            const scopedActionResponseObjects = yield this.canActionInScopeMultiple(accountId, userId, scopedActions);
+            return scopedActionResponseObjects[0].permit.can;
         });
     }
-    ;
-    static canActionInScopeMultiple(accountId, userId, subjects) {
+    static canActionInScopeMultiple(accountId, userId, scopedActions) {
         return __awaiter(this, void 0, void 0, function* () {
             const internalAuthToken = monday_jwt_1.signAuthorizationHeader({ appName: INTERNAL_APP_NAME, accountId, userId });
-            const subjectsPayload = subjects.map((subject) => {
-                return Object.assign(Object.assign({}, subject), { scope: lodash_1.mapKeys(subject.scope, (_, key) => lodash_1.snakeCase(key)) }); // for example: { workspaceId: 1 } => { workspace_id: 1 }
+            const scopedActionsPayload = scopedActions.map((scopedAction) => {
+                return Object.assign(Object.assign({}, scopedAction), { scope: lodash_1.mapKeys(scopedAction.scope, (_, key) => lodash_1.snakeCase(key)) }); // for example: { workspaceId: 1 } => { workspace_id: 1 }
             });
             const response = yield monday_fetch_1.fetch(getCanActionsInScopesUrl(), {
                 method: 'POST',
@@ -109,30 +121,17 @@ class AuthorizationService {
                 timeout: getRequestTimeout(),
                 body: JSON.stringify({
                     user_id: userId,
-                    subjects: subjectsPayload,
+                    scoped_actions: scopedActionsPayload,
                 }),
             }, mondayFetchOptions);
             if (!response.ok) {
                 logger.error({ status: response.status }, 'AuthorizationService: authorization request failed - canActionInScopeMultiple');
-                return subjects.map((subject) => ({ subject, permit: { isAllowed: false, reason: { key: 'internal error' } } }));
+                return scopedActions.map((scopedAction) => ({ scopedAction, permit: { can: false, reason: { key: 'internal error' } } }));
             }
             const responseBody = yield response.json();
             return responseBody.result;
         });
     }
-    static fetchIsUserGrantedWithFeature(featureName, accountId, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let authorizationObject = {
-                action: featureName,
-                resource_type: 'feature',
-            };
-            let authorizeResponsePromise = yield this.isAuthorized(accountId, userId, [authorizationObject]);
-            return authorizeResponsePromise.isAuthorized;
-        });
-    }
-    static getCachedKeyName(userId, featureName) {
-        return `granted-feature-${featureName}-${userId}`;
-    }
     static isAuthorizedSingular(accountId, userId, resources, action) {
         return __awaiter(this, void 0, void 0, function* () {
             const { authorizationObjects } = createAuthorizationParams(resources, action);

package/dist/lib/types/scoped-actions-contracts.d.ts

@@ -0,0 +1,32 @@
+export interface WorkspaceScope {
+    workspaceId: number;
+}
+export interface BoardScope {
+    boardId: number;
+}
+export interface PulseScope {
+    pulseId: number;
+}
+export interface AccountProductScope {
+    accountProductId: number;
+}
+export interface AccountScope {
+    accountId: number;
+}
+export declare type ScopeOptions = WorkspaceScope | BoardScope | PulseScope | AccountProductScope | AccountScope;
+export interface Translation {
+    key: string;
+    [option: string]: string;
+}
+export interface ScopedActionPermit {
+    can: boolean;
+    reason: Translation;
+}
+export interface ScopedAction {
+    action: string;
+    scope: ScopeOptions;
+}
+export interface ScopedActionResponseObject {
+    scopedAction: ScopedAction;
+    permit: ScopedActionPermit;
+}

package/dist/lib/types/scoped-actions-contracts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mondaydotcomorg/monday-authorization",
-  "version": "1.0.53-featureyardenauthorization-sdk-can-action-in-scope-support.34+3c772f361",
+  "version": "1.0.53",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "BSD-3-Clause",
@@ -32,5 +32,5 @@
   "files": [
     "dist/"
   ],
-  "gitHead": "3c772f361ac623b6da03988d05af464886b0ff48"
+  "gitHead": "8df5fda8931cf804959647805c4ffe8bf550e9a4"
 }