[Security Solution] Product features simplification refactor

src/platform/packages/shared/kbn-utility-types/index.ts

@@ -111,6 +111,12 @@ export type PublicMethodsOf<T> = Pick<T, MethodKeysOf<T>>;
 export type Writable<T> = {
   -readonly [K in keyof T]: T[K];
 };
+/**
+ *  Makes an object with readonly properties mutable.
+ */
+export type RecursiveWritable<T> = {
+  -readonly [K in keyof T]: RecursiveWritable<T[K]>;
+};
 
 /**
  * XOR for some properties applied to a type

x-pack/solutions/security/packages/features/src/assistant/index.ts

@@ -4,18 +4,20 @@
  * 2.0; you may not use this file except in compliance with the Elastic License
  * 2.0.
  */
-import type { AssistantSubFeatureId } from '../product_features_keys';
+import type { AssistantSubFeatureId, ProductFeatureAssistantKey } from '../product_features_keys';
 import type { ProductFeatureParams } from '../types';
 import { getAssistantBaseKibanaFeature } from './kibana_features';
 import {
   getAssistantBaseKibanaSubFeatureIds,
   getAssistantSubFeaturesMap,
 } from './kibana_sub_features';
+import { assistantProductFeaturesConfig } from './product_feature_config';
 
 export const getAssistantFeature = (
   experimentalFeatures: Record<string, boolean>
-): ProductFeatureParams<AssistantSubFeatureId> => ({
+): ProductFeatureParams<ProductFeatureAssistantKey, AssistantSubFeatureId> => ({
   baseKibanaFeature: getAssistantBaseKibanaFeature(),
   baseKibanaSubFeatureIds: getAssistantBaseKibanaSubFeatureIds(),
   subFeaturesMap: getAssistantSubFeaturesMap(experimentalFeatures),
+  productFeatureConfig: assistantProductFeaturesConfig,
 });

x-pack/solutions/security/packages/features/src/assistant/product_feature_config.ts

@@ -6,21 +6,11 @@
  */
 
 import { AssistantSubFeatureId, ProductFeatureAssistantKey } from '../product_features_keys';
-import type { ProductFeatureKibanaConfig } from '../types';
+import type { ProductFeaturesConfig } from '../types';
 
-/**
- * App features privileges configuration for the Security Assistant Kibana Feature app.
- * These are the configs that are shared between both offering types (ess and serverless).
- * They can be extended on each offering plugin to register privileges using different way on each offering type.
- *
- * Privileges can be added in different ways:
- * - `privileges`: the privileges that will be added directly into the main Security feature.
- * - `subFeatureIds`: the ids of the sub-features that will be added into the Security subFeatures entry.
- * - `subFeaturesPrivileges`: the privileges that will be added into the existing Security subFeature with the privilege `id` specified.
- */
-export const assistantDefaultProductFeaturesConfig: Record<
+export const assistantProductFeaturesConfig: ProductFeaturesConfig<
   ProductFeatureAssistantKey,
-  ProductFeatureKibanaConfig<AssistantSubFeatureId>
+  AssistantSubFeatureId
 > = {
   [ProductFeatureAssistantKey.assistant]: {
     privileges: {

x-pack/solutions/security/packages/features/src/attack_discovery/index.ts

@@ -7,9 +7,11 @@
 
 import { getAttackDiscoveryBaseKibanaFeature } from './kibana_features';
 import type { ProductFeatureParams } from '../types';
+import { attackDiscoveryProductFeaturesConfig } from './product_feature_config';
+import type { ProductFeatureAttackDiscoveryKey } from '../product_features_keys';
 
-export const getAttackDiscoveryFeature = (): ProductFeatureParams => ({
-  baseKibanaFeature: getAttackDiscoveryBaseKibanaFeature(),
-  baseKibanaSubFeatureIds: [],
-  subFeaturesMap: new Map(),
-});
+export const getAttackDiscoveryFeature =
+  (): ProductFeatureParams<ProductFeatureAttackDiscoveryKey> => ({
+    baseKibanaFeature: getAttackDiscoveryBaseKibanaFeature(),
+    productFeatureConfig: attackDiscoveryProductFeaturesConfig,
+  });

x-pack/solutions/security/packages/features/src/attack_discovery/product_feature_config.ts

@@ -6,28 +6,16 @@
  */
 
 import { ProductFeatureAttackDiscoveryKey } from '../product_features_keys';
-import type { ProductFeatureKibanaConfig } from '../types';
+import type { ProductFeaturesConfig } from '../types';
 
-/**
- * App features privileges configuration for the Attack discovery feature.
- * These are the configs that are shared between both offering types (ess and serverless).
- * They can be extended on each offering plugin to register privileges using different way on each offering type.
- *
- * Privileges can be added in different ways:
- * - `privileges`: the privileges that will be added directly into the main Security feature.
- * - `subFeatureIds`: the ids of the sub-features that will be added into the Security subFeatures entry.
- * - `subFeaturesPrivileges`: the privileges that will be added into the existing Security subFeature with the privilege `id` specified.
- */
-export const attackDiscoveryDefaultProductFeaturesConfig: Record<
-  ProductFeatureAttackDiscoveryKey,
-  ProductFeatureKibanaConfig
-> = {
-  [ProductFeatureAttackDiscoveryKey.attackDiscovery]: {
-    privileges: {
-      all: {
-        ui: ['attack-discovery'],
+export const attackDiscoveryProductFeaturesConfig: ProductFeaturesConfig<ProductFeatureAttackDiscoveryKey> =
+  {
+    [ProductFeatureAttackDiscoveryKey.attackDiscovery]: {
+      privileges: {
+        all: {
+          ui: ['attack-discovery'],
+        },
       },
+      subFeatureIds: [],
     },
-    subFeatureIds: [],
-  },
-};
+  };

x-pack/solutions/security/packages/features/src/cases/index.ts

@@ -4,12 +4,12 @@
  * 2.0; you may not use this file except in compliance with the Elastic License
  * 2.0.
  */
-import type { CasesSubFeatureId } from '../product_features_keys';
+import type { CasesSubFeatureId, ProductFeatureCasesKey } from '../product_features_keys';
 import type { ProductFeatureParams } from '../types';
 import { getCasesBaseKibanaFeature } from './v1_features/kibana_features';
 import {
-  getCasesBaseKibanaSubFeatureIds,
-  getCasesSubFeaturesMap,
+  getCasesBaseKibanaSubFeatureIdsV1,
+  getCasesSubFeaturesMapV1,
 } from './v1_features/kibana_sub_features';
 import type { CasesFeatureParams } from './types';
 import { getCasesBaseKibanaFeatureV2 } from './v2_features/kibana_features';
@@ -22,30 +22,31 @@ import {
   getCasesBaseKibanaSubFeatureIdsV3,
   getCasesSubFeaturesMapV3,
 } from './v3_features/kibana_sub_features';
+import { getCasesProductFeaturesConfig } from './product_feature_config';
 
-/**
- * @deprecated Use getCasesV2Feature instead
- */
 export const getCasesFeature = (
   params: CasesFeatureParams
-): ProductFeatureParams<CasesSubFeatureId> => ({
+): ProductFeatureParams<ProductFeatureCasesKey, CasesSubFeatureId> => ({
   baseKibanaFeature: getCasesBaseKibanaFeature(params),
-  baseKibanaSubFeatureIds: getCasesBaseKibanaSubFeatureIds(),
-  subFeaturesMap: getCasesSubFeaturesMap(params),
+  baseKibanaSubFeatureIds: getCasesBaseKibanaSubFeatureIdsV1(),
+  subFeaturesMap: getCasesSubFeaturesMapV1(params),
+  productFeatureConfig: getCasesProductFeaturesConfig(params),
 });
 
 export const getCasesV2Feature = (
   params: CasesFeatureParams
-): ProductFeatureParams<CasesSubFeatureId> => ({
+): ProductFeatureParams<ProductFeatureCasesKey, CasesSubFeatureId> => ({
   baseKibanaFeature: getCasesBaseKibanaFeatureV2(params),
   baseKibanaSubFeatureIds: getCasesBaseKibanaSubFeatureIdsV2(),
   subFeaturesMap: getCasesSubFeaturesMapV2(params),
+  productFeatureConfig: getCasesProductFeaturesConfig(params),
 });
 
 export const getCasesV3Feature = (
   params: CasesFeatureParams
-): ProductFeatureParams<CasesSubFeatureId> => ({
+): ProductFeatureParams<ProductFeatureCasesKey, CasesSubFeatureId> => ({
   baseKibanaFeature: getCasesBaseKibanaFeatureV3(params),
   baseKibanaSubFeatureIds: getCasesBaseKibanaSubFeatureIdsV3(),
   subFeaturesMap: getCasesSubFeaturesMapV3(params),
+  productFeatureConfig: getCasesProductFeaturesConfig(params),
 });

x-pack/solutions/security/packages/features/src/cases/kibana_sub_features.ts

@@ -0,0 +1,175 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+import { i18n } from '@kbn/i18n';
+import type { SubFeatureConfig } from '@kbn/features-plugin/common';
+import { APP_ID } from '../constants';
+import type { CasesFeatureParams } from './types';
+
+export const getDeleteCasesSubFeature = ({
+  apiTags,
+  uiCapabilities,
+  savedObjects,
+}: CasesFeatureParams): SubFeatureConfig => ({
+  name: i18n.translate('securitySolutionPackages.features.featureRegistry.deleteSubFeatureName', {
+    defaultMessage: 'Delete',
+  }),
+  privilegeGroups: [
+    {
+      groupType: 'independent',
+      privileges: [
+        {
+          api: apiTags.default.delete,
+          id: 'cases_delete',
+          name: i18n.translate(
+            'securitySolutionPackages.features.featureRegistry.deleteSubFeatureDetails',
+            { defaultMessage: 'Delete cases and comments' }
+          ),
+          includeIn: 'all',
+          savedObject: {
+            all: [...savedObjects.files],
+            read: [...savedObjects.files],
+          },
+          cases: {
+            delete: [APP_ID],
+          },
+          ui: uiCapabilities.default.delete,
+        },
+      ],
+    },
+  ],
+});
+
+export const getCasesSettingsCasesSubFeature = ({
+  uiCapabilities,
+  savedObjects,
+}: CasesFeatureParams): SubFeatureConfig => ({
+  name: i18n.translate(
+    'securitySolutionPackages.features.featureRegistry.casesSettingsSubFeatureName',
+    { defaultMessage: 'Case settings' }
+  ),
+  privilegeGroups: [
+    {
+      groupType: 'independent',
+      privileges: [
+        {
+          id: 'cases_settings',
+          name: i18n.translate(
+            'securitySolutionPackages.features.featureRegistry.casesSettingsSubFeatureDetails',
+            { defaultMessage: 'Edit case settings' }
+          ),
+          includeIn: 'all',
+          savedObject: {
+            all: [...savedObjects.files],
+            read: [...savedObjects.files],
+          },
+          cases: {
+            settings: [APP_ID],
+          },
+          ui: uiCapabilities.default.settings,
+        },
+      ],
+    },
+  ],
+});
+
+export const getCasesAddCommentsCasesSubFeature = ({
+  apiTags,
+  uiCapabilities,
+  savedObjects,
+}: CasesFeatureParams): SubFeatureConfig => ({
+  name: i18n.translate(
+    'securitySolutionPackages.features.featureRegistry.addCommentsSubFeatureName',
+    { defaultMessage: 'Create comments & attachments' }
+  ),
+  privilegeGroups: [
+    {
+      groupType: 'independent',
+      privileges: [
+        {
+          api: apiTags.default.createComment,
+          id: 'create_comment',
+          name: i18n.translate(
+            'securitySolutionPackages.features.featureRegistry.addCommentsSubFeatureDetails',
+            { defaultMessage: 'Add comments to cases' }
+          ),
+          includeIn: 'all',
+          savedObject: {
+            all: [...savedObjects.files],
+            read: [...savedObjects.files],
+          },
+          cases: {
+            createComment: [APP_ID],
+          },
+          ui: uiCapabilities.default.createComment,
+        },
+      ],
+    },
+  ],
+});
+
+export const getCasesReopenCaseSubFeature = ({
+  uiCapabilities,
+}: CasesFeatureParams): SubFeatureConfig => ({
+  name: i18n.translate(
+    'securitySolutionPackages.features.featureRegistry.reopenCaseSubFeatureName',
+    { defaultMessage: 'Re-open' }
+  ),
+  privilegeGroups: [
+    {
+      groupType: 'independent',
+      privileges: [
+        {
+          id: 'case_reopen',
+          name: i18n.translate(
+            'securitySolutionPackages.features.featureRegistry.reopenCaseSubFeatureDetails',
+            { defaultMessage: 'Re-open closed cases' }
+          ),
+          includeIn: 'all',
+          savedObject: {
+            all: [],
+            read: [],
+          },
+          cases: {
+            reopenCase: [APP_ID],
+          },
+          ui: uiCapabilities.default.reopenCase,
+        },
+      ],
+    },
+  ],
+});
+
+export const getCasesAssignUsersCasesSubFeature = ({
+  uiCapabilities,
+}: CasesFeatureParams): SubFeatureConfig => ({
+  name: i18n.translate('securitySolutionPackages.features.assignUsersSubFeatureName', {
+    defaultMessage: 'Assign users',
+  }),
+  privilegeGroups: [
+    {
+      groupType: 'independent',
+      privileges: [
+        {
+          id: 'cases_assign',
+          name: i18n.translate('securitySolutionPackages.features.assignUsersSubFeatureName', {
+            defaultMessage: 'Assign users to cases',
+          }),
+          includeIn: 'all',
+          savedObject: {
+            all: [],
+            read: [],
+          },
+          cases: {
+            assign: [APP_ID],
+          },
+          ui: uiCapabilities.default.assignCase,
+        },
+      ],
+    },
+  ],
+});