dbgate-datalib 6.5.1 → 6.5.3

package/lib/CollectionGridDisplay.d.ts

@@ -4,5 +4,5 @@ import { GridConfig, GridCache } from './GridConfig';
 export declare function analyseCollectionDisplayColumns(rows: any, display: any): any[];
 export declare class CollectionGridDisplay extends GridDisplay {
     collection: CollectionInfo;
-    constructor(collection: CollectionInfo, driver: EngineDriver, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, loadedRows: any, changeSet: any, readOnly?: boolean);
+    constructor(collection: CollectionInfo, driver: EngineDriver, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, loadedRows: any, changeSet: any, readOnly?: boolean, currentSettings?: any);
 }

package/lib/CollectionGridDisplay.js

@@ -93,9 +93,9 @@ function analyseCollectionDisplayColumns(rows, display) {
 }
 exports.analyseCollectionDisplayColumns = analyseCollectionDisplayColumns;
 class CollectionGridDisplay extends GridDisplay_1.GridDisplay {
-    constructor(collection, driver, config, setConfig, cache, setCache, loadedRows, changeSet, readOnly = false) {
+    constructor(collection, driver, config, setConfig, cache, setCache, loadedRows, changeSet, readOnly = false, currentSettings = null) {
         var _a, _b;
-        super(config, setConfig, cache, setCache, driver);
+        super(config, setConfig, cache, setCache, driver, undefined, undefined, currentSettings);
         this.collection = collection;
         const changedDocs = lodash_1.default.compact(changeSet.updates.map(chs => chs.document));
         const insertedDocs = lodash_1.default.compact(changeSet.inserts.map(chs => chs.fields));

package/lib/JslGridDisplay.d.ts

@@ -2,5 +2,5 @@ import { GridDisplay, ChangeCacheFunc, ChangeConfigFunc } from './GridDisplay';
 import { GridConfig, GridCache } from './GridConfig';
 import { EngineDriver } from 'dbgate-types';
 export declare class JslGridDisplay extends GridDisplay {
-    constructor(jslid: any, structure: any, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, rows: any, isDynamicStructure: boolean, supportsReload: boolean, editable?: boolean, driver?: EngineDriver);
+    constructor(jslid: any, structure: any, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, rows: any, isDynamicStructure: boolean, supportsReload: boolean, editable?: boolean, driver?: EngineDriver, currentSettings?: any);
 }

package/lib/JslGridDisplay.js

@@ -9,9 +9,9 @@ const GridDisplay_1 = require("./GridDisplay");
 const CollectionGridDisplay_1 = require("./CollectionGridDisplay");
 const dbgate_tools_1 = require("dbgate-tools");
 class JslGridDisplay extends GridDisplay_1.GridDisplay {
-    constructor(jslid, structure, config, setConfig, cache, setCache, rows, isDynamicStructure, supportsReload, editable = false, driver = null) {
+    constructor(jslid, structure, config, setConfig, cache, setCache, rows, isDynamicStructure, supportsReload, editable = false, driver = null, currentSettings = null) {
         var _a;
-        super(config, setConfig, cache, setCache, driver);
+        super(config, setConfig, cache, setCache, driver, undefined, undefined, currentSettings);
         this.filterable = true;
         this.sortable = true;
         this.supportsReload = supportsReload;

package/lib/ViewGridDisplay.d.ts

@@ -3,7 +3,7 @@ import type { EngineDriver, ViewInfo, ColumnInfo, DatabaseInfo } from 'dbgate-ty
 import { GridConfig, GridCache } from './GridConfig';
 export declare class ViewGridDisplay extends GridDisplay {
     view: ViewInfo;
-    constructor(view: ViewInfo, driver: EngineDriver, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, dbinfo: DatabaseInfo, serverVersion: any);
+    constructor(view: ViewInfo, driver: EngineDriver, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, dbinfo: DatabaseInfo, serverVersion: any, currentSettings: any);
     getDisplayColumns(view: ViewInfo): {
         isChecked: boolean;
         pureName: string;

package/lib/ViewGridDisplay.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViewGridDisplay = void 0;
 const GridDisplay_1 = require("./GridDisplay");
 class ViewGridDisplay extends GridDisplay_1.GridDisplay {
-    constructor(view, driver, config, setConfig, cache, setCache, dbinfo, serverVersion) {
-        super(config, setConfig, cache, setCache, driver, dbinfo, serverVersion);
+    constructor(view, driver, config, setConfig, cache, setCache, dbinfo, serverVersion, currentSettings) {
+        super(config, setConfig, cache, setCache, driver, dbinfo, serverVersion, currentSettings);
         this.view = view;
         this.columns = this.getDisplayColumns(view);
         this.formColumns = this.columns;

package/lib/chartDefinitions.d.ts

@@ -16,6 +16,7 @@ export declare const ChartLimits: {
     VALID_VALUE_RATIO_LIMIT: number;
     PIE_RATIO_LIMIT: number;
     PIE_COUNT_LIMIT: number;
+    CHART_FILL_LIMIT: number;
 };
 export interface ChartXFieldDefinition {
     field: string;
@@ -36,6 +37,7 @@ export interface ChartDefinition {
     title?: string;
     pieRatioLimit?: number;
     pieCountLimit?: number;
+    trimXCountLimit?: number;
     xdef: ChartXFieldDefinition;
     ydefs: ChartYFieldDefinition[];
     useDataLabels?: boolean;
@@ -76,5 +78,6 @@ export interface ProcessedChart {
         [key: string]: Set<any>;
     };
     availableColumns: ChartAvailableColumn[];
+    errorMessage?: string;
     definition: ChartDefinition;
 }

package/lib/chartDefinitions.js

@@ -14,5 +14,6 @@ exports.ChartLimits = {
     MAX_DISTINCT_VALUES: 10,
     VALID_VALUE_RATIO_LIMIT: 0.5,
     PIE_RATIO_LIMIT: 0.05,
-    PIE_COUNT_LIMIT: 10, // limit for number of pie chart slices, if the number of slices is above this, it will be grouped into "Other"
+    PIE_COUNT_LIMIT: 10,
+    CHART_FILL_LIMIT: 10000, // limit for filled charts (time intervals), to avoid too many points
 };

package/lib/chartProcessor.d.ts

@@ -9,6 +9,7 @@ export declare class ChartProcessor {
     availableColumns: ChartAvailableColumn[];
     autoDetectCharts: boolean;
     rowsAdded: number;
+    errorMessage?: string;
     constructor(givenDefinitions?: ChartDefinition[]);
     addRow(row: any): void;
     applyLimitsOnCharts(): void;

package/lib/chartProcessor.js

@@ -140,9 +140,18 @@ class ChartProcessor {
         }
         // apply on all charts with this date column
         for (const chart of this.chartsProcessing) {
+            if (chart.errorMessage) {
+                continue; // skip charts with errors
+            }
             this.applyRawData(chart, row, dateColumns[chart.definition.xdef.field], chart.isGivenDefinition ? numericColumns : numericColumnsForAutodetect, stringColumns);
+            if (Object.keys(chart.buckets).length > chartDefinitions_1.ChartLimits.CHART_FILL_LIMIT) {
+                chart.errorMessage = `Chart has too many buckets, limit is ${chartDefinitions_1.ChartLimits.CHART_FILL_LIMIT}.`;
+            }
         }
         for (let i = 0; i < this.chartsProcessing.length; i++) {
+            if (this.chartsProcessing[i].errorMessage) {
+                continue; // skip charts with errors
+            }
             this.chartsProcessing[i] = (0, chartTools_1.autoAggregateCompactTimelineChart)(this.chartsProcessing[i]);
         }
         this.rowsAdded += 1;
@@ -173,17 +182,25 @@ class ChartProcessor {
         this.applyLimitsOnCharts();
         this.availableColumns = Object.values(this.availableColumnsDict);
         for (const chart of this.chartsProcessing) {
+            if (chart.errorMessage) {
+                this.charts.push(chart);
+                continue;
+            }
             let addedChart = chart;
-            if (chart.rowsAdded == 0) {
+            if (chart.rowsAdded == 0 && !chart.isGivenDefinition) {
                 continue; // skip empty charts
             }
             const sortOrder = (_a = chart.definition.xdef.sortOrder) !== null && _a !== void 0 ? _a : 'ascKeys';
             if (sortOrder != 'natural') {
                 if (sortOrder == 'ascKeys' || sortOrder == 'descKeys') {
-                    if (chart.definition.xdef.transformFunction.startsWith('date:')) {
+                    if (chart.definition.chartType == 'line' && chart.definition.xdef.transformFunction.startsWith('date:')) {
                         addedChart = (0, chartTools_1.autoAggregateCompactTimelineChart)(addedChart);
                         (0, chartTools_1.fillChartTimelineBuckets)(addedChart);
                     }
+                    if (addedChart.errorMessage) {
+                        this.charts.push(addedChart);
+                        continue;
+                    }
                     addedChart.bucketKeysOrdered = (0, sortBy_1.default)(Object.keys(addedChart.buckets));
                     if (sortOrder == 'descKeys') {
                         addedChart.bucketKeysOrdered.reverse();
@@ -200,6 +217,10 @@ class ChartProcessor {
                 addedChart = Object.assign(Object.assign({}, addedChart), { definition: Object.assign(Object.assign({}, addedChart.definition), { ydefs: addedChart.definition.ydefs.filter(y => !addedChart.invalidYRows[y.field] &&
                             addedChart.validYRows[y.field] / addedChart.rowsAdded >= chartDefinitions_1.ChartLimits.VALID_VALUE_RATIO_LIMIT) }) });
             }
+            if (addedChart.definition.trimXCountLimit != null &&
+                addedChart.bucketKeysOrdered.length > addedChart.definition.trimXCountLimit) {
+                addedChart.bucketKeysOrdered = addedChart.bucketKeysOrdered.slice(0, addedChart.definition.trimXCountLimit);
+            }
             if (addedChart) {
                 addedChart.availableColumns = this.availableColumns;
                 this.charts.push(addedChart);

package/lib/chartTools.js

@@ -455,6 +455,7 @@ function fillChartTimelineBuckets(chart) {
     }
     const transform = chart.definition.xdef.transformFunction;
     let currentParsed = fromParsed;
+    let count = 0;
     while (compareChartDatesParsed(currentParsed, toParsed, transform) <= 0) {
         const bucketKey = stringifyChartDate(currentParsed, transform);
         if (!chart.buckets[bucketKey]) {
@@ -462,6 +463,11 @@ function fillChartTimelineBuckets(chart) {
             chart.bucketKeyDateParsed[bucketKey] = currentParsed;
         }
         currentParsed = incrementChartDate(currentParsed, transform);
+        count++;
+        if (count > chartDefinitions_1.ChartLimits.CHART_FILL_LIMIT) {
+            chart.errorMessage = `Too many buckets to fill in chart, limit is ${chartDefinitions_1.ChartLimits.CHART_FILL_LIMIT}`;
+            return;
+        }
     }
 }
 exports.fillChartTimelineBuckets = fillChartTimelineBuckets;

package/lib/tests/chartProcessor.test.js

@@ -354,4 +354,29 @@ describe('Chart processor', () => {
         expect(chart.bucketKeysOrdered).toEqual(expectedOrder);
         expect(chart.buckets).toEqual(expectedBuckets);
     });
+    test.only('Incorrect chart definition', () => {
+        const processor = new chartProcessor_1.ChartProcessor([
+            {
+                chartType: 'bar',
+                xdef: {
+                    field: 'category',
+                    transformFunction: 'date:day',
+                },
+                ydefs: [],
+            },
+        ]);
+        processor.addRows(...DS1.slice(0, 3));
+        processor.finalize();
+        expect(processor.charts.length).toEqual(1);
+        const chart = processor.charts[0];
+        expect(chart.definition.xdef.transformFunction).toEqual('date:day');
+        // console.log(getChartDebugPrint(processor.charts[0]));
+        // expect(chart.definition.xdef.transformFunction).toEqual('date:day');
+        // expect(chart.definition.ydefs).toEqual([
+        //   expect.objectContaining({
+        //     field: 'value',
+        //   }),
+        // ]);
+        // expect(chart.bucketKeysOrdered).toEqual(['2023-10-01', '2023-10-02', '2023-10-03']);
+    });
 });

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "6.5.1",
+  "version": "6.5.3",
   "name": "dbgate-datalib",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -15,14 +15,14 @@
   ],
   "dependencies": {
     "date-fns": "^4.1.0",
-    "dbgate-filterparser": "^6.5.1",
-    "dbgate-sqltree": "^6.5.1",
-    "dbgate-tools": "^6.5.1",
+    "dbgate-filterparser": "^6.5.3",
+    "dbgate-sqltree": "^6.5.3",
+    "dbgate-tools": "^6.5.3",
     "uuid": "^3.4.0"
   },
   "devDependencies": {
     "@types/node": "^13.7.0",
-    "dbgate-types": "^6.5.1",
+    "dbgate-types": "^6.5.3",
     "jest": "^28.1.3",
     "ts-jest": "^28.0.7",
     "typescript": "^4.4.3"