@genesislcap/pbc-reporting-ui 14.396.3 → 14.397.0

package/src/new/main/edit-config/shared/datasource-data-base-component.helpers.ts.ts

@@ -127,9 +127,22 @@ export function datasourceNameFromDisplay(input: string): DatasourceName {
     .replace(/[)]/g, '')
     .split('(')
     .map((x) => x.trim());
-  return (datasourceInputFromDisplay(parts[1] as Display.DatasourceInputTypes) +
-    '_' +
-    parts[0]) as DatasourceName;
+  const type = datasourceInputFromDisplay(parts[1] as Display.DatasourceInputTypes);
+  const name = parts[0];
+
+  const match = Object.entries(selectors.datasourceConfig.getAllConfigSet()).find(
+    ([_, ds]) => ds.KEY === name && ds.INPUT_TYPE === type,
+  );
+
+  if (!match) {
+    /**
+     * This can occur when the datasource is first being initialized and the name
+     * hasn't yet been persisted to the store.
+     */
+    return `${type}_${name}_${name}` as DatasourceName;
+  }
+
+  return match[0] as DatasourceName;
 }
 
 /**
@@ -198,14 +211,11 @@ export async function fetchDatasourceSpecs(
 
   try {
     return await Promise.all(
-      Object.values(selectors.datasourceConfig.getAllConfigSet())
-        .filter(
-          ({ NAME, INPUT_TYPE }) =>
-            INPUT_TYPE === 'REQ_REP' && `${INPUT_TYPE}_${NAME}` === datasourceName,
-        )
-        .map(async ({ NAME }) => ({
-          spec: await getSchema(NAME),
-          name: datasourceNameForDisplay(NAME, 'REQ_REP'),
+      Object.entries(selectors.datasourceConfig.getAllConfigSet())
+        .filter(([key, ds]) => ds.INPUT_TYPE === 'REQ_REP' && key === datasourceName)
+        .map(async ([_, { KEY, NAME }]) => ({
+          spec: await getSchema(NAME), // Fetch schema by Resource Name
+          name: datasourceNameForDisplay(KEY, 'REQ_REP'), // Display Alias
         })),
     );
   } catch (e) {

package/src/new/main/edit-config/shared/datasource-data-base-component.test.ts

@@ -42,11 +42,15 @@ export type SelectRendererParams = Parameters<SelectRenderer['init']>[typeof FIR
 // DatasourceNameFromDisplay tests
 const DatasourceNameFromDisplayTests = suite('datasourceNameFromDisplay()');
 
+DatasourceNameFromDisplayTests.before.each(() => {
+  sinon.restore();
+});
+
 DatasourceNameFromDisplayTests(
   'Correctly builds datasource key from Snapshot (REQ_REP) input',
   () => {
     const input = 'myService (Snapshot)';
-    const expected = 'REQ_REP_myService';
+    const expected = 'REQ_REP_myService_myService';
     assert.equal(datasourceNameFromDisplay(input), expected);
   },
 );
@@ -55,7 +59,7 @@ DatasourceNameFromDisplayTests(
   'Correctly builds datasource key from Data Pipeline (DATA_PIPELINE) input',
   () => {
     const input = 'dataFlow (Data Pipeline)';
-    const expected = 'DATA_PIPELINE_dataFlow';
+    const expected = 'DATA_PIPELINE_dataFlow_dataFlow';
     assert.equal(datasourceNameFromDisplay(input), expected);
   },
 );
@@ -101,6 +105,8 @@ LookupColumnIsIncluded('returns true when column is in included', () => {
     NAME: 'Test Datasource',
     INPUT_TYPE: 'REQ_REP' as const,
     OUTPUT_TYPE: 'TABLE' as const,
+    GROUPING_STRATEGY: 'NONE' as const,
+    GROUP_KEY: null,
     TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: ['testColumn', 'otherColumn'] },
   };
 
@@ -122,6 +128,8 @@ LookupColumnIsIncluded('returns false when column is not in filters', () => {
     NAME: 'Test Datasource',
     INPUT_TYPE: 'REQ_REP' as const,
     OUTPUT_TYPE: 'TABLE' as const,
+    GROUPING_STRATEGY: 'NONE' as const,
+    GROUP_KEY: null,
     TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: ['testColumn', 'otherColumn'] },
   };
 
@@ -143,6 +151,8 @@ LookupColumnIsIncluded('returns false when INCLUDE_COLUMNS is undefined', () =>
     NAME: 'Test Datasource',
     INPUT_TYPE: 'REQ_REP' as const,
     OUTPUT_TYPE: 'TABLE' as const,
+    GROUPING_STRATEGY: 'NONE' as const,
+    GROUP_KEY: null,
     TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: undefined },
   };
 
@@ -164,6 +174,8 @@ LookupColumnIsIncluded('returns false when INCLUDE_COLUMNS is empty array', () =
     NAME: 'Test Datasource',
     INPUT_TYPE: 'REQ_REP' as const,
     OUTPUT_TYPE: 'TABLE' as const,
+    GROUPING_STRATEGY: 'NONE' as const,
+    GROUP_KEY: null,
     TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
   };
 

package/src/new/main/edit-config/tabbed-datasource-container/tabbed-datasource-container.template.ts

@@ -11,7 +11,7 @@ export const template = html<TabbedDatasourceContainer>`
         (_) => Object.entries(selectors.datasourceConfig.getAllConfigSet()),
         html<[DatasourceName, DatasourceConfig[DatasourceName]], TabbedDatasourceContainer>`
           <rapid-tab @click=${(x, c) => c.parent.handleDatasourceChanged(x[0])}>
-            ${(x) => x[1].NAME}
+            ${(x) => x[1].KEY}
           </rapid-tab>
         `,
       )}

package/src/new/store/slices/datasources-config.ts

@@ -6,6 +6,7 @@ import { buildDatasourceName } from '../../utils';
 import { getDefaultFormat } from '../../utils/format-utils';
 import {
   DatasourceConfig,
+  DatasourceGrouping,
   DatasourceName,
   DatasourceOutputTypes,
   deselectedColumns,
@@ -21,18 +22,20 @@ export const datasourceSlice = createSlice({
     initDatasourceConfiguration(
       state: DatasourceConfig,
       action: PayloadAction<{
-        base: Pick<DatasourceConfig[DatasourceName], 'KEY' | 'INPUT_TYPE'>;
+        base: Pick<DatasourceConfig[DatasourceName], 'KEY' | 'NAME' | 'INPUT_TYPE'>;
         fields: string[];
       }>,
     ) {
-      const { KEY, INPUT_TYPE } = action.payload.base;
-      const key: DatasourceName = buildDatasourceName(KEY, INPUT_TYPE);
+      const { KEY, NAME, INPUT_TYPE } = action.payload.base;
+      const key: DatasourceName = buildDatasourceName(KEY, NAME, INPUT_TYPE);
       state[key] = {
         KEY: KEY,
         INPUT_TYPE: INPUT_TYPE,
-        NAME: KEY,
+        NAME: NAME,
         OUTPUT_TYPE: 'TABLE',
         TRANSFORMER_CONFIGURATION: {},
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
       };
       action.payload.fields.forEach((field) => {
         datasourceSlice.caseReducers.setColumnRename(state, {
@@ -54,11 +57,43 @@ export const datasourceSlice = createSlice({
         });
       });
     },
-    updateDatasourceKey(
+    reorderDatasource(
       state: DatasourceConfig,
-      action: PayloadAction<{ key: DatasourceName; newKey: string }>,
+      action: PayloadAction<{ key: DatasourceName; newIndex: number }>,
     ) {
-      state[action.payload.key].KEY = action.payload.newKey;
+      const { key, newIndex } = action.payload;
+      const entries = Object.entries(state);
+      const currentIndex = entries.findIndex(([k]) => k === key);
+
+      if (currentIndex === -1) return state;
+
+      const [item] = entries.splice(currentIndex, 1);
+      entries.splice(newIndex, 0, item);
+
+      return Object.fromEntries(entries) as DatasourceConfig;
+    },
+    renameDatasource(
+      state: DatasourceConfig,
+      action: PayloadAction<{ key: DatasourceName; newName: string }>,
+    ) {
+      const { key: oldKey, newName } = action.payload;
+      const datasource = state[oldKey];
+      if (!datasource) {
+        return;
+      }
+      const newKey = buildDatasourceName(newName, datasource.NAME, datasource.INPUT_TYPE);
+      if (state[newKey] && newKey !== oldKey) {
+        return;
+      }
+
+      return Object.fromEntries(
+        Object.entries(state).map(([k, v]) => {
+          if (k === oldKey) {
+            return [newKey, { ...v, KEY: newName }];
+          }
+          return [k, v];
+        }),
+      ) as DatasourceConfig;
     },
     updateDatasourceOutputType(
       state: DatasourceConfig,
@@ -100,22 +135,26 @@ export const datasourceSlice = createSlice({
         column: string;
         included: boolean;
         type?: Genesis.GenesisFieldTypes;
+        setDefaultFormat?: boolean;
       }>,
     ) {
-      const { key, column, included, type } = action.payload;
+      const { key, column, included, type, setDefaultFormat = true } = action.payload;
       if (included) {
         state[key].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS = [
           ...(state[key].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS ?? []),
           column,
         ];
-        datasourceSlice.caseReducers.setColumnFormat(state, {
-          ...action,
-          payload: {
-            key,
-            column,
-            format: getDefaultFormat(type),
-          },
-        });
+        const defaultFormat = getDefaultFormat(type);
+        if (defaultFormat && setDefaultFormat) {
+          datasourceSlice.caseReducers.setColumnFormat(state, {
+            ...action,
+            payload: {
+              key,
+              column,
+              format: defaultFormat,
+            },
+          });
+        }
       } else {
         state[key].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS = (
           state[key].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS ?? []
@@ -220,6 +259,22 @@ export const datasourceSlice = createSlice({
       const { [column]: _, ...rest } = state[key].TRANSFORMER_CONFIGURATION?.COLUMN_FORMATS ?? {};
       state[key].TRANSFORMER_CONFIGURATION.COLUMN_FORMATS = rest;
     },
+    setGrouping(
+      state: DatasourceConfig,
+      action: PayloadAction<{
+        key: DatasourceName;
+        grouping: Exclude<DatasourceGrouping, { GROUPING_STRATEGY: 'NONE' }>;
+      }>,
+    ) {
+      const { key, grouping } = action.payload;
+      state[key].GROUPING_STRATEGY = grouping.GROUPING_STRATEGY;
+      state[key].GROUP_KEY = grouping.GROUP_KEY;
+    },
+    deleteGrouping(state: DatasourceConfig, action: PayloadAction<{ key: DatasourceName }>) {
+      const { key } = action.payload;
+      state[key].GROUPING_STRATEGY = 'NONE';
+      state[key].GROUP_KEY = null;
+    },
   },
   selectors: {
     getAllConfigSet(state: DatasourceConfig) {

package/src/new/store/slices/types.ts

@@ -16,9 +16,27 @@ export const datasourceOutputs = [
 ] as const;
 export type DatasourceOutputTypes = (typeof datasourceOutputs)[number];
 
-// Key to uniquely identify each data source, must be keyed on the input type as
-// the names are not unique between the different data sources
-export type DatasourceName = `${DatasourceInputTypes}_${string}`;
+export const datasourceGroupingStrategies = ['NONE', 'MULTI_SHEET', 'LOOKUP_TABLE'] as const;
+export type DatasourceGroupingStrategy = (typeof datasourceGroupingStrategies)[number];
+export type DatasourceGrouping =
+  | {
+      GROUPING_STRATEGY: Extract<DatasourceGroupingStrategy, 'NONE'>;
+      GROUP_KEY: null;
+    }
+  | {
+      GROUPING_STRATEGY: Extract<DatasourceGroupingStrategy, 'MULTI_SHEET' | 'LOOKUP_TABLE'>;
+      GROUP_KEY: string;
+    };
+
+/**
+ * Server KEY => This is an alias (this needs to be unique). This is presented as "Name" input on the UI, rapid-text-field
+ * Server NAME => The name of the datasource (matches req_rep). This is presented as rapid-select
+ * DatasoureName to uniquely identify each data source, must be keyed on the input type as
+ * the names are not unique between the different data sources
+ */
+export type AliasKey = string;
+export type ServerDatasourceName = string;
+export type DatasourceName = `${DatasourceInputTypes}_${ServerDatasourceName}_${AliasKey}`;
 
 export type TransformerConfig = {
   COLUMN_RENAMES?: { [k: string]: string };
@@ -44,7 +62,7 @@ export type DatasourceConfig = {
     INPUT_TYPE: DatasourceInputTypes;
     OUTPUT_TYPE: DatasourceOutputTypes;
     TRANSFORMER_CONFIGURATION: TransformerConfig;
-  };
+  } & DatasourceGrouping;
 };
 
 // BASE-CONFIG

