@genesislcap/pbc-reporting-ui 14.396.3 → 14.397.0

package/dist/esm/new/main/edit-config/datasource-config/datasources-config-container.helpers.js

@@ -1,28 +1,32 @@
 import { __awaiter } from "tslib";
 import { logger } from '@genesislcap/foundation-comms';
 import { actions, selectors } from '../../../store';
-import { buildDatasourceName } from '../../../utils';
+import { buildDatasourceName, generateUniqueAlias } from '../../../utils';
 import { setDefaultFormatsForDatasource } from '../data-transforms-derived-fields/data-transforms.helpers';
 export const createNewDatasourceConfig = (getSchema) => (choices) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
-    const validDatasources = (_a = choices.filter((ds) => !(buildDatasourceName(ds.name, ds.inputType) in
-        selectors.datasourceConfig.getAllConfigSet()))) !== null && _a !== void 0 ? _a : [];
+    const allDatasources = selectors.datasourceConfig.getAllConfigSet();
+    const validDatasources = (_a = choices.filter((ds) => !(buildDatasourceName(ds.name, ds.name, ds.inputType) in allDatasources))) !== null && _a !== void 0 ? _a : [];
     if ((validDatasources === null || validDatasources === void 0 ? void 0 : validDatasources.length) < 1) {
         logger.error('No datasources available to create new config from');
         return;
     }
     const baseConfig = selectors.baseConfig.getConfig();
