Add support for keyword markers in database enabled_clients

- Add hasKeywordMarkers() utility to detect @@Keyword@@ and ##KEYWORD## patterns
- Modify mapClientID2NameSorted() to preserve strings with keyword markers
- Handle both string and array inputs for enabled_clients configuration
- Add comprehensive test coverage for keyword marker detection and handling
- Fix TypeError when processing databases with template variables

Author: kushalshit27

src/utils.ts

@@ -201,7 +201,27 @@ export function convertClientIdToName(clientId: string, knownClients: Asset[] =
   }
 }
 
-export function mapClientID2NameSorted(enabledClients: string[], knownClients: Asset[]): string[] {
+export function hasKeywordMarkers(value: any): boolean {
+  if (typeof value !== 'string') return false;
+  return /@@[A-Z_]+@@/.test(value) || /##[A-Z_]+##/.test(value);
+}
+
+export function mapClientID2NameSorted(enabledClients: string[] | string, knownClients: Asset[]): string[] | string {
+  // If enabledClients is a string (likely contains keyword markers), return as-is
+  if (typeof enabledClients === 'string') {
+    return enabledClients;
+  }
+  
+  // If enabledClients is null or undefined, return empty array
+  if (!enabledClients) {
+    return [];
+  }
+  
+  // If any element in the array contains keyword markers, return the array as-is
+  if (Array.isArray(enabledClients) && enabledClients.some(client => hasKeywordMarkers(client))) {
+    return enabledClients;
+  }
+  
   return [
     ...(enabledClients || []).map((clientId) => convertClientIdToName(clientId, knownClients)),
   ].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));

test/context/directory/databases.test.js

@@ -354,4 +354,30 @@ describe('#directory context databases', () => {
       strategy: 'auth0',
     });
   });
+
+  it('should dump databases with keyword replacement in enabled_clients', async () => {
+    cleanThenMkdir(dbDumpDir);
+    const context = new Context({ AUTH0_INPUT_FILE: dbDumpDir }, mockMgmtClient());
+
+    context.assets.databases = [
+      {
+        name: 'users',
+        enabled_clients: '@@DATABASE_ENABLED_CLIENTS@@', // String with keyword marker
+        options: {
+          requires_username: true,
+        },
+        strategy: 'auth0',
+      },
+    ];
+
+    // This should not throw a TypeError anymore
+    await handler.dump(context);
+    const scriptsFolder = path.join(dbDumpDir, constants.DATABASE_CONNECTIONS_DIRECTORY, 'users');
+    const dumpedDB = loadJSON(path.join(scriptsFolder, 'database.json'));
+    
+    // The keyword marker should be preserved as-is
+    expect(dumpedDB.enabled_clients).to.equal('@@DATABASE_ENABLED_CLIENTS@@');
+    expect(dumpedDB.name).to.equal('users');
+    expect(dumpedDB.strategy).to.equal('auth0');
+  });
 });

test/tools/utils.test.ts

@@ -1,5 +1,6 @@
 import { expect } from 'chai';
 import { getEnabledClients } from '../../src/tools/utils';
+import { hasKeywordMarkers, mapClientID2NameSorted } from '../../src/utils';
 
 describe('#getEnabledClients', () => {
   const mockExclusions = {};
@@ -62,3 +63,73 @@ describe('#getEnabledClients', () => {
     expect(enabledClients).to.equal(undefined);
   });
 });
+
+describe('#hasKeywordMarkers', () => {
+  it('should detect array keyword markers', () => {
+    const testString = '@@SOME_KEYWORD@@';
+    const result = hasKeywordMarkers(testString);
+    expect(result).to.be.true;
+  });
+
+  it('should detect string keyword markers', () => {
+    const testString = '##SOME_KEYWORD##';
+    const result = hasKeywordMarkers(testString);
+    expect(result).to.be.true;
+  });
+
+  it('should return false for non-string values', () => {
+    const testArray = ['client1', 'client2'];
+    const result = hasKeywordMarkers(testArray);
+    expect(result).to.be.false;
+  });
+
+  it('should return false for strings without markers', () => {
+    const testString = 'regular string';
+    const result = hasKeywordMarkers(testString);
+    expect(result).to.be.false;
+  });
+
+  it('should return false for empty strings', () => {
+    const testString = '';
+    const result = hasKeywordMarkers(testString);
+    expect(result).to.be.false;
+  });
+});
+
+describe('#mapClientID2NameSorted', () => {
+  const mockClients = [
+    { name: 'Client B', client_id: 'client-b-id' },
+    { name: 'Client A', client_id: 'client-a-id' },
+    { name: 'Client C', client_id: 'client-c-id' },
+  ];
+
+  it('should handle array input normally', () => {
+    const enabledClients = ['client-a-id', 'client-b-id'];
+    const result = mapClientID2NameSorted(enabledClients, mockClients);
+    expect(result).to.deep.equal(['Client A', 'Client B']);
+  });
+
+  it('should return string unchanged when input is a string', () => {
+    const enabledClients = '@@DATABASE_ENABLED_CLIENTS@@';
+    const result = mapClientID2NameSorted(enabledClients, mockClients);
+    expect(result).to.equal('@@DATABASE_ENABLED_CLIENTS@@');
+  });
+
+  it('should handle empty array', () => {
+    const enabledClients = [];
+    const result = mapClientID2NameSorted(enabledClients, mockClients);
+    expect(result).to.deep.equal([]);
+  });
+
+  it('should handle null/undefined enabled clients', () => {
+    const result = mapClientID2NameSorted(null, mockClients);
+    expect(result).to.deep.equal([]);
+  });
+
+  it('should preserve keyword markers in arrays', () => {
+    const enabledClientsWithKeywords = ['@@CLIENT_KEYWORD@@', 'client-a-id'];
+    const result = mapClientID2NameSorted(enabledClientsWithKeywords, mockClients);
+    // When an array contains keyword markers, the entire array should be returned as-is
+    expect(result).to.deep.equal(enabledClientsWithKeywords);
+  });
+});