@genesislcap/pbc-reporting-ui 14.396.4 → 14.397.1

package/dist/dts/new/utils/tooltip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../../src/new/utils/tooltip.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,6DAElD,CAAC;AAMF,eAAO,MAAM,eAAe,0DAA0C,CAAC;AAEvE,yBAAiB,OAAO,CAAC;IAChB,MAAM,UAAU,uJAGxB,CAAC;IAEO,MAAM,cAAc,+KAI5B,CAAC;IAEO,MAAM,eAAe,8IAG7B,CAAC;IAEO,MAAM,iBAAiB,2IAG/B,CAAC;IAEO,MAAM,eAAe,ybAQ7B,CAAC;IAEO,MAAM,mBAAmB,65BAQ/B,CAAC;IAEK,MAAM,gBAAgB,uWAI9B,CAAC;IAEO,MAAM,gBAAgB,mRAG9B,CAAC;IAEO,MAAM,iBAAiB,wFAG/B,CAAC;IAEO,MAAM,gBAAgB,qGAG9B,CAAC;CACD"}
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../../src/new/utils/tooltip.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,6DAElD,CAAC;AAMF,eAAO,MAAM,eAAe,0DAA0C,CAAC;AAEvE,yBAAiB,OAAO,CAAC;IAChB,MAAM,UAAU,uJAGxB,CAAC;IAEO,MAAM,cAAc,+KAI5B,CAAC;IAEO,MAAM,eAAe,8IAG7B,CAAC;IAEO,MAAM,iBAAiB,2IAG/B,CAAC;IAEO,MAAM,eAAe,ybAQ7B,CAAC;IAEO,MAAM,mBAAmB,65BAQ/B,CAAC;IAEK,MAAM,sBAAsB,sIAGpC,CAAC;IAEO,MAAM,gBAAgB,uWAI9B,CAAC;IAEO,MAAM,gBAAgB,mRAG9B,CAAC;IAEO,MAAM,6BAA6B,6dAO3C,CAAC;IAEO,MAAM,wBAAwB,6HAGtC,CAAC;IAEO,MAAM,iBAAiB,wFAG/B,CAAC;IAEO,MAAM,gBAAgB,qGAG9B,CAAC;CACD"}

package/dist/dts/new/utils/transformers.d.ts

@@ -5,5 +5,5 @@ export declare function transformToServerPayload(state: ReportingConfig): Genesi
 export declare function transformFromServerPayload(payload: Genesis.ServerReportConfig, getSchema: (name: string) => Promise<JSONSchema7>): Promise<ReportingConfig>;
 export declare function datasourceInputForDisplay(input: DatasourceInputTypes): Display.DatasourceInputTypes;
 export declare function datasourceInputFromDisplay(display: Display.DatasourceInputTypes): DatasourceInputTypes;
-export declare function buildDatasourceName(key: string, type: DatasourceInputTypes): DatasourceName;
+export declare function buildDatasourceName(alias: string, resourceName: string, type: DatasourceInputTypes): DatasourceName;
 //# sourceMappingURL=transformers.d.ts.map

