[Automatic Import V2] Validations for integration and data stream names (#260748)

This PR adds validations for Integration and Data stream names.
Adds more checks to see if the custom integrations names are currently used already.

Author: robester0403

x-pack/platform/plugins/shared/automatic_import_v2/public/common/index.ts

@@ -53,4 +53,14 @@ export type {
 export { getLangSmithOptions } from './lib/lang_smith';
 export type { LangSmithOptions } from './lib/lang_smith';
 
-export { generateId, normalizeTitleName } from './lib/helper_functions';
+export {
+  generateId,
+  normalizeTitleName,
+  isValidNameFormat,
+  isNotPurelyNumeric,
+  startsWithLetter,
+  meetsMinLength,
+  meetsMaxLength,
+  MIN_NAME_LENGTH,
+  MAX_NAME_LENGTH,
+} from './lib/helper_functions';

x-pack/platform/plugins/shared/automatic_import_v2/public/common/lib/helper_functions.test.ts

@@ -5,7 +5,17 @@
  * 2.0.
  */
 
-import { generateId } from './helper_functions';
+import {
+  generateId,
+  normalizeTitleName,
+  isValidNameFormat,
+  isNotPurelyNumeric,
+  startsWithLetter,
+  meetsMinLength,
+  meetsMaxLength,
+  MIN_NAME_LENGTH,
+  MAX_NAME_LENGTH,
+} from './helper_functions';
 
 describe('helper_functions', () => {
   describe('generateId', () => {
@@ -36,4 +46,172 @@ describe('helper_functions', () => {
       expect(id).not.toContain('-');
     });
   });
+
+  describe('normalizeTitleName', () => {
+    it('should convert to lowercase', () => {
+      expect(normalizeTitleName('MyIntegration')).toBe('myintegration');
+    });
+
+    it('should replace spaces with underscores', () => {
+      expect(normalizeTitleName('My Integration')).toBe('my_integration');
+    });
+
+    it('should collapse multiple spaces into single underscore', () => {
+      expect(normalizeTitleName('My   Integration')).toBe('my_integration');
+    });
+
+    it('should collapse multiple underscores into single underscore', () => {
+      expect(normalizeTitleName('My___Integration')).toBe('my_integration');
+    });
+
+    it('should collapse mixed spaces and underscores into single underscore', () => {
+      expect(normalizeTitleName('My _ Integration')).toBe('my_integration');
+    });
+
+    it('should trim leading and trailing whitespace', () => {
+      expect(normalizeTitleName('  My Integration  ')).toBe('my_integration');
+    });
+
+    it('should remove leading underscores', () => {
+      expect(normalizeTitleName('_my_integration')).toBe('my_integration');
+      expect(normalizeTitleName('__my_integration')).toBe('my_integration');
+    });
+
+    it('should remove trailing underscores', () => {
+      expect(normalizeTitleName('my_integration_')).toBe('my_integration');
+      expect(normalizeTitleName('my_integration__')).toBe('my_integration');
+    });
+
+    it('should handle trailing spaces that become underscores', () => {
+      expect(normalizeTitleName('my integration ')).toBe('my_integration');
+      expect(normalizeTitleName(' my integration ')).toBe('my_integration');
+    });
+  });
+
+  describe('isValidNameFormat', () => {
+    it('should return true for empty string', () => {
+      expect(isValidNameFormat('')).toBe(true);
+    });
+
+    it('should return true for alphanumeric characters', () => {
+      expect(isValidNameFormat('MyIntegration123')).toBe(true);
+    });
+
+    it('should return true for names with spaces', () => {
+      expect(isValidNameFormat('My Integration')).toBe(true);
+    });
+
+    it('should return true for names with underscores', () => {
+      expect(isValidNameFormat('My_Integration')).toBe(true);
+    });
+
+    it('should return false for names with special characters', () => {
+      expect(isValidNameFormat('My-Integration')).toBe(false);
+      expect(isValidNameFormat('My@Integration')).toBe(false);
+      expect(isValidNameFormat('My!Integration')).toBe(false);
+      expect(isValidNameFormat('My.Integration')).toBe(false);
+    });
+
+    it('should return false for names with unicode characters', () => {
+      expect(isValidNameFormat('Integración')).toBe(false);
+      expect(isValidNameFormat('インテグレーション')).toBe(false);
+    });
+  });
+
+  describe('isNotPurelyNumeric', () => {
+    it('should return true for empty string', () => {
+      expect(isNotPurelyNumeric('')).toBe(true);
+    });
+
+    it('should return true for names with letters', () => {
+      expect(isNotPurelyNumeric('Integration123')).toBe(true);
+      expect(isNotPurelyNumeric('a')).toBe(true);
+    });
+
+    it('should return true for names starting with numbers but containing letters', () => {
+      expect(isNotPurelyNumeric('123Integration')).toBe(true);
+    });
+
+    it('should return false for purely numeric names', () => {
+      expect(isNotPurelyNumeric('123')).toBe(false);
+      expect(isNotPurelyNumeric('1')).toBe(false);
+    });
+
+    it('should return false for numeric names with spaces or underscores only', () => {
+      expect(isNotPurelyNumeric('123 456')).toBe(false);
+      expect(isNotPurelyNumeric('123_456')).toBe(false);
+    });
+
+    it('should return true for names with letters and underscores/spaces', () => {
+      expect(isNotPurelyNumeric('my_123')).toBe(true);
+      expect(isNotPurelyNumeric('123 abc')).toBe(true);
+    });
+  });
+
+  describe('startsWithLetter', () => {
+    it('should return true for empty string', () => {
+      expect(startsWithLetter('')).toBe(true);
+    });
+
+    it('should return true for names starting with a letter', () => {
+      expect(startsWithLetter('MyIntegration')).toBe(true);
+      expect(startsWithLetter('a')).toBe(true);
+      expect(startsWithLetter('A123')).toBe(true);
+    });
+
+    it('should return false for names starting with a number', () => {
+      expect(startsWithLetter('123Integration')).toBe(false);
+      expect(startsWithLetter('1abc')).toBe(false);
+    });
+
+    it('should return false for names starting with underscore', () => {
+      expect(startsWithLetter('_integration')).toBe(false);
+    });
+
+    it('should return true for names with leading spaces (trimmed before check)', () => {
+      // Leading spaces are trimmed, so ' integration' becomes 'integration' which starts with a letter
+      expect(startsWithLetter(' integration')).toBe(true);
+    });
+  });
+
+  describe('meetsMinLength', () => {
+    it('should return true for empty string', () => {
+      expect(meetsMinLength('')).toBe(true);
+    });
+
+    it('should return true for names with 2 or more characters', () => {
+      expect(meetsMinLength('ab')).toBe(true);
+      expect(meetsMinLength('abc')).toBe(true);
+      expect(meetsMinLength('my integration')).toBe(true);
+    });
+
+    it('should return false for single character names', () => {
+      expect(meetsMinLength('a')).toBe(false);
+    });
+  });
+
+  describe('meetsMaxLength', () => {
+    it('should return true for empty string', () => {
+      expect(meetsMaxLength('')).toBe(true);
+    });
+
+    it('should return true for names within limit', () => {
+      expect(meetsMaxLength('ab')).toBe(true);
+      expect(meetsMaxLength('a'.repeat(256))).toBe(true);
+    });
+
+    it('should return false for names exceeding 256 characters', () => {
+      expect(meetsMaxLength('a'.repeat(257))).toBe(false);
+    });
+  });
+
+  describe('constants', () => {
+    it('should have correct MIN_NAME_LENGTH', () => {
+      expect(MIN_NAME_LENGTH).toBe(2);
+    });
+
+    it('should have correct MAX_NAME_LENGTH', () => {
+      expect(MAX_NAME_LENGTH).toBe(256);
+    });
+  });
 });

x-pack/platform/plugins/shared/automatic_import_v2/public/common/lib/helper_functions.ts

@@ -14,5 +14,74 @@ export function generateId(): string {
   return uuidv4().replace(/-/g, '').slice(0, 12);
 }
 
+// Validation constants matching elastic-package requirements
+export const MIN_NAME_LENGTH = 2;
+export const MAX_NAME_LENGTH = 256;
+
+/**
+ * Normalizes a title/name for use as an integration or data stream identifier.
+ * - Trims leading/trailing whitespace
+ * - Converts to lowercase
+ * - Replaces spaces with underscores
+ * - Collapses multiple consecutive underscores into one
+ * - Removes leading/trailing underscores for compatibility
+ */
 export const normalizeTitleName = (value: string): string =>
-  value.trim().toLowerCase().replace(/[ _]+/g, '_');
+  value
+    .trim()
+    .toLowerCase()
+    .replace(/[ _]+/g, '_')
+    .replace(/^_+|_+$/g, '');
+
+/**
+ * Validates that a name contains only valid characters for Elastic integrations.
+ * Allowed: lowercase letters, numbers, underscores, and spaces (spaces will be converted to underscores).
+ * @returns true if valid, false otherwise
+ */
+export const isValidNameFormat = (value: string): boolean => {
+  if (!value) return true;
+  return /^[a-zA-Z0-9_ ]+$/.test(value.trim());
+};
+
+/**
+ * Validates that a name starts with a letter (required for integration names).
+ * After normalization, names must start with a letter or underscore, but we encourage
+ * starting with a letter for better compatibility.
+ * @returns true if starts with a letter, false otherwise
+ */
+export const startsWithLetter = (value: string): boolean => {
+  if (!value) return true;
+  const trimmed = value.trim();
+  return /^[a-zA-Z]/.test(trimmed);
+};
+
+/**
+ * Validates that a name is not purely numeric (after removing spaces/underscores).
+ * Names must contain at least one letter.
+ * @returns true if valid (contains at least one letter), false if purely numeric
+ */
+export const isNotPurelyNumeric = (value: string): boolean => {
+  if (!value) return true;
+  const alphanumericOnly = value.replace(/[_ ]/g, '');
+  return /[a-zA-Z]/.test(alphanumericOnly);
+};
+
+/**
+ * Validates that a name meets the minimum length requirement (2 characters after normalization).
+ * @returns true if valid, false otherwise
+ */
+export const meetsMinLength = (value: string): boolean => {
+  if (!value) return true;
+  const normalized = normalizeTitleName(value);
+  return normalized.length >= MIN_NAME_LENGTH;
+};
+
+/**
+ * Validates that a name does not exceed the maximum length (256 characters).
+ * @returns true if valid, false otherwise
+ */
+export const meetsMaxLength = (value: string): boolean => {
+  if (!value) return true;
+  const normalized = normalizeTitleName(value);
+  return normalized.length <= MAX_NAME_LENGTH;
+};

x-pack/platform/plugins/shared/automatic_import_v2/public/components/integration_management/forms/integration_form.tsx

@@ -15,9 +15,10 @@ import {
 } from '@kbn/es-ui-shared-plugin/static/forms/hook_form_lib';
 import { createFormSchema, REQUIRED_FIELDS } from './integration_form_validation';
 import type { IntegrationFormData } from './types';
-import { useKibana, getInstalledPackages } from '../../../common';
+import { useKibana, getInstalledPackages, getAllIntegrations } from '../../../common';
 import * as i18n from './translations';
 import { DEFAULT_DATA_STREAM_VALUES, DEFAULT_INTEGRATION_VALUES } from './constants';
+import { normalizeTitleName } from '../../../common/lib/helper_functions';
 
 export interface IntegrationFormProviderProps {
   children?: React.ReactNode;
@@ -35,17 +36,35 @@ export const IntegrationFormProvider: React.FC<IntegrationFormProviderProps> = (
   const { http, notifications } = useKibana().services;
   const [packageNames, setPackageNames] = useState<Set<string>>();
 
-  // Load installed package names for duplicate title validation
+  // Load installed package names and existing AIV2 integration IDs for duplicate title validation
   useEffect(() => {
     const abortController = new AbortController();
     const deps = { http, abortSignal: abortController.signal };
     (async () => {
       try {
-        const packagesResponse = await getInstalledPackages(deps);
+        const [packagesResponse, aiv2Integrations] = await Promise.all([
+          getInstalledPackages(deps),
+          getAllIntegrations(deps),
+        ]);
         if (abortController.signal.aborted) return;
+
+        const allNames = new Set<string>();
+
+        // Add installed package IDs
         if (packagesResponse?.items?.length) {
-          setPackageNames(new Set(packagesResponse.items.map((pkg) => pkg.id)));
+          packagesResponse.items.forEach((pkg) => allNames.add(pkg.id));
+        }
+
+        // Add AIV2 integration IDs (normalized to match how new titles are converted)
+        if (aiv2Integrations?.length) {
+          aiv2Integrations.forEach((integration) => {
+            // Add both the raw integrationId and the normalized title
+            allNames.add(integration.integrationId);
+            allNames.add(normalizeTitleName(integration.title));
+          });
         }
+
+        setPackageNames(allNames);
       } catch (e) {
         if (!abortController.signal.aborted) {
           notifications?.toasts.addError(e, {