deepline 0.3.88 → 0.3.89

package/dist/bundling-sources/shared_libs/product-notifications/configuration-draft.ts

@@ -0,0 +1,456 @@
+import type {
+  EffectiveProductNotificationConfiguration,
+  EffectiveProductNotificationDestination,
+  EffectiveProductNotificationGroup,
+  EffectiveProductNotificationRule,
+  ProductNotificationConfigMode,
+  ProductNotificationDefaultDestination,
+  ProductNotificationDefaultGroup,
+  ProductNotificationDefaultRule,
+  ProductNotificationGroupDraft,
+} from './configuration';
+import { productNotificationValuesEqual } from './configuration';
+import { normalizeProductNotificationEmailList } from './configuration';
+export {
+  createProductNotificationRule,
+  type ProductNotificationPlayFailureSettings as PlayFailureOptions,
+} from './catalog';
+export type { ProductNotificationGroupDraft } from './configuration';
+
+type WorkspaceOverride = {
+  configMode: ProductNotificationConfigMode;
+  defaultKey?: string;
+};
+
+export type ProductNotificationConfigurationOperation =
+  | {
+      kind: 'put_group';
+      group: ProductNotificationDefaultGroup &
+        Required<Pick<ProductNotificationDefaultGroup, 'deliveryTiming'>> &
+        WorkspaceOverride;
+    }
+  | { kind: 'remove_group'; groupKey: string }
+  | {
+      kind: 'put_rule';
+      rule: ProductNotificationDefaultRule &
+        Required<
+          Pick<
+            ProductNotificationDefaultRule,
+            'repeatMode' | 'conditionGeneration'
+          >
+        > &
+        WorkspaceOverride;
+    }
+  | { kind: 'remove_rule'; ruleKey: string }
+  | {
+      kind: 'put_destination';
+      destination: ProductNotificationDefaultDestination & WorkspaceOverride;
+    }
+  | { kind: 'remove_destination'; destinationKey: string };
+
+/** Return the editable view of one effective group. */
+export function getProductNotificationGroupDraft(
+  configuration: EffectiveProductNotificationConfiguration,
+  groupKey: string,
+): ProductNotificationGroupDraft {
+  const group = configuration.groups.find(
+    (candidate) => candidate.groupKey === groupKey,
+  );
+  if (!group) throw new Error(`Unknown notification group ${groupKey}.`);
+  return {
+    group: { ...group },
+    destinations: configuration.destinations
+      .filter((destination) => destination.groupKey === groupKey)
+      .map((destination) => ({ ...destination })),
+    rules: configuration.rules
+      .filter((rule) => rule.groupKey === groupKey)
+      .map((rule) => ({ ...rule })),
+  };
+}
+
+/** Editing a synthetic default materializes its single sparse override. */
+export function materializeProductNotificationRuleEdit(
+  saved: EffectiveProductNotificationConfiguration,
+  updated: EffectiveProductNotificationRule,
+): EffectiveProductNotificationRule {
+  const inherited =
+    updated.configMode === 'default' &&
+    !saved.rules.some((rule) => rule.ruleKey === updated.ruleKey);
+  return inherited
+    ? {
+        ...updated,
+        source: 'workspace',
+        configMode: 'replace_default',
+        defaultKey: updated.ruleKey,
+      }
+    : updated;
+}
+
+function comparableGroup(group: EffectiveProductNotificationGroup) {
+  return {
+    name: group.name,
+    enabled: group.enabled,
+    deliveryTiming: group.deliveryTiming,
+  };
+}
+
+function comparableDestination(
+  destination: EffectiveProductNotificationDestination,
+) {
+  return {
+    groupKey: destination.groupKey,
+    name: destination.name,
+    enabled: destination.enabled,
+    settings: destination.settings,
+  };
+}
+
+function comparableRule(rule: EffectiveProductNotificationRule) {
+  return {
+    groupKey: rule.groupKey,
+    enabled: rule.enabled,
+    notificationType: rule.notificationType,
+    eventName: rule.eventName,
+    eventFilter: rule.eventFilter,
+    trigger: rule.trigger,
+    repeatMode: rule.repeatMode,
+  };
+}
+
+function modeFor(item: {
+  configMode: EffectiveProductNotificationRule['configMode'];
+}) {
+  return item.configMode === 'default' ? 'replace_default' : item.configMode;
+}
+
+function canonicalDestinationSettings(
+  settings: EffectiveProductNotificationDestination['settings'],
+) {
+  if (settings.kind === 'slack') {
+    return {
+      ...settings,
+      targetId: settings.targetId.trim(),
+      targetName: settings.targetName.trim(),
+      oauthConnectionId: settings.oauthConnectionId.trim(),
+    };
+  }
+  if (settings.kind === 'email_roles') {
+    return {
+      ...settings,
+      roles: [...new Set(settings.roles.map((role) => role.trim()))],
+    };
+  }
+  return {
+    kind: settings.kind,
+    to: normalizeProductNotificationEmailList(settings.to, 'to'),
+    cc: settings.cc
+      ? normalizeProductNotificationEmailList(settings.cc, 'cc')
+      : undefined,
+    bcc: settings.bcc
+      ? normalizeProductNotificationEmailList(settings.bcc, 'bcc')
+      : undefined,
+  };
+}
+
+function canonicalGroupDraft(
+  draft: ProductNotificationGroupDraft,
+): ProductNotificationGroupDraft {
+  return {
+    group: { ...draft.group, name: draft.group.name.trim() },
+    destinations: draft.destinations.map((destination) => ({
+      ...destination,
+      name: destination.name.trim(),
+      settings: canonicalDestinationSettings(destination.settings),
+    })),
+    rules: draft.rules.map((rule) => ({
+      ...rule,
+      eventFilter: Object.fromEntries(
+        Object.entries(rule.eventFilter).map(([key, value]) => [
+          key.trim(),
+          typeof value === 'string' ? value.trim() : value,
+        ]),
+      ),
+    })),
+  };
+}
+
+/** Build the smallest atomic operation list for one edited group. */
+export function buildProductNotificationGroupOperations(
+  saved: EffectiveProductNotificationConfiguration,
+  draft: ProductNotificationGroupDraft,
+): ProductNotificationConfigurationOperation[] {
+  draft = canonicalGroupDraft(draft);
+  for (const destination of draft.destinations) {
+    if (destination.groupKey !== draft.group.groupKey) {
+      throw new Error('Every destination must belong to the saved group.');
+    }
+  }
+  for (const rule of draft.rules) {
+    if (rule.groupKey !== draft.group.groupKey) {
+      throw new Error('Every rule must belong to the saved group.');
+    }
+  }
+  const operations: ProductNotificationConfigurationOperation[] = [];
+  const savedGroup = saved.groups.find(
+    (group) => group.groupKey === draft.group.groupKey,
+  );
+  if (
+    !savedGroup ||
+    !productNotificationValuesEqual(
+      comparableGroup(savedGroup),
+      comparableGroup(draft.group),
+    )
+  ) {
+    operations.push({
+      kind: 'put_group',
+      group: {
+        groupKey: draft.group.groupKey,
+        name: draft.group.name,
+        enabled: draft.group.enabled,
+        deliveryTiming: draft.group.deliveryTiming,
+        configMode: modeFor(draft.group),
+        ...(draft.group.configMode === 'default'
+          ? { defaultKey: draft.group.groupKey }
+          : draft.group.defaultKey
+            ? { defaultKey: draft.group.defaultKey }
+            : {}),
+      },
+    });
+  }
+
+  const savedDestinations = saved.destinations.filter(
+    (destination) => destination.groupKey === draft.group.groupKey,
+  );
+  for (const destination of savedDestinations) {
+    if (
+      draft.destinations.some(
+        (candidate) => candidate.destinationKey === destination.destinationKey,
+      )
+    )
+      continue;
+    if (
+      destination.configMode === 'default' ||
+      destination.configMode === 'replace_default'
+    ) {
+      operations.push({
+        kind: 'put_destination',
+        destination: {
+          destinationKey: destination.destinationKey,
+          groupKey: destination.groupKey,
+          name: destination.name,
+          enabled: false,
+          settings: destination.settings,
+          configMode: 'disable_default',
+          defaultKey: destination.destinationKey,
+        },
+      });
+    } else {
+      operations.push({
+        kind: 'remove_destination',
+        destinationKey: destination.destinationKey,
+      });
+    }
+  }
+  for (const destination of draft.destinations) {
+    const previous = savedDestinations.find(
+      (candidate) => candidate.destinationKey === destination.destinationKey,
+    );
+    if (
+      previous &&
+      productNotificationValuesEqual(
+        comparableDestination(previous),
+        comparableDestination(destination),
+      )
+    )
+      continue;
+    operations.push({
+      kind: 'put_destination',
+      destination: {
+        destinationKey: destination.destinationKey,
+        groupKey: destination.groupKey,
+        name: destination.name,
+        enabled: destination.enabled,
+        settings: destination.settings,
+        configMode: modeFor(destination),
+        ...(destination.configMode === 'default'
+          ? { defaultKey: destination.destinationKey }
+          : destination.defaultKey
+            ? { defaultKey: destination.defaultKey }
+            : {}),
+      },
+    });
+  }
+
+  const savedRules = saved.rules.filter(
+    (rule) => rule.groupKey === draft.group.groupKey,
+  );
+  for (const rule of savedRules) {
+    if (draft.rules.some((candidate) => candidate.ruleKey === rule.ruleKey))
+      continue;
+    if (
+      rule.configMode === 'default' ||
+      rule.configMode === 'replace_default'
+    ) {
+      operations.push({
+        kind: 'put_rule',
+        rule: {
+          ruleKey: rule.ruleKey,
+          groupKey: rule.groupKey,
+          enabled: false,
+          notificationType: rule.notificationType,
+          eventName: rule.eventName,
+          eventFilter: rule.eventFilter,
+          trigger: rule.trigger,
+          repeatMode: rule.repeatMode,
+          conditionGeneration: rule.conditionGeneration,
+          configMode: 'disable_default',
+          defaultKey: rule.ruleKey,
+        },
+      });
+    } else {
+      operations.push({ kind: 'remove_rule', ruleKey: rule.ruleKey });
+    }
+  }
+  for (const rule of draft.rules) {
+    const previous = savedRules.find(
+      (candidate) => candidate.ruleKey === rule.ruleKey,
+    );
+    if (
+      previous &&
+      productNotificationValuesEqual(
+        comparableRule(previous),
+        comparableRule(rule),
+      )
+    )
+      continue;
+    if (!previous && rule.configMode === 'default') {
+      operations.push({ kind: 'remove_rule', ruleKey: rule.ruleKey });
+      continue;
+    }
+    operations.push({
+      kind: 'put_rule',
+      rule: {
+        ruleKey: rule.ruleKey,
+        groupKey: rule.groupKey,
+        enabled: rule.enabled,
+        notificationType: rule.notificationType,
+        eventName: rule.eventName,
+        eventFilter: rule.eventFilter,
+        trigger: rule.trigger,
+        repeatMode: rule.repeatMode,
+        conditionGeneration: rule.conditionGeneration,
+        configMode: modeFor(rule),
+        ...(rule.configMode === 'default'
+          ? { defaultKey: rule.ruleKey }
+          : rule.defaultKey
+            ? { defaultKey: rule.defaultKey }
+            : {}),
+      },
+    });
+  }
+
+  if (savedGroup?.configMode === 'default' && operations.length > 0) {
+    if (!operations.some((operation) => operation.kind === 'put_group')) {
+      operations.unshift({
+        kind: 'put_group',
+        group: {
+          groupKey: draft.group.groupKey,
+          name: draft.group.name,
+          enabled: draft.group.enabled,
+          deliveryTiming: draft.group.deliveryTiming,
+          configMode: 'replace_default',
+          defaultKey: draft.group.groupKey,
+        },
+      });
+    }
+    for (const destination of draft.destinations) {
+      if (
+        destination.configMode !== 'default' ||
+        operations.some(
+          (operation) =>
+            (operation.kind === 'put_destination' &&
+              operation.destination.destinationKey ===
+                destination.destinationKey) ||
+            (operation.kind === 'remove_destination' &&
+              operation.destinationKey === destination.destinationKey),
+        )
+      )
+        continue;
+      operations.push({
+        kind: 'put_destination',
+        destination: {
+          destinationKey: destination.destinationKey,
+          groupKey: destination.groupKey,
+          name: destination.name,
+          enabled: destination.enabled,
+          settings: destination.settings,
+          configMode: 'replace_default',
+          defaultKey: destination.destinationKey,
+        },
+      });
+    }
+    for (const rule of draft.rules) {
+      if (
+        rule.configMode !== 'default' ||
+        operations.some(
+          (operation) =>
+            (operation.kind === 'put_rule' &&
+              operation.rule.ruleKey === rule.ruleKey) ||
+            (operation.kind === 'remove_rule' &&
+              operation.ruleKey === rule.ruleKey),
+        )
+      )
+        continue;
+      operations.push({
+        kind: 'put_rule',
+        rule: {
+          ruleKey: rule.ruleKey,
+          groupKey: rule.groupKey,
+          enabled: rule.enabled,
+          notificationType: rule.notificationType,
+          eventName: rule.eventName,
+          eventFilter: rule.eventFilter,
+          trigger: rule.trigger,
+          repeatMode: rule.repeatMode,
+          conditionGeneration: rule.conditionGeneration,
+          configMode: 'replace_default',
+          defaultKey: rule.ruleKey,
+        },
+      });
+    }
+  }
+  return operations;
+}
+
+export function productNotificationGroupDraftHasChanges(
+  saved: EffectiveProductNotificationConfiguration,
+  draft: ProductNotificationGroupDraft,
+) {
+  return buildProductNotificationGroupOperations(saved, draft).length > 0;
+}
+
+/** Delete a custom group and its children in dependency order. */
+export function buildProductNotificationGroupDeletionOperations(
+  saved: EffectiveProductNotificationConfiguration,
+  groupKey: string,
+): ProductNotificationConfigurationOperation[] {
+  const group = saved.groups.find(
+    (candidate) => candidate.groupKey === groupKey,
+  );
+  if (!group) return [];
+  if (group.configMode !== 'custom') {
+    throw new Error('The default notification group cannot be deleted.');
+  }
+  return [
+    ...saved.rules
+      .filter((rule) => rule.groupKey === groupKey)
+      .map((rule) => ({ kind: 'remove_rule' as const, ruleKey: rule.ruleKey })),
+    ...saved.destinations
+      .filter((destination) => destination.groupKey === groupKey)
+      .map((destination) => ({
+        kind: 'remove_destination' as const,
+        destinationKey: destination.destinationKey,
+      })),
+    { kind: 'remove_group' as const, groupKey },
+  ];
+}