-    if (Object.keys(selectors.datasourceConfig.getAllConfigSet()).length > 0 &&
+    if (Object.keys(allDatasources).length > 0 &&
         baseConfig.OUTPUT_FORMAT === 'CSV' &&
         !baseConfig.DOCUMENT_TEMPLATE_ID) {
         logger.error('Cannot add multiple datasources when using csv file without a template');
         return;
     }
-    const { KEY, INPUT_TYPE, schema } = yield findFirstValidDatasource(getSchema)(validDatasources);
-    const datasourceName = buildDatasourceName(KEY, INPUT_TYPE);
+    const { KEY: RESOURCE_NAME, INPUT_TYPE, schema, } = yield findFirstValidDatasource(getSchema)(validDatasources);
+    // Check for duplicate aliases
+    const existingAliases = new Set(Object.values(allDatasources).map((ds) => ds.KEY));
+    const uniqueAlias = generateUniqueAlias(RESOURCE_NAME, existingAliases);
+    const datasourceName = buildDatasourceName(uniqueAlias, RESOURCE_NAME, INPUT_TYPE);
     actions.datasourceConfig.initDatasourceConfiguration({
         base: {
-            KEY,
+            KEY: uniqueAlias,
+            NAME: RESOURCE_NAME,
             INPUT_TYPE,
         },
         fields: Object.keys(schema.properties), // Properties is valid as we check in findFirstValidDatasource

package/dist/esm/new/main/edit-config/datasource-config/datasources-config-container.helpers.test.js

@@ -154,14 +154,16 @@ CreateNewDatasourceConfig.before.each(() => {
     sinon.restore();
 });
 CreateNewDatasourceConfig('should exit when no valid datasources are available', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockChoices = [{ name: 'test', inputType: 'REQ_REP' }];
+    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' }];
     const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
-        REQ_REP_test: {
-            KEY: 'REQ_REP_test',
-            NAME: 'Test Datasource',
+        REQ_REP_testSource_testSource: {
+            KEY: 'testSource',
+            NAME: 'testSource',
             INPUT_TYPE: 'REQ_REP',
             OUTPUT_TYPE: 'TABLE',
             TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
+            GROUPING_STRATEGY: 'NONE',
+            GROUP_KEY: null,
         },
     });
     const loggerStub = sinon.stub(logger, 'error');
@@ -172,14 +174,16 @@ CreateNewDatasourceConfig('should exit when no valid datasources are available',
     assert.ok(!getSchemaStub.called);
 }));
 CreateNewDatasourceConfig('should exit when trying to add multiple datasources with CSV format', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockChoices = [{ name: 'test', inputType: 'REQ_REP' }];
+    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' }];
     const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
-        REQ_REP_existing: {
-            KEY: 'REQ_REP_existing',
-            NAME: 'Existing Datasource',
+        REQ_REP_existingSource_existingAlias: {
+            KEY: 'existingAlias',
+            NAME: 'existingSource',
             INPUT_TYPE: 'REQ_REP',
             OUTPUT_TYPE: 'TABLE',
             TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
+            GROUPING_STRATEGY: 'NONE',
+            GROUP_KEY: null,
         },
     });
     const getConfigStub = sinon.stub(selectors.baseConfig, 'getConfig').returns({
@@ -190,7 +194,7 @@ CreateNewDatasourceConfig('should exit when trying to add multiple datasources w
     const loggerStub = sinon.stub(logger, 'error');
     const getSchemaStub = sinon.stub().resolves({});
     yield createNewDatasourceConfig(getSchemaStub)(mockChoices);
-    assert.equal(getAllConfigSetStub.callCount, 2, 'getAllConfigSetStub should be called twice');
+    assert.equal(getAllConfigSetStub.callCount, 1, 'getAllConfigSetStub should be called once');
     assert.equal(getConfigStub.callCount, 1, 'getConfigStub should be called once');
     // assert.ok(loggerStub.calledWith('Cannot add multiple datasources when using csv file without a template'));
     if (loggerStub.args.length > 0) {
@@ -202,14 +206,16 @@ CreateNewDatasourceConfig('should exit when trying to add multiple datasources w
     assert.equal(getSchemaStub.callCount, 0, 'getSchemaStub should not be called');
 }));
 CreateNewDatasourceConfig('should allow adding multiple datasources with CSV format IF template is selected', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockChoices = [{ name: 'test', inputType: 'REQ_REP' }];
+    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' }];
     const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
-        REQ_REP_existing: {
-            KEY: 'REQ_REP_existing',
-            NAME: 'Existing Datasource',
+        REQ_REP_existingSource_existingAlias: {
+            KEY: 'existingAlias',
+            NAME: 'existingSource',
             INPUT_TYPE: 'REQ_REP',
             OUTPUT_TYPE: 'TABLE',
             TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
+            GROUPING_STRATEGY: 'NONE',
+            GROUP_KEY: null,
         },
     });
     sinon.stub(selectors.baseConfig, 'getConfig').returns({
@@ -227,12 +233,12 @@ CreateNewDatasourceConfig('should allow adding multiple datasources with CSV for
     const getSchemaStub = sinon.stub().resolves(mockSchema);
     const initConfigStub = sinon.stub(actions.datasourceConfig, 'initDatasourceConfiguration');
     yield createNewDatasourceConfig(getSchemaStub)(mockChoices);
-    assert.ok(getAllConfigSetStub.calledTwice);
+    assert.ok(getAllConfigSetStub.calledOnce);
     assert.ok(getSchemaStub.calledOnce);
     assert.ok(initConfigStub.called);
 }));
 CreateNewDatasourceConfig('should successfully create new datasource configuration', () => __awaiter(void 0, void 0, void 0, function* () {
-    const mockChoices = [{ name: 'test', inputType: 'REQ_REP' }];
+    const mockChoices = [{ name: 'testSource', inputType: 'REQ_REP' }];
     const getAllConfigSetStub = sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({});
     sinon.stub(selectors.baseConfig, 'getConfig').returns({
         DESTINATION_IDS: [],
@@ -248,14 +254,15 @@ CreateNewDatasourceConfig('should successfully create new datasource configurati
     const getSchemaStub = sinon.stub().resolves(mockSchema);
     const initConfigStub = sinon.stub(actions.datasourceConfig, 'initDatasourceConfiguration');
     yield createNewDatasourceConfig(getSchemaStub)(mockChoices);
-    assert.ok(getAllConfigSetStub.calledTwice);
+    assert.ok(getAllConfigSetStub.calledOnce);
     assert.ok(getSchemaStub.calledOnce);
-    assert.ok(initConfigStub.calledWith({
-        base: {
-            KEY: 'test',
+    assert.ok(initConfigStub.calledWith(sinon.match({
+        base: sinon.match({
+            KEY: 'testSource',
+            NAME: 'testSource',
             INPUT_TYPE: 'REQ_REP',
-        },
-        fields: ['field1', 'field2'],
-    }));
+        }),
+        fields: sinon.match.array.deepEquals(['field1', 'field2']),
+    })));
 }));
 CreateNewDatasourceConfig.run();

package/dist/esm/new/main/edit-config/datasource-config/datasources-config-container.template.js

@@ -27,6 +27,9 @@ const container = html `
   </p>
   <div>
     ${repeat((_) => Object.keys(selectors.datasourceConfig.getAllConfigSet()), html `
+        ${when((_, ctx) => !ctx.isFirst, html `
+            <rapid-divider></rapid-divider>
+          `)}
         <datasource-config-item
           :datasourceName=${(x) => x}
           :datasourceChoices=${(_, c) => c.parent.datasourceChoices}

package/dist/esm/new/main/edit-config/shared/datasource-data-base-component.helpers.ts.js

@@ -77,9 +77,17 @@ export function datasourceNameFromDisplay(input) {
         .replace(/[)]/g, '')
         .split('(')
         .map((x) => x.trim());
-    return (datasourceInputFromDisplay(parts[1]) +
-        '_' +
-        parts[0]);
+    const type = datasourceInputFromDisplay(parts[1]);
+    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}`;
+    }
+    return match[0];
 }
 /**
  * Formats datasource name for display
@@ -137,12 +145,12 @@ export function fetchDatasourceSpecs(datasourceName, getSchema, onError) {
             return [];
         }
         try {
-            return yield Promise.all(Object.values(selectors.datasourceConfig.getAllConfigSet())
-                .filter(({ NAME, INPUT_TYPE }) => INPUT_TYPE === 'REQ_REP' && `${INPUT_TYPE}_${NAME}` === datasourceName)
-                .map((_a) => __awaiter(this, [_a], void 0, function* ({ NAME }) {
+            return yield Promise.all(Object.entries(selectors.datasourceConfig.getAllConfigSet())
+                .filter(([key, ds]) => ds.INPUT_TYPE === 'REQ_REP' && key === datasourceName)
+                .map((_a) => __awaiter(this, [_a], void 0, function* ([_, { KEY, NAME }]) {
                 return ({
-                    spec: yield getSchema(NAME),
-                    name: datasourceNameForDisplay(NAME, 'REQ_REP'),
+                    spec: yield getSchema(NAME), // Fetch schema by Resource Name
+                    name: datasourceNameForDisplay(KEY, 'REQ_REP'), // Display Alias
                 });
             })));
         }

package/dist/esm/new/main/edit-config/shared/datasource-data-base-component.test.js

@@ -17,14 +17,17 @@ function createTestRowData(overrides = {}) {
 const FIRST_PARAM = 0;
 // 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);
 });
 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);
 });
 DatasourceNameFromDisplayTests.run();
@@ -60,6 +63,8 @@ LookupColumnIsIncluded('returns true when column is in included', () => {
         NAME: 'Test Datasource',
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
         TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: ['testColumn', 'otherColumn'] },
     };
     sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
@@ -78,6 +83,8 @@ LookupColumnIsIncluded('returns false when column is not in filters', () => {
         NAME: 'Test Datasource',
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
         TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: ['testColumn', 'otherColumn'] },
     };
     sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
@@ -96,6 +103,8 @@ LookupColumnIsIncluded('returns false when INCLUDE_COLUMNS is undefined', () =>
         NAME: 'Test Datasource',
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
         TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: undefined },
     };
     sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
@@ -114,6 +123,8 @@ LookupColumnIsIncluded('returns false when INCLUDE_COLUMNS is empty array', () =
         NAME: 'Test Datasource',
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
         TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
     };
     sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);

package/dist/esm/new/main/edit-config/tabbed-datasource-container/tabbed-datasource-container.template.js

@@ -7,7 +7,7 @@ export const template = html `
     <rapid-tabs ${ref('tabs')}>
       ${repeat((_) => Object.entries(selectors.datasourceConfig.getAllConfigSet()), html `
           <rapid-tab @click=${(x, c) => c.parent.handleDatasourceChanged(x[0])}>
-            ${(x) => x[1].NAME}
+            ${(x) => x[1].KEY}
           </rapid-tab>
         `)}
       <!-- rapid-tab-panel unused for content, only used to make the rapid-tabs work correctly -->

package/dist/esm/new/store/slices/datasources-config.js

@@ -10,14 +10,16 @@ export const datasourceSlice = createSlice({
     initialState,
     reducers: {
         initDatasourceConfiguration(state, action) {
-            const { KEY, INPUT_TYPE } = action.payload.base;
-            const key = buildDatasourceName(KEY, INPUT_TYPE);
+            const { KEY, NAME, INPUT_TYPE } = action.payload.base;
+            const key = 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, Object.assign(Object.assign({}, action), { payload: {
@@ -33,8 +35,32 @@ export const datasourceSlice = createSlice({
                     } }));
             });
         },
-        updateDatasourceKey(state, action) {
-            state[action.payload.key].KEY = action.payload.newKey;
+        reorderDatasource(state, action) {
+            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);
+        },
+        renameDatasource(state, action) {
+            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, Object.assign(Object.assign({}, v), { KEY: newName })];
+                }
+                return [k, v];
+            }));
         },
         updateDatasourceOutputType(state, action) {
             state[action.payload.key].OUTPUT_TYPE = action.payload.newType;
@@ -59,17 +85,20 @@ export const datasourceSlice = createSlice({
          */
         setColumnIncluded(state, action) {
             var _a, _b;
-            const { key, column, included, type } = action.payload;
+            const { key, column, included, type, setDefaultFormat = true } = action.payload;
             if (included) {
                 state[key].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS = [
                     ...((_a = state[key].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) !== null && _a !== void 0 ? _a : []),
                     column,
                 ];
-                datasourceSlice.caseReducers.setColumnFormat(state, Object.assign(Object.assign({}, action), { payload: {
-                        key,
-                        column,
-                        format: getDefaultFormat(type),
-                    } }));
+                const defaultFormat = getDefaultFormat(type);
+                if (defaultFormat && setDefaultFormat) {
+                    datasourceSlice.caseReducers.setColumnFormat(state, Object.assign(Object.assign({}, action), { payload: {
+                            key,
+                            column,
+                            format: defaultFormat,
+                        } }));
+                }
             }
             else {
                 state[key].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS = ((_b = state[key].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) !== null && _b !== void 0 ? _b : []).filter((col) => col !== column);
@@ -119,6 +148,16 @@ export const datasourceSlice = createSlice({
             const _c = (_b = (_a = state[key].TRANSFORMER_CONFIGURATION) === null || _a === void 0 ? void 0 : _a.COLUMN_FORMATS) !== null && _b !== void 0 ? _b : {}, _d = column, _ = _c[_d], rest = __rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
             state[key].TRANSFORMER_CONFIGURATION.COLUMN_FORMATS = rest;
         },
+        setGrouping(state, action) {
+            const { key, grouping } = action.payload;
+            state[key].GROUPING_STRATEGY = grouping.GROUPING_STRATEGY;
+            state[key].GROUP_KEY = grouping.GROUP_KEY;
+        },
+        deleteGrouping(state, action) {
+            const { key } = action.payload;
+            state[key].GROUPING_STRATEGY = 'NONE';
+            state[key].GROUP_KEY = null;
+        },
     },
     selectors: {
         getAllConfigSet(state) {

package/dist/esm/new/store/slices/types.js

@@ -8,5 +8,6 @@ export const datasourceOutputs = [
     // 'RECORD_STREAM',
     'TABLE',
 ];
+export const datasourceGroupingStrategies = ['NONE', 'MULTI_SHEET', 'LOOKUP_TABLE'];
 // BASE-CONFIG
 export const reportOutputFormats = ['CSV', 'PDF', 'XLSX'];

package/dist/esm/new/utils/alias-generator.js

@@ -0,0 +1,16 @@
+/**
+ * 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, existingAliases) {
+    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/dist/esm/new/utils/alias-generator.test.js

@@ -0,0 +1,36 @@
+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/dist/esm/new/utils/index.js

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

package/dist/esm/new/utils/tooltip.js

@@ -44,6 +44,10 @@ export var TOOLTIP;
     <li>Where File type is set to <strong>PDF</strong> you must select a <code>.html</code> or <code>.xhtml</code> template that you've uploaded to the document manager PBC</li>
   </ul>
   `;
+    TOOLTIP.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>
+`;
     TOOLTIP.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>
@@ -52,6 +56,18 @@ export var TOOLTIP;
     TOOLTIP.DATASOURCES_TYPE = `
   <h3>Datasource type</h3>
   <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>
+`;
+    TOOLTIP.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>
+`;
+    TOOLTIP.DATASOURCES_GROUPING_KEY = `
+  <h3>Grouping Key</h3>
+  <p>Select the field for this datasource you want to operate the grouping strategy on.</p>
 `;
     TOOLTIP.DELIVERY_TIMEZONE = `
   <h3>Timezone</h3>

package/dist/esm/new/utils/transformers.js

@@ -10,7 +10,14 @@ export function transformToServerPayload(state) {
         // TODO: server workaround - currently need to explicitly set to null if unset
         DOCUMENT_TEMPLATE_ID: restBaseConfig.DOCUMENT_TEMPLATE_ID
             ? restBaseConfig.DOCUMENT_TEMPLATE_ID
-            : null, DATA_SOURCES: Object.values(datasourceConfig) });
+            : null, 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 } = ds, rest = __rest(ds, ["GROUPING_STRATEGY", "GROUP_KEY"]);
+                return rest;
+            }
+            return ds;
+        }) });
 }
 /**
  * Cleans up orphaned field references from transformer configuration
@@ -46,10 +53,12 @@ export function transformFromServerPayload(payload, getSchema) {
             DESTINATION_IDS,
             OUTPUT_DIRECTORY,
             DOCUMENT_TEMPLATE_ID }, (SCHEDULES.length > 0 && { SCHEDULE: SCHEDULES[0] }));
-        const cleanedDatasources = yield Promise.all(DATA_SOURCES.map((_a) => __awaiter(this, [_a], void 0, function* ({ KEY, INPUT_TYPE, NAME: DS_NAME, OUTPUT_TYPE, TRANSFORMER_CONFIGURATION }) {
+        const cleanedDatasources = yield Promise.all(DATA_SOURCES.map((_a) => __awaiter(this, void 0, void 0, function* () {
+            var { KEY, INPUT_TYPE, NAME: DS_NAME, OUTPUT_TYPE, TRANSFORMER_CONFIGURATION } = _a, rest = __rest(_a, ["KEY", "INPUT_TYPE", "NAME", "OUTPUT_TYPE", "TRANSFORMER_CONFIGURATION"]);
             try {
-                const schema = yield getSchema(KEY);
+                const schema = yield getSchema(DS_NAME);
                 const validFields = new Set(Object.keys(schema.properties || {}));
+                const { GROUPING_STRATEGY, GROUP_KEY } = rest;
                 const cleanedConfig = cleanupTransformerConfig(TRANSFORMER_CONFIGURATION || {}, validFields);
                 return {
                     KEY,
@@ -57,23 +66,28 @@ export function transformFromServerPayload(payload, getSchema) {
                     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;
                 return {
                     KEY,
                     INPUT_TYPE,
                     NAME: DS_NAME,
                     OUTPUT_TYPE,
                     TRANSFORMER_CONFIGURATION: TRANSFORMER_CONFIGURATION || {},
+                    GROUPING_STRATEGY: GROUPING_STRATEGY || 'NONE',
+                    GROUP_KEY: GROUP_KEY || null,
                 };
             }
         })));
         return {
             baseConfig,
-            datasourceConfig: cleanedDatasources.reduce((acum, ds) => (Object.assign(Object.assign({}, acum), { [buildDatasourceName(ds.NAME, ds.INPUT_TYPE)]: ds })), {}),
+            datasourceConfig: cleanedDatasources.reduce((acum, ds) => (Object.assign(Object.assign({}, acum), { [buildDatasourceName(ds.KEY, ds.NAME, ds.INPUT_TYPE)]: ds })), {}),
         };
     });
 }
@@ -93,6 +107,6 @@ export function datasourceInputFromDisplay(display) {
     else
         throw new Error(`datasourceInputFromDisplay - Uncaught case ${display}`);
 }
-export function buildDatasourceName(key, type) {
-    return `${type}_${key}`;
+export function buildDatasourceName(alias, resourceName, type) {
+    return `${type}_${resourceName}_${alias}`;
 }