package/dist/dts/new/utils/transformers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../../../../src/new/utils/transformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAc,oBAAoB,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAElG,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAE5C,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAiB3F;AAiCD,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,OAAO,CAAC,kBAAkB,EACnC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,GAChD,OAAO,CAAC,eAAe,CAAC,CAuE1B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,oBAAoB,CAI9B;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,CAAC,oBAAoB,GACpC,oBAAoB,CAItB;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,oBAAoB,GAAG,cAAc,CAE3F"}
+{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../../../../src/new/utils/transformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAc,oBAAoB,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAElG,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAE5C,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAwB3F;AAiCD,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,OAAO,CAAC,kBAAkB,EACnC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,GAChD,OAAO,CAAC,eAAe,CAAC,CAoF1B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,oBAAoB,CAI9B;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,CAAC,oBAAoB,GACpC,oBAAoB,CAItB;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,oBAAoB,GACzB,cAAc,CAEhB"}

package/dist/esm/new/main/edit-config/col-filters/col-filters-grid.helpers.test.js

@@ -38,6 +38,8 @@ RowSelectionChangedHandler('should return early if filtered state matches select
         TRANSFORMER_CONFIGURATION: {
             COLUMN_FILTERS: ['testColumn'],
         },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     rowSelectionChangedHandler(mockEvent);
     assert.equal(lookupStub.called, true);
@@ -66,6 +68,8 @@ RowSelectionChangedHandler('should return early if type is invalid', () => {
         TRANSFORMER_CONFIGURATION: {
             COLUMN_FILTERS: [],
         },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     rowSelectionChangedHandler(mockEvent);
     assert.equal(lookupStub.called, true);
@@ -73,7 +77,7 @@ RowSelectionChangedHandler('should return early if type is invalid', () => {
 });
 RowSelectionChangedHandler('should update include and redraw when selection changes', () => {
     const mockData = {
-        [GridColumnNames.Datasource]: 'TEST (Snapshot)',
+        [GridColumnNames.Datasource]: 'testAlias (Snapshot)',
         [GridColumnNames.ColumnName]: 'testColumn',
         [GridColumnNames.Type]: 'INT',
     };
@@ -88,17 +92,30 @@ RowSelectionChangedHandler('should update include and redraw when selection chan
     };
     const setColumnIncludedStub = sinon.stub(actions.datasourceConfig, 'setColumnIncluded');
     sinon.stub(selectors.datasourceConfig, 'getDatasource').returns({
-        KEY: 'test',
-        NAME: 'Test Datasource',
+        KEY: 'testSource',
+        NAME: 'testAlias',
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
         TRANSFORMER_CONFIGURATION: {
             INCLUDE_COLUMNS: ['testColumn'],
         },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
+    });
+    sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
+        REQ_REP_testSource_testAlias: {
+            KEY: 'testAlias',
+            NAME: 'testSource',
+            INPUT_TYPE: 'REQ_REP',
+            OUTPUT_TYPE: 'TABLE',
+            TRANSFORMER_CONFIGURATION: {},
+            GROUPING_STRATEGY: 'NONE',
+            GROUP_KEY: null,
+        },
     });
     rowSelectionChangedHandler(mockEvent);
     assert.equal(setColumnIncludedStub.calledOnce, true);
-    assert.equal(setColumnIncludedStub.getCall(0).args[0].key, 'REQ_REP_TEST');
+    assert.equal(setColumnIncludedStub.getCall(0).args[0].key, 'REQ_REP_testSource_testAlias');
     assert.equal(setColumnIncludedStub.getCall(0).args[0].column, 'testColumn');
     assert.equal(setColumnIncludedStub.getCall(0).args[0].included, false);
     assert.equal(setColumnIncludedStub.getCall(0).args[0].setDefaultFormat, true);
@@ -129,6 +146,8 @@ RowSelectionChangedHandler('should not set default format if output format is XL
         TRANSFORMER_CONFIGURATION: {
             INCLUDE_COLUMNS: ['testColumn'],
         },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     rowSelectionChangedHandler(mockEvent);
     assert.equal(setColumnIncludedStub.calledOnce, true);
@@ -136,7 +155,7 @@ RowSelectionChangedHandler('should not set default format if output format is XL
 });
 RowSelectionChangedHandler('should handle undefined selection state', () => {
     const mockData = {
-        [GridColumnNames.Datasource]: 'TEST (Snapshot)',
+        [GridColumnNames.Datasource]: 'testAlias (Snapshot)',
         [GridColumnNames.ColumnName]: 'testColumn',
         [GridColumnNames.Type]: 'INT',
     };
@@ -151,13 +170,26 @@ RowSelectionChangedHandler('should handle undefined selection state', () => {
     };
     const setColumnIncludedStub = sinon.stub(actions.datasourceConfig, 'setColumnIncluded');
     sinon.stub(selectors.datasourceConfig, 'getDatasource').returns({
-        KEY: 'test',
-        NAME: 'Test Datasource',
+        KEY: 'testSource',
+        NAME: 'testAlias',
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
         TRANSFORMER_CONFIGURATION: {
             COLUMN_FILTERS: ['testColumn'],
         },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
+    });
+    sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
+        REQ_REP_testSource_testAlias: {
+            KEY: 'testAlias',
+            NAME: 'testSource',
+            INPUT_TYPE: 'REQ_REP',
+            OUTPUT_TYPE: 'TABLE',
+            TRANSFORMER_CONFIGURATION: {},
+            GROUPING_STRATEGY: 'NONE',
+            GROUP_KEY: null,
+        },
     });
     rowSelectionChangedHandler(mockEvent);
     assert.equal(setColumnIncludedStub.calledOnce, true);

package/dist/esm/new/main/edit-config/col-rename-alias/col-rename-alias-grid.helpers.test.js

@@ -21,6 +21,8 @@ LookupColumnRename('should return original data when no rename is found', () =>
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
         TRANSFORMER_CONFIGURATION: { COLUMN_RENAMES: {} },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     const result = lookupColumnRename(mockData);
     assert.equal(result, mockData);
@@ -45,6 +47,8 @@ LookupColumnRename('should return data with renamed display name when rename exi
                 [originalColumn]: newDisplayName,
             },
         },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     const result = lookupColumnRename(mockData);
     assert.equal(result[GridColumnNames.DisplayName], newDisplayName);
@@ -66,6 +70,8 @@ LookupColumnRename('should handle undefined COLUMN_RENAMES', () => {
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
         TRANSFORMER_CONFIGURATION: {},
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     const result = lookupColumnRename(mockData);
     assert.equal(result, mockData);
@@ -80,17 +86,28 @@ DisplayNameOnChangeHandler('calls setColumnRename with correct parameters when v
     const callback = sinon.spy();
     const handler = displayNameOnChangeHandler(callback);
     const mockData = {
-        [GridColumnNames.Datasource]: 'testSource (Snapshot)',
+        [GridColumnNames.Datasource]: 'testAlias (Snapshot)',
         [GridColumnNames.ColumnName]: 'originalColumn',
         [GridColumnNames.DisplayName]: 'Original Display',
         [GridColumnNames.Type]: 'STRING',
     };
     const setColumnRenameStub = sinon.stub(actions.datasourceConfig, 'setColumnRename');
+    sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
+        REQ_REP_testSource_testAlias: {
+            KEY: 'testAlias',
+            NAME: 'testSource',
+            INPUT_TYPE: 'REQ_REP',
+            OUTPUT_TYPE: 'TABLE',
+            TRANSFORMER_CONFIGURATION: {},
+            GROUPING_STRATEGY: 'NONE',
+            GROUP_KEY: null,
+        },
+    });
     handler('newColumn', { data: mockData });
     assert.equal(setColumnRenameStub.calledOnce, true);
     // Check each property individually instead of using deepEqual
     const firstCallArg = setColumnRenameStub.firstCall.args[0];
-    assert.equal(firstCallArg.key, 'REQ_REP_testSource');
+    assert.equal(firstCallArg.key, 'REQ_REP_testSource_testAlias');
     assert.equal(firstCallArg.columnFrom, 'originalColumn');
     assert.equal(firstCallArg.columnTo, 'newColumn');
     assert.equal(callback.called, false);
@@ -99,17 +116,28 @@ DisplayNameOnChangeHandler('removes prohibited characters and calls callback', (
     const callback = sinon.spy();
     const handler = displayNameOnChangeHandler(callback);
     const mockData = {
-        [GridColumnNames.Datasource]: 'testSource (Snapshot)',
+        [GridColumnNames.Datasource]: 'testAlias (Snapshot)',
         [GridColumnNames.ColumnName]: 'originalColumn',
         [GridColumnNames.DisplayName]: 'Original Display',
         [GridColumnNames.Type]: 'STRING',
     };
     const setColumnRenameStub = sinon.stub(actions.datasourceConfig, 'setColumnRename');
+    sinon.stub(selectors.datasourceConfig, 'getAllConfigSet').returns({
+        REQ_REP_testSource_testAlias: {
+            KEY: 'testAlias',
+            NAME: 'testSource',
+            INPUT_TYPE: 'REQ_REP',
+            OUTPUT_TYPE: 'TABLE',
+            TRANSFORMER_CONFIGURATION: {},
+            GROUPING_STRATEGY: 'NONE',
+            GROUP_KEY: null,
+        },
+    });
     handler('new@Column-=+test', { data: mockData });
     assert.equal(setColumnRenameStub.calledOnce, true);
     // Check each property individually instead of using deepEqual
     const firstCallArg = setColumnRenameStub.firstCall.args[0];
-    assert.equal(firstCallArg.key, 'REQ_REP_testSource');
+    assert.equal(firstCallArg.key, 'REQ_REP_testSource_testAlias');
     assert.equal(firstCallArg.columnFrom, 'originalColumn');
     assert.equal(firstCallArg.columnTo, 'newColumntest');
     assert.equal(callback.calledOnce, true);

package/dist/esm/new/main/edit-config/data-transforms-derived-fields/data-transforms.helpers.test.js

@@ -20,6 +20,8 @@ LookupColumnFormat('should return empty string when no format is found', () => {
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
         TRANSFORMER_CONFIGURATION: { COLUMN_FORMATS: {} },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     const result = lookupColumnFormat(mockData);
     assert.equal(result[GridColumnNames.Format], ''); // No format found, returns empty string
@@ -44,6 +46,8 @@ LookupColumnFormat('should return data with format when format exists', () => {
                 [originalColumn]: newFormat,
             },
         },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     const result = lookupColumnFormat(mockData);
     assert.equal(result[GridColumnNames.Format], newFormat);
@@ -65,6 +69,8 @@ LookupColumnFormat('should handle undefined COLUMN_FORMATS', () => {
         INPUT_TYPE: 'REQ_REP',
         OUTPUT_TYPE: 'TABLE',
         TRANSFORMER_CONFIGURATION: {},
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     const result = lookupColumnFormat(mockData);
     assert.equal(result[GridColumnNames.Format], ''); // No format found, returns empty string
@@ -87,6 +93,8 @@ LookupColumnFormat('should return existing format when format exists', () => {
                 numericColumn: '#.##',
             },
         },
+        GROUPING_STRATEGY: 'NONE',
+        GROUP_KEY: null,
     });
     const result = lookupColumnFormat(mockData);
     assert.equal(result[GridColumnNames.Format], '#.##'); // Existing format is returned
@@ -363,7 +371,7 @@ ValueExprCellRendereronChange.before.each(() => {
     sinon.restore();
 });
 ValueExprCellRendereronChange('should call setColumnTransform when model exists', () => {
-    const datasourceKey = 'REQ_REP_Test';
+    const datasourceKey = 'REQ_REP_RESOURCE_ALIAS';
     const columnName = 'testColumn';
     // Using type assertions to match the expected type
     const mockExpression = {
@@ -403,7 +411,7 @@ ValueExprCellRendereronChange('should call setColumnTransform when model exists'
     assert.equal(deleteColumnTransformStub.called, false);
 });
 ValueExprCellRendereronChange('should call deleteColumnTransform when model is null', () => {
-    const datasourceKey = 'REQ_REP_Test';
+    const datasourceKey = 'REQ_REP_RESOURCE_ALIAS';
     const columnName = 'testColumn';
     const mockParams = {
         data: {

package/dist/esm/new/main/edit-config/datasource-config/datasource-config-item.js

@@ -1,8 +1,8 @@
 import { __awaiter, __decorate } from "tslib";
 import { Connect } from '@genesislcap/foundation-comms';
 import { attr, customElement, GenesisElement, observable } from '@genesislcap/web-core';
-import { actions, } from '../../../store';
-import { buildDatasourceName, datasourceInputFromDisplay, getDatasourceSchema, showNotificationToast, } from '../../../utils';
+import { actions, selectors, } from '../../../store';
+import { buildDatasourceName, datasourceInputFromDisplay, generateUniqueAlias, getDatasourceSchema, showNotificationToast, } from '../../../utils';
 import { setDefaultFormatsForDatasource } from '../data-transforms-derived-fields/data-transforms.helpers';
 import { styles } from './datasource-config-item.styles';
 import { template } from './datasource-config-item.template';
@@ -12,10 +12,27 @@ let DatasourceConfigItem = class DatasourceConfigItem extends GenesisElement {
         this.getSchema = getDatasourceSchema(this.connect);
         this.datasourceName = null;
         this.datasourceChoices = null;
+        this.groupingByFieldsNames = null;
         this.canRemove = false;
         this.position = 'below';
         this.error = 'none';
     }
+    connectedCallback() {
+        const _super = Object.create(null, {
+            connectedCallback: { get: () => super.connectedCallback }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.connectedCallback.call(this);
+            try {
+                const datasource = selectors.datasourceConfig.getDatasource(this.datasourceName);
+                const schema = yield this.getSchema(datasource.NAME);
+                this.groupingByFieldsNames = Object.keys(schema.properties);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+    }
     deleteDatasourceHandler() {
         if (!this.canRemove)
             throw new Error('Trying to remove final datasource!');
@@ -25,13 +42,28 @@ let DatasourceConfigItem = class DatasourceConfigItem extends GenesisElement {
             key: this.datasourceName,
         });
     }
-    updateKeyHandler(newKey) {
+    updateKeyHandler(newName, event) {
         if (!this.datasourceName) {
             throw new Error('updateKeyHandler - datasourceName unset');
         }
-        actions.datasourceConfig.updateDatasourceKey({
+        const allDatasources = selectors.datasourceConfig.getAllConfigSet();
+        const nameExists = Object.entries(allDatasources)
+            .filter(([key]) => key !== this.datasourceName)
+            .some(([, ds]) => ds.KEY.toLowerCase() === newName.toLowerCase());
+        if (nameExists) {
+            showNotificationToast({
+                title: 'Reporting Config',
+                body: `Name '${newName}' is already in use by another datasource.`,
+                toast: { type: 'error' },
+            });
+            if (event) {
+                event.target.value = allDatasources[this.datasourceName].KEY;
+            }
+            return;
+        }
+        actions.datasourceConfig.renameDatasource({
             key: this.datasourceName,
-            newKey,
+            newName,
         });
     }
     updateOutputTypeHandler(newType) {
@@ -43,6 +75,45 @@ let DatasourceConfigItem = class DatasourceConfigItem extends GenesisElement {
             newType,
         });
     }
+    updateGroupingStrategyHandler(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (value === 'NONE') {
+                    actions.datasourceConfig.deleteGrouping({ key: this.datasourceName });
+                    return;
+                }
+                const dsResource = selectors.datasourceConfig.getDatasource(this.datasourceName).NAME;
+                const schema = yield this.getSchema(dsResource);
+                if (!schema.properties)
+                    throw new Error(`schema properties for ${dsResource} undefined`);
+                const fields = Object.keys(schema.properties);
+                actions.datasourceConfig.setGrouping({
+                    key: this.datasourceName,
+                    grouping: { GROUPING_STRATEGY: value, GROUP_KEY: fields[0] },
+                });
+                this.groupingByFieldsNames = Object.keys(schema.properties);
+            }
+            catch (e) {
+                const errorMsg = e instanceof Error ? `\n\n${e.message}` : '';
+                showNotificationToast({
+                    title: 'Reporting Config',
+                    body: `Error fetching field data for datasource ${this.datasourceName}.${errorMsg}`,
+                    toast: { type: 'critical' },
+                });
+                this.error = 'unknown';
+                console.error(e);
+            }
+        });
+    }
+    updateGroupingByHandler(value) {
+        const datasource = selectors.datasourceConfig.getDatasource(this.datasourceName);
+        if (datasource.GROUPING_STRATEGY === 'NONE')
+            throw new Error('Cannot set group by field when GROUPING_STRATEGY is NONE');
+        actions.datasourceConfig.setGrouping({
+            key: this.datasourceName,
+            grouping: { GROUPING_STRATEGY: datasource.GROUPING_STRATEGY, GROUP_KEY: value },
+        });
+    }
     updateDatasourceSourceHandler(selectedOption) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -54,7 +125,7 @@ let DatasourceConfigItem = class DatasourceConfigItem extends GenesisElement {
                     return;
                 }
                 const option = selectedOption.selectedOptions[0];
-                const KEY = option.value;
+                const RESOURCE_NAME = option.value;
                 const dataAttr = (option.getAttribute('data-bubble-content'));
                 if (!dataAttr)
                     throw new Error(`Unable to read datasource from attribute ${dataAttr}`);
@@ -62,21 +133,37 @@ let DatasourceConfigItem = class DatasourceConfigItem extends GenesisElement {
                 if (!this.datasourceName || !INPUT_TYPE) {
                     throw new Error('updateKeyHandler - datasourceName or INPUT_TYPE null');
                 }
-                const schema = yield this.getSchema(KEY);
+                const schema = yield this.getSchema(RESOURCE_NAME);
                 if (!schema.properties)
-                    throw new Error(`schema properties for ${KEY} undefined`);
+                    throw new Error(`schema properties for ${RESOURCE_NAME} undefined`);
                 const fields = Object.keys(schema.properties);
+                // Check for duplicate aliases
+                const allDatasources = selectors.datasourceConfig.getAllConfigSet();
+                const existingAliases = new Set(Object.entries(allDatasources)
+                    .filter(([key]) => key !== this.datasourceName)
+                    .map(([, ds]) => ds.KEY));
+                const uniqueAlias = generateUniqueAlias(RESOURCE_NAME, existingAliases);
+                // Preserve index
+                const originalIndex = Object.keys(allDatasources).indexOf(this.datasourceName);
                 actions.datasourceConfig.deleteDatasource({ key: this.datasourceName });
                 actions.datasourceConfig.initDatasourceConfiguration({
                     base: {
-                        KEY,
+                        KEY: uniqueAlias,
+                        NAME: RESOURCE_NAME,
                         INPUT_TYPE: INPUT_TYPE,
                     },
                     fields,
                 });
-                const datasourceName = buildDatasourceName(KEY, INPUT_TYPE);
+                const datasourceName = buildDatasourceName(uniqueAlias, RESOURCE_NAME, INPUT_TYPE);
+                if (originalIndex !== -1) {
+                    actions.datasourceConfig.reorderDatasource({
+                        key: datasourceName,
+                        newIndex: originalIndex,
+                    });
+                }
                 setDefaultFormatsForDatasource(datasourceName, schema);
                 this.error = 'none';
+                this.groupingByFieldsNames = Object.keys(schema.properties);
             }
             catch (e) {
                 const errorMsg = e instanceof Error ? `\n\n${e.message}` : '';
@@ -100,6 +187,9 @@ __decorate([
 __decorate([
     observable
 ], DatasourceConfigItem.prototype, "datasourceChoices", void 0);
+__decorate([
+    observable
+], DatasourceConfigItem.prototype, "groupingByFieldsNames", void 0);
 __decorate([
     attr({ mode: 'boolean', attribute: 'can-remove' })
 ], DatasourceConfigItem.prototype, "canRemove", void 0);

package/dist/esm/new/main/edit-config/datasource-config/datasource-config-item.styles.js

@@ -8,6 +8,12 @@ export const styles = css `
     gap: calc(var(--design-unit) * 2px);
   }
 
+  div.split {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: calc(var(--design-unit) * 2px);
+  }
+
   rapid-combobox.datasource {
     margin-bottom: calc(var(--design-unit) * 2px);
   }

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

@@ -1,15 +1,42 @@
 import { classNames, html, repeat, when, whenElse } from '@genesislcap/web-core';
-import { datasourceOutputs, selectors } from '../../../store';
+import { datasourceGroupingStrategies, datasourceOutputs, selectors, } from '../../../store';
 import { datasourceInputForDisplay, TOOLTIP, tooltip } from '../../../utils';
 const datasourceAlias = html `
   <div>
     <p class="label">Name${tooltip(TOOLTIP.DATASOURCES_NAME)}</p>
     <rapid-text-field
       value=${(x) => selectors.datasourceConfig.getDatasource(x.datasourceName).KEY}
-      @change=${(x, ctx) => x.updateKeyHandler(ctx.event.target.value)}
+      @change=${(x, ctx) => x.updateKeyHandler(ctx.event.target.value, ctx.event)}
     ></rapid-text-field>
   </div>
 `;
+const groupingType = html `
+  <div class="split">
+    <div>
+      <p class="label">Grouping Strategy${tooltip(TOOLTIP.DATASOURCES_GROUPING_STRATEGY)}</p>
+      <rapid-select
+        :value=${(x) => selectors.datasourceConfig.getDatasource(x.datasourceName).GROUPING_STRATEGY}
+        @change=${(x, ctx) => x.updateGroupingStrategyHandler(ctx.event.target.value)}
+      >
+        ${repeat(() => datasourceGroupingStrategies, html `
+            <rapid-option>${(x) => x}</rapid-option>
+          `)}
+      </rapid-select>
+    </div>
+    <div>
+      <p class="label">Grouping Key${tooltip(TOOLTIP.DATASOURCES_GROUPING_KEY)}</p>
+      <rapid-select
+        :value=${(x) => selectors.datasourceConfig.getDatasource(x.datasourceName).GROUP_KEY}
+        @change=${(x, ctx) => x.updateGroupingByHandler(ctx.event.target.value)}
+        ?disabled=${(x) => selectors.datasourceConfig.getDatasource(x.datasourceName).GROUPING_STRATEGY === 'NONE'}
+      >
+        ${repeat((x) => { var _a; return (_a = x.groupingByFieldsNames) !== null && _a !== void 0 ? _a : []; }, html `
+            <rapid-option>${(x) => x}</rapid-option>
+          `)}
+      </rapid-select>
+    </div>
+  </div>
+`;
 const processType = html `
   <div>
     <p class="label">Type${tooltip(TOOLTIP.DATASOURCES_TYPE)}</p>
@@ -33,6 +60,9 @@ const closeButton = html `
 const component = html `
   ${when((x) => x.canRemove, closeButton)}
   <div class="container">
+<div class="${() => classNames(['split', Boolean(selectors.baseConfig.getConfig().DOCUMENT_TEMPLATE_ID)])}">
+<div>
+    <p class="label">Datasource${tooltip(TOOLTIP.DATASOURCES_DATASOURCE)}</p>
     <rapid-combobox
       class="datasource ${(x) => classNames(['error', x.error !== 'none'])}"
       autocomplete="both"
@@ -50,7 +80,12 @@ const component = html `
           </rapid-option>
         `)}
     </rapid-combobox>
-    ${when((_) => Boolean(selectors.baseConfig.getConfig().DOCUMENT_TEMPLATE_ID), datasourceAlias)}
+</div>
+    ${when((_) => Boolean(selectors.baseConfig.getConfig().DOCUMENT_TEMPLATE_ID) ||
+    selectors.baseConfig.getConfig().OUTPUT_FORMAT !== 'CSV', datasourceAlias)}
+</div>
+</div>
+    ${when((_) => Boolean(selectors.baseConfig.getConfig().DOCUMENT_TEMPLATE_ID), groupingType)}
     <!-- ${when((_) => selectors.baseConfig.getConfig().OUTPUT_FORMAT === 'CSV', processType)} -->
   </div>
 `;

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