@mondaydotcomorg/monday-authorization 3.3.1 → 3.4.0-feature-bashanye-add-membership-create-delete-api-9ba3b16

package/src/metrics-service.ts

@@ -1,29 +1,37 @@
 import { Metric } from '@mondaydotcomorg/monday-observability-kit';
 import { logger } from './authorization-internal-service';
 
-type ApiType = 'platform' | 'graph';
+type ApiType = 'platform' | 'graph' | 'authorization';
+
+export type MetricsClient = Pick<typeof Metric, 'distribution' | 'increment'>;
 
 interface InitializeMetricsOptions {
-  serviceName: string;
+  client?: MetricsClient;
+  serviceName?: string;
   host?: string;
   port?: number;
   disabled?: boolean;
 }
 
-let initialized = false;
+let metricsClient: MetricsClient | null = null;
 
 export function initializeMetrics(options: InitializeMetricsOptions): void {
-  if (initialized) {
+  if (metricsClient) {
+    return;
+  }
+
+  if (options.client) {
+    metricsClient = options.client;
     return;
   }
 
   const { serviceName } = options;
   if (!serviceName) {
-    logger.warn({ tag: 'metrics-service' }, 'Metrics initialization skipped: serviceName is missing');
+    logger.warn({ tag: 'monday-authorization-sdk' }, 'Metrics initialization skipped: serviceName is missing');
     return;
   }
 
-  const resolvedHost = options.host ?? process.env.DOGSTATSD_HOST ?? 'localhost';
+  const resolvedHost = options.host ?? process.env.HOST_IP ?? 'localhost';
   const envPort = process.env.DOGSTATSD_PORT ? Number(process.env.DOGSTATSD_PORT) : undefined;
   const resolvedPort = options.port ?? (Number.isFinite(envPort ?? NaN) ? envPort : undefined) ?? 8125;
   const resolvedDisabled =
@@ -36,32 +44,56 @@ export function initializeMetrics(options: InitializeMetricsOptions): void {
       port: resolvedPort,
       disabled: resolvedDisabled,
     });
-    initialized = true;
+    metricsClient = Metric;
   } catch (error) {
-    logger.warn({ tag: 'metrics-service', error }, 'Failed to initialize metrics');
+    logger.warn({ tag: 'monday-authorization-sdk', error }, 'Failed to initialize metrics');
   }
 }
 
-export function recordAuthorizationTiming(apiType: ApiType, duration: number): void {
-  if (!initialized) {
+export function recordAuthorizationTiming(apiType: ApiType, duration: number, placement: string): void {
+  if (!metricsClient) {
     return;
   }
 
   try {
-    Metric.distribution(`authorization.authorizationCheck.${apiType}.duration`, duration);
-  } catch {
-    // ignore metric emission failures
+    metricsClient.distribution(`authorization.authorizationCheck.${apiType}.${placement}.duration`, duration);
+  } catch (error) {
+    logger.warn(
+      {
+        tag: 'monday-authorization-sdk',
+        metric: 'authorizationCheckDuration',
+        apiType,
+        placement,
+        duration,
+        error,
+      },
+      'Failed to emit authorization timing metric'
+    );
   }
 }
 
-export function recordAuthorizationError(apiType: ApiType, statusCode: number): void {
-  if (!initialized) {
+export function recordAuthorizationError(apiType: ApiType, statusCode: number, placement: string): void {
+  if (!metricsClient) {
     return;
   }
 
   try {
-    Metric.increment(`authorization.authorizationCheck.${apiType}.error`, { statusCode: String(statusCode) }, 1);
-  } catch {
-    // ignore metric emission failures
+    metricsClient.increment(
+      `authorization.authorizationCheck.${apiType}.${placement}.error`,
+      { statusCode: String(statusCode) },
+      1
+    );
+  } catch (error) {
+    logger.warn(
+      {
+        tag: 'monday-authorization-sdk',
+        metric: 'authorizationCheckError',
+        apiType,
+        placement,
+        statusCode,
+        error,
+      },
+      'Failed to emit authorization error metric'
+    );
   }
 }

package/src/types/memberships.ts

@@ -0,0 +1,47 @@
+export interface MembershipForCreate {
+  entityId: number; // Which entity has the role?
+  entityType: string; // What type of entity is this?
+  resourceId: number; // What resource is this membership for?
+  resourceType: string; // What type of resource is this membership for?
+  roleId: number; // What role is this membership for?
+  roleType?: string; // What type of role is this membership for? (basic/custom)
+  addedById: number; // Who added this membership? for logging purposes
+}
+
+export interface MembershipForDelete {
+  entityId?: number; // Which entity has the role?
+  entityType: string; // What type of entity is this?
+  resourceId?: number; // What resource is this membership for?
+  resourceType: string; // What type of resource is this membership for?
+}
+
+export interface Membership {
+  id: number;
+  entityId: number;
+  entityType: string;
+  resourceId: number;
+  resourceType: string;
+  roleId: number;
+  roleType: string;
+  addedById: null | number | undefined;
+  hops: number;
+  isNewRecord: boolean;
+  previousValues: Partial<Membership>;
+  walVersion: number | null | undefined;
+}
+
+export interface MembershipCreateResponse {
+  memberships: Membership[];
+}
+
+export interface MembershipDeleteResponse {
+  memberships: Membership[];
+}
+
+export interface MembershipCreateRequest {
+  memberships: MembershipForCreate[];
+}
+
+export interface MembershipDeleteRequest {
+  memberships: MembershipForDelete[];
+}

package/src/utils/api-error-handler.ts

@@ -2,20 +2,24 @@ import { HttpFetcherError } from '@mondaydotcomorg/monday-fetch-api';
 import { AuthorizationInternalService, logger } from '../authorization-internal-service';
 import { recordAuthorizationError } from '../metrics-service';
 
-export function handleApiError(err: unknown, apiType: 'platform' | 'graph', placement: string): never {
+export function handleApiError(
+  err: unknown,
+  apiType: 'platform' | 'graph' | 'authorization',
+  placement: string
+): never {
   if (err instanceof HttpFetcherError) {
     logger.error(
       { tag: `${apiType}-api`, status: err.status, error: err.message },
-      `${apiType.charAt(0).toUpperCase() + apiType.slice(1)} API authorization request failed`
+      `${apiType.charAt(0).toUpperCase() + apiType.slice(1)} API ${placement} request failed`
     );
-    recordAuthorizationError(apiType, err.status);
+    recordAuthorizationError(apiType, err.status, placement);
     AuthorizationInternalService.throwOnHttpError(err.status, placement);
   } else {
     logger.error(
       { tag: `${apiType}-api`, error: err instanceof Error ? err.message : String(err) },
-      `${apiType.charAt(0).toUpperCase() + apiType.slice(1)} API authorization request failed`
+      `${apiType.charAt(0).toUpperCase() + apiType.slice(1)} API ${placement} request failed`
     );
-    recordAuthorizationError(apiType, 500);
+    recordAuthorizationError(apiType, 500, placement);
     throw err;
   }
 }