package/src/new/types/misc.ts

@@ -1,5 +1,11 @@
 import type { JSONSchema7 as JSONShemaBase } from 'json-schema';
-import type { BaseConfig, DatasourceConfig, DatasourceName, Schedule } from '../store';
+import type {
+  BaseConfig,
+  DatasourceConfig,
+  DatasourceName,
+  Schedule,
+  DatasourceGrouping,
+} from '../store';
 
 export namespace Genesis {
   export const genesisFieldTypes = [
@@ -28,7 +34,8 @@ export namespace Genesis {
   };
 
   export type ServerReportConfig = Omit<BaseConfig, 'SCHEDULE'> & {
-    DATA_SOURCES: DatasourceConfig[DatasourceName][];
+    DATA_SOURCES: (Omit<DatasourceConfig[DatasourceName], 'GROUPING_STRATEGY' | 'GROUP_KEY'> &
+      (Exclude<DatasourceGrouping, { GROUPING_STRATEGY: 'NONE' }> | {}))[];
     SCHEDULES: Schedule[];
   };
 

package/src/new/utils/alias-generator.test.ts

@@ -0,0 +1,44 @@
+import { assert, suite } from '@genesislcap/foundation-testing';
+import { generateUniqueAlias } from './alias-generator';
+
+const GenerateUniqueAlias = suite('generateUniqueAlias');
+
+GenerateUniqueAlias('returns the base alias if it does not exist', () => {
+  const existingAliases = new Set(['other']);
+  const alias = generateUniqueAlias('test', existingAliases);
+  assert.equal(alias, 'test');
+});
+
+GenerateUniqueAlias('increments the alias if it already exists', () => {
+  const existingAliases = new Set(['test']);
+  const alias = generateUniqueAlias('test', existingAliases);
+  assert.equal(alias, 'test_1');
+});
+
+GenerateUniqueAlias('increments the alias until it is unique', () => {
+  const existingAliases = new Set(['test', 'test_1']);
+  const alias = generateUniqueAlias('test', existingAliases);
+  assert.equal(alias, 'test_2');
+});
+
+GenerateUniqueAlias('handles case-insensitivity when checking for existing aliases', () => {
+  const existingAliases = new Set(['Test']);
+  const alias = generateUniqueAlias('test', existingAliases);
+  assert.equal(alias, 'test_1');
+});
+
+GenerateUniqueAlias('handles case-insensitivity for new alias generation', () => {
+  const existingAliases = new Set(['test']);
+  const alias = generateUniqueAlias('Test', existingAliases);
+  // Since input baseAlias is 'Test', it tries 'Test'. 'Test' matches 'test' case-insensitively.
+  // Next attempt 'Test_1'.
+  assert.equal(alias, 'Test_1');
+});
+
+GenerateUniqueAlias('handles mixed case existing aliases', () => {
+  const existingAliases = new Set(['TeSt', 'tEsT_1']);
+  const alias = generateUniqueAlias('test', existingAliases);
+  assert.equal(alias, 'test_2');
+});
+
+GenerateUniqueAlias.run();

package/src/new/utils/alias-generator.ts

@@ -0,0 +1,18 @@
+/**
+ * Generates a unique alias by appending a counter if the base alias already exists in the set.
+ * @param baseAlias The desired alias name (usually the resource name).
+ * @param existingAliases A Set of currently used aliases to check against.
+ * @returns A unique alias string.
+ */
+export function generateUniqueAlias(baseAlias: string, existingAliases: Set<string>): string {
+  const existingAliasesLower = new Set(
+    Array.from(existingAliases).map((alias) => alias.toLowerCase()),
+  );
+  let uniqueAlias = baseAlias;
+  let counter = 1;
+  while (existingAliasesLower.has(uniqueAlias.toLowerCase())) {
+    uniqueAlias = `${baseAlias}_${counter}`;
+    counter += 1;
+  }
+  return uniqueAlias;
+}

package/src/new/utils/index.ts

@@ -1,3 +1,4 @@
+export * from './alias-generator';
 export * from './endpoint';
 export * from './formatters';
 export * from './notifications';

package/src/new/utils/tooltip.ts

@@ -52,6 +52,11 @@ export namespace TOOLTIP {
   </ul>
   `;
 
+  export const DATASOURCES_DATASOURCE = `
+  <h3>Datasource</h3>
+  <p>This is the name of the server resource that data will be pulled from to generate the report.</p>
+`;
+
   export const DATASOURCES_NAME = `
   <h3>Datasource name</h3>
   <p>Allows you to set a name for the datasource which must correspond with your template data references where the report is configured to use a template file.</p>
@@ -63,6 +68,20 @@ export namespace TOOLTIP {
   <p>Configures the method by which the server constructs the report configuration. Currently only TABLE is supported, which means the entire datasource is loaded into memory when generating the report using this report configuration.</p>
 `;
 
+  export const DATASOURCES_GROUPING_STRATEGY = `
+  <h3>Grouping Strategy</h3>
+  <p>Select "None" to disable grouping strategies, or select the strategy you'd like to use.</p>
+  <ul>
+    <li><strong>Multi-sheet</strong>: Group data for <code>JXLS</code> template Multi-sheet functionality, to split different groups across multiple excel worksheets.</li>
+    <li><strong>Lookup-table</strong>: Create a lookup table of key value pairs in the template data, where the group key field is the map key.</li>
+  </ul>
+`;
+
+  export const DATASOURCES_GROUPING_KEY = `
+  <h3>Grouping Key</h3>
+  <p>Select the field for this datasource you want to operate the grouping strategy on.</p>
+`;
+
   export const DELIVERY_TIMEZONE = `
   <h3>Timezone</h3>
   <p>Select the timezone to be used for this schedule.</p>

package/src/new/utils/transformers.test.ts

@@ -1,6 +1,10 @@
 import { assert, sinon, suite } from '@genesislcap/foundation-testing';
 import type { Genesis } from '../types';
-import { buildDatasourceName, transformFromServerPayload } from './transformers';
+import {
+  buildDatasourceName,
+  transformFromServerPayload,
+  transformToServerPayload,
+} from './transformers';
 
 const TransformFromServerPayload = suite('transformFromServerPayload');
 
@@ -39,7 +43,7 @@ TransformFromServerPayload('cleans up orphaned fields from INCLUDE_COLUMNS', asy
 
   const result = await transformFromServerPayload(payload, mockGetSchema);
 
-  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
   const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
 
   assert.equal(cleanedConfig.INCLUDE_COLUMNS?.length, 2);
@@ -83,7 +87,7 @@ TransformFromServerPayload('cleans up orphaned fields from COLUMN_RENAMES', asyn
 
   const result = await transformFromServerPayload(payload, mockGetSchema);
 
-  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
   const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
 
   assert.equal(Object.keys(cleanedConfig.COLUMN_RENAMES || {}).length, 2);
@@ -127,7 +131,7 @@ TransformFromServerPayload('cleans up orphaned fields from COLUMN_FORMATS', asyn
 
   const result = await transformFromServerPayload(payload, mockGetSchema);
 
-  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
   const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
 
   assert.equal(Object.keys(cleanedConfig.COLUMN_FORMATS || {}).length, 2);
@@ -171,7 +175,7 @@ TransformFromServerPayload('cleans up orphaned fields from COLUMN_TRANSFORMS', a
 
   const result = await transformFromServerPayload(payload, mockGetSchema);
 
-  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
   const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
 
   assert.equal(Object.keys(cleanedConfig.COLUMN_TRANSFORMS || {}).length, 2);
@@ -209,7 +213,7 @@ TransformFromServerPayload('handles schema fetch failure gracefully', async () =
 
   const result = await transformFromServerPayload(payload, mockGetSchema);
 
-  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
   const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
 
   // Should keep original config when schema fetch fails
@@ -266,8 +270,8 @@ TransformFromServerPayload('handles multiple datasources independently', async (
 
   const result = await transformFromServerPayload(payload, mockGetSchema);
 
-  const counterpartyKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
-  const tradeKey = buildDatasourceName('TRADE', 'REQ_REP');
+  const counterpartyKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
+  const tradeKey = buildDatasourceName('TRADE', 'TRADE', 'REQ_REP');
 
   assert.equal(
     result.datasourceConfig[counterpartyKey].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS?.length,
@@ -318,7 +322,7 @@ TransformFromServerPayload('handles empty transformer configuration', async () =
 
   const result = await transformFromServerPayload(payload, mockGetSchema);
 
-  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
   const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
 
   assert.equal(JSON.stringify(cleanedConfig), JSON.stringify({}));
@@ -350,7 +354,7 @@ TransformFromServerPayload('handles missing schema properties', async () => {
 
   const result = await transformFromServerPayload(payload, mockGetSchema);
 
-  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
   const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
 
   // All fields should be removed when schema has no properties
@@ -460,7 +464,7 @@ TransformFromServerPayload('handles all transformer config types together', asyn
 
   const result = await transformFromServerPayload(payload, mockGetSchema);
 
-  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+  const datasourceKey = buildDatasourceName('COUNTERPARTY', 'COUNTERPARTY', 'REQ_REP');
   const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
 
   // INCLUDE_COLUMNS should only have valid fields
@@ -485,3 +489,61 @@ TransformFromServerPayload('handles all transformer config types together', asyn
 });
 
 TransformFromServerPayload.run();
+
+const TransformToServerPayload = suite('transformToServerPayload');
+
+TransformToServerPayload('omits grouping fields when strategy is NONE', () => {
+  const state: any = {
+    baseConfig: {
+      DESTINATION_IDS: [],
+      OUTPUT_DIRECTORY: '/reports',
+    },
+    datasourceConfig: {
+      REQ_REP_COUNTERPARTY_COUNTERPARTY: {
+        KEY: 'COUNTERPARTY',
+        INPUT_TYPE: 'REQ_REP',
+        NAME: 'COUNTERPARTY',
+        OUTPUT_TYPE: 'TABLE',
+        TRANSFORMER_CONFIGURATION: {},
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
+      },
+    },
+  };
+
+  const result = transformToServerPayload(state);
+  const ds = result.DATA_SOURCES[0];
+
+  assert.equal(ds.KEY, 'COUNTERPARTY');
+  assert.ok(!('GROUPING_STRATEGY' in ds));
+  assert.ok(!('GROUP_KEY' in ds));
+});
+
+TransformToServerPayload('includes grouping fields when strategy is not NONE', () => {
+  const state: any = {
+    baseConfig: {
+      DESTINATION_IDS: [],
+      OUTPUT_DIRECTORY: '/reports',
+    },
+    datasourceConfig: {
+      REQ_REP_COUNTERPARTY_COUNTERPARTY: {
+        KEY: 'COUNTERPARTY',
+        INPUT_TYPE: 'REQ_REP',
+        NAME: 'COUNTERPARTY',
+        OUTPUT_TYPE: 'TABLE',
+        TRANSFORMER_CONFIGURATION: {},
+        GROUPING_STRATEGY: 'MULTI_SHEET',
+        GROUP_KEY: 'some_key',
+      },
+    },
+  };
+
+  const result = transformToServerPayload(state);
+  const ds = result.DATA_SOURCES[0] as any;
+
+  assert.equal(ds.KEY, 'COUNTERPARTY');
+  assert.equal(ds.GROUPING_STRATEGY, 'MULTI_SHEET');
+  assert.equal(ds.GROUP_KEY, 'some_key');
+});
+
+TransformToServerPayload.run();

package/src/new/utils/transformers.ts

@@ -18,7 +18,14 @@ export function transformToServerPayload(state: ReportingConfig): Genesis.Server
     DOCUMENT_TEMPLATE_ID: restBaseConfig.DOCUMENT_TEMPLATE_ID
       ? restBaseConfig.DOCUMENT_TEMPLATE_ID
       : null,
-    DATA_SOURCES: Object.values(datasourceConfig),
+    DATA_SOURCES: Object.values(datasourceConfig).map((ds) => {
+      // For NONE case we just don't send it to the server to be backwards compatible
+      if (ds.GROUPING_STRATEGY === 'NONE') {
+        const { GROUPING_STRATEGY, GROUP_KEY, ...rest } = ds;
+        return rest;
+      }
+      return ds;
+    }),
   };
 }
 
@@ -85,10 +92,18 @@ export async function transformFromServerPayload(
 
   const cleanedDatasources = await Promise.all(
     DATA_SOURCES.map(
-      async ({ KEY, INPUT_TYPE, NAME: DS_NAME, OUTPUT_TYPE, TRANSFORMER_CONFIGURATION }) => {
+      async ({
+        KEY,
+        INPUT_TYPE,
+        NAME: DS_NAME,
+        OUTPUT_TYPE,
+        TRANSFORMER_CONFIGURATION,
+        ...rest
+      }) => {
         try {
-          const schema = await getSchema(KEY);
+          const schema = await getSchema(DS_NAME);
           const validFields = new Set(Object.keys(schema.properties || {}));
+          const { GROUPING_STRATEGY, GROUP_KEY } = rest as any;
 
           const cleanedConfig = cleanupTransformerConfig(
             TRANSFORMER_CONFIGURATION || {},
@@ -101,16 +116,21 @@ export async function transformFromServerPayload(
             NAME: DS_NAME,
             OUTPUT_TYPE,
             TRANSFORMER_CONFIGURATION: cleanedConfig,
+            GROUPING_STRATEGY: GROUPING_STRATEGY || 'NONE',
+            GROUP_KEY: GROUP_KEY || null,
           };
         } catch (error) {
           // If schema fetch fails, log warning but keep original config
           console.warn(`Failed to fetch schema for ${KEY}, skipping cleanup:`, error);
+          const { GROUPING_STRATEGY, GROUP_KEY } = rest as any;
           return {
             KEY,
             INPUT_TYPE,
             NAME: DS_NAME,
             OUTPUT_TYPE,
             TRANSFORMER_CONFIGURATION: TRANSFORMER_CONFIGURATION || {},
+            GROUPING_STRATEGY: GROUPING_STRATEGY || 'NONE',
+            GROUP_KEY: GROUP_KEY || null,
           };
         }
       },
@@ -122,7 +142,7 @@ export async function transformFromServerPayload(
     datasourceConfig: cleanedDatasources.reduce(
       (acum, ds) => ({
         ...acum,
-        [buildDatasourceName(ds.NAME, ds.INPUT_TYPE)]: ds,
+        [buildDatasourceName(ds.KEY, ds.NAME, ds.INPUT_TYPE)]: ds,
       }),
       {},
     ),
@@ -145,6 +165,10 @@ export function datasourceInputFromDisplay(
   else throw new Error(`datasourceInputFromDisplay - Uncaught case ${display}`);
 }
 
-export function buildDatasourceName(key: string, type: DatasourceInputTypes): DatasourceName {
-  return `${type}_${key}`;
+export function buildDatasourceName(
+  alias: string,
+  resourceName: string,
+  type: DatasourceInputTypes,
+): DatasourceName {
+  return `${type}_${resourceName}_${alias}`;
 }