@mondaydotcomorg/monday-authorization 3.3.0-feature-bashanye-navigate-can-action-in-scope-to-graph-0a3cfd6 → 3.3.0-feature-bashanye-navigate-can-action-in-scope-to-graph-752f21a

package/src/types/roles.ts

@@ -0,0 +1,42 @@
+export enum RoleType {
+  CUSTOM = 'custom_role',
+  BASIC = 'basic_role',
+}
+
+export interface CustomRole {
+  id?: number;
+  name: string;
+  resourceType: string;
+  resourceId: number;
+  basicRoleId: number;
+  basicRoleType: RoleType;
+}
+
+export interface BasicRole {
+  id: number;
+  resourceType: string;
+  roleType: string;
+  name: string;
+}
+
+export interface RolesResponse {
+  customRoles: CustomRole[];
+  basicRoles?: BasicRole[];
+}
+
+export interface RoleCreateRequest {
+  name: string;
+  resourceType: string;
+  resourceId: number;
+  sourceRole: {
+    id: number;
+    type: RoleType;
+  };
+}
+
+export interface RoleUpdateRequest {
+  id: number;
+  updateAttributes: {
+    name: string;
+  };
+}

package/src/types/scoped-actions-contracts.ts

@@ -0,0 +1,48 @@
+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 type ScopeOptions = WorkspaceScope | BoardScope | PulseScope | AccountProductScope | AccountScope;
+
+export interface Translation {
+  key: string;
+  [option: string]: string;
+}
+
+export enum PermitTechnicalReason {
+  NO_REASON = 0,
+  NOT_ELIGIBLE = 1,
+  BY_ROLE_IN_SCOPE = 2,
+}
+
+export interface ScopedActionPermit {
+  can: boolean;
+  reason: Translation;
+  technicalReason: PermitTechnicalReason;
+}
+
+export interface ScopedAction {
+  action: string;
+  scope: ScopeOptions;
+}
+
+export interface ScopedActionResponseObject {
+  scopedAction: ScopedAction;
+  permit: ScopedActionPermit;
+}

package/src/utils/authorization.utils.ts

@@ -0,0 +1,66 @@
+import snakeCase from 'lodash/snakeCase.js';
+import camelCase from 'lodash/camelCase.js';
+import mapKeys from 'lodash/mapKeys.js';
+import { ScopeOptions } from '../types/scoped-actions-contracts';
+import { ResourceType, ResourceId } from '../types/graph-api.types';
+import { logger } from '../authorization-internal-service';
+
+export type CamelCase<S extends string> = S extends `${infer F}_${infer R}` ? `${F}${Capitalize<CamelCase<R>>}` : S;
+export type CamelCaseKeys<T> = T extends object
+  ? { [K in keyof T as K extends string ? CamelCase<K> : K]: CamelCaseKeys<T[K]> }
+  : T;
+
+/**
+ * Converts a scope object to resource type and resource ID
+ */
+export function scopeToResource(scope: ScopeOptions): { resourceType: ResourceType; resourceId: ResourceId } {
+  logger.debug(
+    {
+      tag: 'authorization-utils',
+      scopeKeys: Object.keys(scope),
+      scopeValues: Object.values(scope),
+    },
+    '🔍 Utils Debug: Converting scope to resource'
+  );
+
+  if ('workspaceId' in scope) {
+    logger.debug({ tag: 'authorization-utils', resourceId: scope.workspaceId }, '🔍 Utils Debug: Mapped to workspace');
+    return { resourceType: 'workspace', resourceId: scope.workspaceId };
+  }
+  if ('boardId' in scope) {
+    logger.debug({ tag: 'authorization-utils', resourceId: scope.boardId }, '🔍 Utils Debug: Mapped to board');
+    return { resourceType: 'board', resourceId: scope.boardId };
+  }
+  if ('pulseId' in scope) {
+    logger.debug({ tag: 'authorization-utils', resourceId: scope.pulseId }, '🔍 Utils Debug: Mapped to pulse');
+    return { resourceType: 'pulse', resourceId: scope.pulseId };
+  }
+  if ('accountProductId' in scope) {
+    logger.debug(
+      { tag: 'authorization-utils', resourceId: scope.accountProductId },
+      '🔍 Utils Debug: Mapped to account_product'
+    );
+    return { resourceType: 'account_product', resourceId: scope.accountProductId };
+  }
+  if ('accountId' in scope) {
+    logger.debug({ tag: 'authorization-utils', resourceId: scope.accountId }, '🔍 Utils Debug: Mapped to account');
+    return { resourceType: 'account', resourceId: scope.accountId };
+  }
+
+  logger.debug({ tag: 'authorization-utils', scope }, '❌ Utils Debug: Unsupported scope provided');
+  throw new Error('Unsupported scope provided');
+}
+
+/**
+ * Converts object keys from snake_case to camelCase
+ */
+export function toCamelCase<T extends object>(obj: T): CamelCaseKeys<T> {
+  return mapKeys(obj, (_, key) => camelCase(key)) as CamelCaseKeys<T>;
+}
+
+/**
+ * Converts object keys from camelCase to snake_case
+ */
+export function toSnakeCase<T extends object>(obj: T): Record<string, any> {
+  return mapKeys(obj, (_, key) => snakeCase(key));
+}