npm - @genesislcap/pbc-reporting-ui - Versions diffs - 14.353.3 → 14.353.4 - Mend

@genesislcap/pbc-reporting-ui 14.353.3 → 14.353.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/dist/dts/new/components/clone-report-config-modal/clone-report-config-modal.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"clone-report-config-modal.d.ts","sourceRoot":"","sources":["../../../../../src/new/components/clone-report-config-modal/clone-report-config-modal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACnD,OAAO,EAAiB,cAAc,EAAc,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;~~AAmBtC~~,qBAKa,sBAAuB,SAAQ,cAAc;IAC/C,OAAO,EAAE,OAAO,CAAC;IAC1B,sBAAsB,EAAE,KAAK,CAAC;IAClB,mBAAmB,EAAE,OAAO,CAAC,kBAAkB,CAAC;IAChD,UAAU,EAAE,MAAM,CAAM;IACxB,QAAQ,EAAE,MAAM,CAAM;IAE5B,sBAAsB,CAAC,EAAE,EAAE,MAAM;IAOjC,qBAAqB,CAAC,EAAE,EAAE,MAAM;IAKtC,2BAA2B;IAM3B,cAAc;IAKd,OAAO,CAAC,YAAY;IASd,iBAAiB;~~IAoCvB~~,cAAc,CAAC,OAAO,EAAE,MAAM;CAO/B"}
1	+ {"version":3,"file":"clone-report-config-modal.d.ts","sourceRoot":"","sources":["../../../../../src/new/components/clone-report-config-modal/clone-report-config-modal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACnD,OAAO,EAAiB,cAAc,EAAc,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAoBtC,qBAKa,sBAAuB,SAAQ,cAAc;IAC/C,OAAO,EAAE,OAAO,CAAC;IAC1B,sBAAsB,EAAE,KAAK,CAAC;IAClB,mBAAmB,EAAE,OAAO,CAAC,kBAAkB,CAAC;IAChD,UAAU,EAAE,MAAM,CAAM;IACxB,QAAQ,EAAE,MAAM,CAAM;IAE5B,sBAAsB,CAAC,EAAE,EAAE,MAAM;IAOjC,qBAAqB,CAAC,EAAE,EAAE,MAAM;IAKtC,2BAA2B;IAM3B,cAAc;IAKd,OAAO,CAAC,YAAY;IASd,iBAAiB;IAqCvB,cAAc,CAAC,OAAO,EAAE,MAAM;CAO/B"}

package/dist/dts/new/components/reporting-configurations/reporting-configurations.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"reporting-configurations.d.ts","sourceRoot":"","sources":["../../../../../src/new/components/reporting-configurations/reporting-configurations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAExD,OAAO,EAAwC,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAClG,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAEpD,OAAO,EAEL,iBAAiB,EACjB,wBAAwB,EAEzB,MAAM,6BAA6B,CAAC;~~AAYrC~~,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,EAAE,sBAAsB,EAAE,MAAM,wDAAwD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIhG,qBAKa,uBAAwB,SAAQ,4BAAqD;IACvF,OAAO,EAAE,OAAO,CAAC;IAC1B,8BAA8B,EAAE,wBAAwB,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAM;IAC1B,gBAAgB,EAAE,sBAAsB,CAAC;IAC/C,IAAI,EAAG,IAAI,CAAC;IAEX,eAAe;;;;;QAWpB;IAEF,sBAAsB;IAMhB,uBAAuB,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE;~~IAoBxE~~,aAAa;IAmHb,cAAc;YAkBA,kBAAkB;YA8BlB,SAAS;IA6BvB,aAAa,CAAC,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAiBjD,0BAA0B,CAAC,CAAC,KAAA;CAGnC"}
1	+ {"version":3,"file":"reporting-configurations.d.ts","sourceRoot":"","sources":["../../../../../src/new/components/reporting-configurations/reporting-configurations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAExD,OAAO,EAAwC,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAClG,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAEpD,OAAO,EAEL,iBAAiB,EACjB,wBAAwB,EAEzB,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,EAAE,sBAAsB,EAAE,MAAM,wDAAwD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIhG,qBAKa,uBAAwB,SAAQ,4BAAqD;IACvF,OAAO,EAAE,OAAO,CAAC;IAC1B,8BAA8B,EAAE,wBAAwB,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAM;IAC1B,gBAAgB,EAAE,sBAAsB,CAAC;IAC/C,IAAI,EAAG,IAAI,CAAC;IAEX,eAAe;;;;;QAWpB;IAEF,sBAAsB;IAMhB,uBAAuB,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE;IAqBxE,aAAa;IAmHb,cAAc;YAkBA,kBAAkB;YA8BlB,SAAS;IA6BvB,aAAa,CAAC,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAiBjD,0BAA0B,CAAC,CAAC,KAAA;CAGnC"}

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

@@ -1,7 +1,8 @@
+import type { JSONSchema7 } from 'json-schema';
 import type { DatasourceInputTypes, DatasourceName, ReportingConfig } from '../store';
 import { Display, Genesis } from '../types';
 export declare function transformToServerPayload(state: ReportingConfig): Genesis.ServerReportConfig;
-export declare function transformFromServerPaylaod(payload: Genesis.ServerReportConfig): ReportingConfig;
+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;

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

	@@ -1 +1 @@
1	- {"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../../../../src/new/utils/transformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,oBAAoB,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;~~AAClG~~,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAE5C,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAiB3F;~~AAID~~,~~wBAAgB~~,0BAA0B,~~CAAC~~,OAAO,EAAE,OAAO,CAAC,kBAAkB,~~GAAG~~,eAAe,~~CA6C/F~~;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"}
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"}

package/dist/dts/new/utils/transformers.test.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=transformers.test.d.ts.map

package/dist/dts/new/utils/transformers.test.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"transformers.test.d.ts","sourceRoot":"","sources":["../../../../src/new/utils/transformers.test.ts"],"names":[],"mappings":""}

package/dist/esm/new/components/clone-report-config-modal/clone-report-config-modal.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import { __awaiter, __decorate } from "tslib";
 import { Connect } from '@genesislcap/foundation-comms';
 import { customElement, GenesisElement, observable } from '@genesislcap/web-core';
-import { showNotificationToast, transformFromServerPaylaod, validateReportingConfig, } from '../../utils';
+import { getDatasourceSchema, showNotificationToast, transformFromServerPayload, validateReportingConfig, } from '../../utils';
 import { cloneReportConfigModalStyles as styles } from './clone-report-config-modal.styles';
 import { CloneReportConfigModalTemplate as template } from './clone-report-config-modal.template';
 const EXCLUDED_FIELDS = [
@@ -52,7 +52,8 @@ let CloneReportConfigModal = class CloneReportConfigModal extends GenesisElement
             var _a, _b;
             try {
                 const DETAILS = Object.assign(Object.assign({}, this.filterFields(this.reportConfigDetails, EXCLUDED_FIELDS)), { NAME: this.reportName, FILE_NAME: this.fileName });
-                const result = yield validateReportingConfig(this.connect)(transformFromServerPaylaod(DETAILS));
+                const getSchema = getDatasourceSchema(this.connect);
+                const result = yield validateReportingConfig(this.connect)(yield transformFromServerPayload(DETAILS, getSchema));
                 if (result.k === 'err') {
                     this.showErrorToast((_a = result.info) === null || _a === void 0 ? void 0 : _a.join('\n\n'));
                     return;

package/dist/esm/new/components/reporting-configurations/reporting-configurations.js CHANGED Viewed

@@ -8,7 +8,7 @@ import { getActionsMenuDef, GridProRendererTypes, } from '@genesislcap/rapid-gri
 import { customElement, GenesisElement, html, observable } from '@genesislcap/web-core';
 import { writeReduxState, reduxBlankState, StorageKey } from '../../store';
 import { Permissions } from '../../types';
-import { formatDate, getFormattedDateTime, permissionGuard, showNotificationToast, transformFromServerPaylaod, } from '../../utils';
+import { formatDate, getDatasourceSchema, getFormattedDateTime, permissionGuard, showNotificationToast, transformFromServerPayload, } from '../../utils';
 import { getFilterParams } from '../../utils/date-filter-params';
 import { ReportingEvents } from '../../utils/event-map';
 import { ReportingConfigurationStyles as styles } from './reporting-configurations.styles';
@@ -41,7 +41,8 @@ let ReportingConfigurations = class ReportingConfigurations extends EventEmitter
                 const data = (_b = response.REPLY) === null || _b === void 0 ? void 0 : _b[0];
                 if (!data)
                     throw new Error(`No data returned for edit report with ID ${ID}`);
-                const transformed = transformFromServerPaylaod(data);
+                const getSchema = getDatasourceSchema(this.connect);
+                const transformed = yield transformFromServerPayload(data, getSchema);
                 console.log({ transformed });
                 writeReduxState(transformed);
                 this.$emit(ReportingEvents.setReportConfigDisplayMode, 'edit');

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

@@ -1,4 +1,4 @@
-import { __rest } from "tslib";
+import { __awaiter, __rest } from "tslib";
 export function transformToServerPayload(state) {
     var _a, _b;
     const { datasourceConfig, baseConfig } = state;
@@ -12,30 +12,71 @@ export function transformToServerPayload(state) {
             ? restBaseConfig.DOCUMENT_TEMPLATE_ID
             : null, DATA_SOURCES: Object.values(datasourceConfig) });
 }
-// TODO: we'll suppress the bigints on the server so won't need to do this
-// horrible destructing
-export function transformFromServerPaylaod(payload) {
-    const { DATA_SOURCES, ID, NAME, DESCRIPTION, OUTPUT_FORMAT, FILE_NAME, AUTO_DISPATCH, DESTINATION_IDS, SCHEDULES, OUTPUT_DIRECTORY, DOCUMENT_TEMPLATE_ID, } = payload;
-    const baseConfig = Object.assign({ ID,
-        NAME,
-        DESCRIPTION,
-        OUTPUT_FORMAT,
-        FILE_NAME,
-        AUTO_DISPATCH,
-        DESTINATION_IDS,
-        OUTPUT_DIRECTORY,
-        DOCUMENT_TEMPLATE_ID }, (SCHEDULES.length > 0 && { SCHEDULE: SCHEDULES[0] }));
+/**
+ * Cleans up orphaned field references from transformer configuration
+ * by validating against current schema
+ */
+function cleanupTransformerConfig(config, validFields) {
+    var _a;
     return {
-        baseConfig,
-        datasourceConfig: DATA_SOURCES.map(({ KEY, INPUT_TYPE, NAME: DS_NAME, OUTPUT_TYPE, TRANSFORMER_CONFIGURATION }) => ({
-            KEY,
-            INPUT_TYPE,
-            NAME: DS_NAME,
-            OUTPUT_TYPE,
-            TRANSFORMER_CONFIGURATION,
-        })).reduce((acum, ds) => (Object.assign(Object.assign({}, acum), { [buildDatasourceName(ds.NAME, ds.INPUT_TYPE)]: ds })), {}),
+        INCLUDE_COLUMNS: (_a = config.INCLUDE_COLUMNS) === null || _a === void 0 ? void 0 : _a.filter((field) => validFields.has(field)),
+        COLUMN_RENAMES: config.COLUMN_RENAMES
+            ? Object.fromEntries(Object.entries(config.COLUMN_RENAMES).filter(([key]) => validFields.has(key)))
+            : undefined,
+        COLUMN_FORMATS: config.COLUMN_FORMATS
+            ? Object.fromEntries(Object.entries(config.COLUMN_FORMATS).filter(([key]) => validFields.has(key)))
+            : undefined,
+        COLUMN_TRANSFORMS: config.COLUMN_TRANSFORMS
+            ? Object.fromEntries(Object.entries(config.COLUMN_TRANSFORMS).filter(([key]) => validFields.has(key)))
+            : undefined,
+        ROW_FILTERS: config.ROW_FILTERS,
     };
 }
+// TODO: we'll suppress the bigints on the server so won't need to do this
+// horrible destructing
+export function transformFromServerPayload(payload, getSchema) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { DATA_SOURCES, ID, NAME, DESCRIPTION, OUTPUT_FORMAT, FILE_NAME, AUTO_DISPATCH, DESTINATION_IDS, SCHEDULES, OUTPUT_DIRECTORY, DOCUMENT_TEMPLATE_ID, } = payload;
+        const baseConfig = Object.assign({ ID,
+            NAME,
+            DESCRIPTION,
+            OUTPUT_FORMAT,
+            FILE_NAME,
+            AUTO_DISPATCH,
+            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 }) {
+            try {
+                const schema = yield getSchema(KEY);
+                const validFields = new Set(Object.keys(schema.properties || {}));
+                const cleanedConfig = cleanupTransformerConfig(TRANSFORMER_CONFIGURATION || {}, validFields);
+                return {
+                    KEY,
+                    INPUT_TYPE,
+                    NAME: DS_NAME,
+                    OUTPUT_TYPE,
+                    TRANSFORMER_CONFIGURATION: cleanedConfig,
+                };
+            }
+            catch (error) {
+                // If schema fetch fails, log warning but keep original config
+                console.warn(`Failed to fetch schema for ${KEY}, skipping cleanup:`, error);
+                return {
+                    KEY,
+                    INPUT_TYPE,
+                    NAME: DS_NAME,
+                    OUTPUT_TYPE,
+                    TRANSFORMER_CONFIGURATION: TRANSFORMER_CONFIGURATION || {},
+                };
+            }
+        })));
+        return {
+            baseConfig,
+            datasourceConfig: cleanedDatasources.reduce((acum, ds) => (Object.assign(Object.assign({}, acum), { [buildDatasourceName(ds.NAME, ds.INPUT_TYPE)]: ds })), {}),
+        };
+    });
+}
 export function datasourceInputForDisplay(input) {
     if (input === 'REQ_REP')
         return 'Snapshot';

package/dist/esm/new/utils/transformers.test.js ADDED Viewed

@@ -0,0 +1,419 @@
+import { __awaiter } from "tslib";
+import { assert, sinon, suite } from '@genesislcap/foundation-testing';
+import { buildDatasourceName, transformFromServerPayload } from './transformers';
+const TransformFromServerPayload = suite('transformFromServerPayload');
+TransformFromServerPayload.before.each(() => {
+    sinon.restore();
+});
+TransformFromServerPayload('cleans up orphaned fields from INCLUDE_COLUMNS', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
+    const mockGetSchema = sinon.stub();
+    const validSchema = {
+        properties: {
+            COUNTERPARTY_NAME: { genesisType: 'STRING' },
+            AMOUNT: { genesisType: 'DOUBLE' },
+        },
+    };
+    mockGetSchema.resolves(validSchema);
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        SCHEDULES: [],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {
+                    INCLUDE_COLUMNS: ['COUNTERPARTY_NAME', 'AMOUNT', 'NAME'], // NAME is orphaned
+                },
+            },
+        ],
+        DESTINATION_IDS: [],
+        OUTPUT_DIRECTORY: '/reports',
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
+    assert.equal((_a = cleanedConfig.INCLUDE_COLUMNS) === null || _a === void 0 ? void 0 : _a.length, 2);
+    assert.ok((_b = cleanedConfig.INCLUDE_COLUMNS) === null || _b === void 0 ? void 0 : _b.includes('COUNTERPARTY_NAME'));
+    assert.ok((_c = cleanedConfig.INCLUDE_COLUMNS) === null || _c === void 0 ? void 0 : _c.includes('AMOUNT'));
+    assert.ok(!((_d = cleanedConfig.INCLUDE_COLUMNS) === null || _d === void 0 ? void 0 : _d.includes('NAME')));
+}));
+TransformFromServerPayload('cleans up orphaned fields from COLUMN_RENAMES', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const mockGetSchema = sinon.stub();
+    const validSchema = {
+        properties: {
+            COUNTERPARTY_NAME: { genesisType: 'STRING' },
+            AMOUNT: { genesisType: 'DOUBLE' },
+        },
+    };
+    mockGetSchema.resolves(validSchema);
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        SCHEDULES: [],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {
+                    COLUMN_RENAMES: {
+                        COUNTERPARTY_NAME: 'Counterparty Name',
+                        AMOUNT: 'Amount',
+                        NAME: 'Old Name', // orphaned
+                    },
+                },
+            },
+        ],
+        DESTINATION_IDS: [],
+        OUTPUT_DIRECTORY: '/reports',
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
+    assert.equal(Object.keys(cleanedConfig.COLUMN_RENAMES || {}).length, 2);
+    assert.equal((_a = cleanedConfig.COLUMN_RENAMES) === null || _a === void 0 ? void 0 : _a['COUNTERPARTY_NAME'], 'Counterparty Name');
+    assert.equal((_b = cleanedConfig.COLUMN_RENAMES) === null || _b === void 0 ? void 0 : _b['AMOUNT'], 'Amount');
+    assert.ok(!((_c = cleanedConfig.COLUMN_RENAMES) === null || _c === void 0 ? void 0 : _c['NAME']));
+}));
+TransformFromServerPayload('cleans up orphaned fields from COLUMN_FORMATS', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const mockGetSchema = sinon.stub();
+    const validSchema = {
+        properties: {
+            COUNTERPARTY_NAME: { genesisType: 'STRING' },
+            AMOUNT: { genesisType: 'DOUBLE' },
+        },
+    };
+    mockGetSchema.resolves(validSchema);
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        SCHEDULES: [],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {
+                    COLUMN_FORMATS: {
+                        COUNTERPARTY_NAME: 'text',
+                        AMOUNT: '#,##0.00',
+                        NAME: 'text', // orphaned
+                    },
+                },
+            },
+        ],
+        DESTINATION_IDS: [],
+        OUTPUT_DIRECTORY: '/reports',
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
+    assert.equal(Object.keys(cleanedConfig.COLUMN_FORMATS || {}).length, 2);
+    assert.equal((_a = cleanedConfig.COLUMN_FORMATS) === null || _a === void 0 ? void 0 : _a['COUNTERPARTY_NAME'], 'text');
+    assert.equal((_b = cleanedConfig.COLUMN_FORMATS) === null || _b === void 0 ? void 0 : _b['AMOUNT'], '#,##0.00');
+    assert.ok(!((_c = cleanedConfig.COLUMN_FORMATS) === null || _c === void 0 ? void 0 : _c['NAME']));
+}));
+TransformFromServerPayload('cleans up orphaned fields from COLUMN_TRANSFORMS', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const mockGetSchema = sinon.stub();
+    const validSchema = {
+        properties: {
+            COUNTERPARTY_NAME: { genesisType: 'STRING' },
+            AMOUNT: { genesisType: 'DOUBLE' },
+        },
+    };
+    mockGetSchema.resolves(validSchema);
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        SCHEDULES: [],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {
+                    COLUMN_TRANSFORMS: {
+                        COUNTERPARTY_NAME: { TYPE: 'BINARY_EXPRESSION', LEFT: {}, OPERATION: 'AND', RIGHT: {} },
+                        AMOUNT: { TYPE: 'METHOD_EXPRESSION', METHOD: 'TRIM', PARAMETERS: [] },
+                        NAME: { TYPE: 'BINARY_EXPRESSION', LEFT: {}, OPERATION: 'AND', RIGHT: {} }, // orphaned
+                    },
+                },
+            },
+        ],
+        DESTINATION_IDS: [],
+        OUTPUT_DIRECTORY: '/reports',
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
+    assert.equal(Object.keys(cleanedConfig.COLUMN_TRANSFORMS || {}).length, 2);
+    assert.ok((_a = cleanedConfig.COLUMN_TRANSFORMS) === null || _a === void 0 ? void 0 : _a['COUNTERPARTY_NAME']);
+    assert.ok((_b = cleanedConfig.COLUMN_TRANSFORMS) === null || _b === void 0 ? void 0 : _b['AMOUNT']);
+    assert.ok(!((_c = cleanedConfig.COLUMN_TRANSFORMS) === null || _c === void 0 ? void 0 : _c['NAME']));
+}));
+TransformFromServerPayload('handles schema fetch failure gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+    const mockGetSchema = sinon.stub();
+    const consoleWarnStub = sinon.stub(console, 'warn');
+    mockGetSchema.rejects(new Error('Schema fetch failed'));
+    const originalConfig = {
+        INCLUDE_COLUMNS: ['NAME', 'AMOUNT'],
+        COLUMN_RENAMES: { NAME: 'Name' },
+    };
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        SCHEDULES: [],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: originalConfig,
+            },
+        ],
+        DESTINATION_IDS: [],
+        OUTPUT_DIRECTORY: '/reports',
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
+    // Should keep original config when schema fetch fails
+    assert.equal(JSON.stringify(cleanedConfig), JSON.stringify(originalConfig));
+    assert.ok(consoleWarnStub.calledOnce);
+    assert.ok(consoleWarnStub.calledWithMatch(sinon.match.string, sinon.match.instanceOf(Error)));
+    consoleWarnStub.restore();
+}));
+TransformFromServerPayload('handles multiple datasources independently', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
+    const mockGetSchema = sinon.stub();
+    mockGetSchema
+        .onFirstCall()
+        .resolves({
+        properties: {
+            COUNTERPARTY_NAME: { genesisType: 'STRING' },
+        },
+    })
+        .onSecondCall()
+        .resolves({
+        properties: {
+            TRADE_ID: { genesisType: 'STRING' },
+        },
+    });
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        SCHEDULES: [],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {
+                    INCLUDE_COLUMNS: ['COUNTERPARTY_NAME', 'NAME'], // NAME is orphaned
+                },
+            },
+            {
+                KEY: 'TRADE',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'TRADE',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {
+                    INCLUDE_COLUMNS: ['TRADE_ID', 'OLD_FIELD'], // OLD_FIELD is orphaned
+                },
+            },
+        ],
+        DESTINATION_IDS: [],
+        OUTPUT_DIRECTORY: '/reports',
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    const counterpartyKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+    const tradeKey = buildDatasourceName('TRADE', 'REQ_REP');
+    assert.equal((_a = result.datasourceConfig[counterpartyKey].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) === null || _a === void 0 ? void 0 : _a.length, 1);
+    assert.ok((_b = result.datasourceConfig[counterpartyKey].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) === null || _b === void 0 ? void 0 : _b.includes('COUNTERPARTY_NAME'));
+    assert.equal((_c = result.datasourceConfig[tradeKey].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) === null || _c === void 0 ? void 0 : _c.length, 1);
+    assert.ok((_d = result.datasourceConfig[tradeKey].TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS) === null || _d === void 0 ? void 0 : _d.includes('TRADE_ID'));
+}));
+TransformFromServerPayload('handles empty transformer configuration', () => __awaiter(void 0, void 0, void 0, function* () {
+    const mockGetSchema = sinon.stub();
+    const validSchema = {
+        properties: {
+            COUNTERPARTY_NAME: { genesisType: 'STRING' },
+        },
+    };
+    mockGetSchema.resolves(validSchema);
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        SCHEDULES: [],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {},
+            },
+        ],
+        DESTINATION_IDS: [],
+        OUTPUT_DIRECTORY: '/reports',
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
+    assert.equal(JSON.stringify(cleanedConfig), JSON.stringify({}));
+}));
+TransformFromServerPayload('handles missing schema properties', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const mockGetSchema = sinon.stub();
+    const schemaWithoutProperties = {};
+    mockGetSchema.resolves(schemaWithoutProperties);
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        SCHEDULES: [],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {
+                    INCLUDE_COLUMNS: ['NAME', 'AMOUNT'],
+                },
+            },
+        ],
+        DESTINATION_IDS: [],
+        OUTPUT_DIRECTORY: '/reports',
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
+    // All fields should be removed when schema has no properties
+    assert.equal((_a = cleanedConfig.INCLUDE_COLUMNS) === null || _a === void 0 ? void 0 : _a.length, 0);
+}));
+TransformFromServerPayload('preserves base config correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const mockGetSchema = sinon.stub();
+    const validSchema = {
+        properties: {
+            COUNTERPARTY_NAME: { genesisType: 'STRING' },
+        },
+    };
+    mockGetSchema.resolves(validSchema);
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        DESCRIPTION: 'Test Description',
+        OUTPUT_FORMAT: 'CSV',
+        FILE_NAME: 'test.csv',
+        AUTO_DISPATCH: true,
+        DESTINATION_IDS: ['dest1', 'dest2'],
+        OUTPUT_DIRECTORY: '/reports',
+        DOCUMENT_TEMPLATE_ID: 'template-123',
+        SCHEDULES: [
+            {
+                CRON_EXPRESSION: '0 0 0 * * ?',
+                TIME_ZONE: 'UTC',
+            },
+        ],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {},
+            },
+        ],
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    assert.equal(result.baseConfig.ID, 'test-id');
+    assert.equal(result.baseConfig.NAME, 'Test Report');
+    assert.equal(result.baseConfig.DESCRIPTION, 'Test Description');
+    assert.equal(result.baseConfig.OUTPUT_FORMAT, 'CSV');
+    assert.equal(result.baseConfig.FILE_NAME, 'test.csv');
+    assert.equal(result.baseConfig.AUTO_DISPATCH, true);
+    assert.equal(JSON.stringify(result.baseConfig.DESTINATION_IDS), JSON.stringify(['dest1', 'dest2']));
+    assert.equal(result.baseConfig.OUTPUT_DIRECTORY, '/reports');
+    assert.equal(result.baseConfig.DOCUMENT_TEMPLATE_ID, 'template-123');
+    assert.ok(result.baseConfig.SCHEDULE);
+    assert.equal((_a = result.baseConfig.SCHEDULE) === null || _a === void 0 ? void 0 : _a.CRON_EXPRESSION, '0 0 0 * * ?');
+    assert.equal((_b = result.baseConfig.SCHEDULE) === null || _b === void 0 ? void 0 : _b.TIME_ZONE, 'UTC');
+}));
+TransformFromServerPayload('handles all transformer config types together', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    const mockGetSchema = sinon.stub();
+    const validSchema = {
+        properties: {
+            COUNTERPARTY_NAME: { genesisType: 'STRING' },
+            AMOUNT: { genesisType: 'DOUBLE' },
+        },
+    };
+    mockGetSchema.resolves(validSchema);
+    const payload = {
+        ID: 'test-id',
+        NAME: 'Test Report',
+        SCHEDULES: [],
+        DATA_SOURCES: [
+            {
+                KEY: 'COUNTERPARTY',
+                INPUT_TYPE: 'REQ_REP',
+                NAME: 'COUNTERPARTY',
+                OUTPUT_TYPE: 'TABLE',
+                TRANSFORMER_CONFIGURATION: {
+                    INCLUDE_COLUMNS: ['COUNTERPARTY_NAME', 'AMOUNT', 'NAME'], // NAME orphaned
+                    COLUMN_RENAMES: {
+                        COUNTERPARTY_NAME: 'Counterparty',
+                        NAME: 'Old Name', // orphaned
+                    },
+                    COLUMN_FORMATS: {
+                        AMOUNT: '#,##0.00',
+                        NAME: 'text', // orphaned
+                    },
+                    COLUMN_TRANSFORMS: {
+                        COUNTERPARTY_NAME: { TYPE: 'BINARY_EXPRESSION', LEFT: {}, OPERATION: 'AND', RIGHT: {} },
+                        NAME: { TYPE: 'METHOD_EXPRESSION', METHOD: 'TRIM', PARAMETERS: [] }, // orphaned
+                    },
+                    ROW_FILTERS: {
+                        TYPE: 'PREDICATE_EXPRESSION',
+                        OPERATION: 'AND',
+                        EXPRESSIONS: [],
+                    },
+                },
+            },
+        ],
+        DESTINATION_IDS: [],
+        OUTPUT_DIRECTORY: '/reports',
+    };
+    const result = yield transformFromServerPayload(payload, mockGetSchema);
+    const datasourceKey = buildDatasourceName('COUNTERPARTY', 'REQ_REP');
+    const cleanedConfig = result.datasourceConfig[datasourceKey].TRANSFORMER_CONFIGURATION;
+    // INCLUDE_COLUMNS should only have valid fields
+    assert.equal((_a = cleanedConfig.INCLUDE_COLUMNS) === null || _a === void 0 ? void 0 : _a.length, 2);
+    assert.ok((_b = cleanedConfig.INCLUDE_COLUMNS) === null || _b === void 0 ? void 0 : _b.includes('COUNTERPARTY_NAME'));
+    assert.ok((_c = cleanedConfig.INCLUDE_COLUMNS) === null || _c === void 0 ? void 0 : _c.includes('AMOUNT'));
+    // COLUMN_RENAMES should only have valid fields
+    assert.equal(Object.keys(cleanedConfig.COLUMN_RENAMES || {}).length, 1);
+    assert.equal((_d = cleanedConfig.COLUMN_RENAMES) === null || _d === void 0 ? void 0 : _d['COUNTERPARTY_NAME'], 'Counterparty');
+    // COLUMN_FORMATS should only have valid fields
+    assert.equal(Object.keys(cleanedConfig.COLUMN_FORMATS || {}).length, 1);
+    assert.equal((_e = cleanedConfig.COLUMN_FORMATS) === null || _e === void 0 ? void 0 : _e['AMOUNT'], '#,##0.00');
+    // COLUMN_TRANSFORMS should only have valid fields
+    assert.equal(Object.keys(cleanedConfig.COLUMN_TRANSFORMS || {}).length, 1);
+    assert.ok((_f = cleanedConfig.COLUMN_TRANSFORMS) === null || _f === void 0 ? void 0 : _f['COUNTERPARTY_NAME']);
+    // ROW_FILTERS should be preserved
+    assert.ok(cleanedConfig.ROW_FILTERS);
+}));
+TransformFromServerPayload.run();