@cubejs-client/core 1.3.15 → 1.3.16

package/dist/src/utils.js

@@ -0,0 +1,294 @@
+import { clone, equals, fromPairs, indexBy, prop, toPairs } from 'ramda';
+import { DEFAULT_GRANULARITY } from './time';
+export function removeEmptyQueryFields(_query) {
+    const query = _query || {};
+    return fromPairs(toPairs(query).flatMap(([key, value]) => {
+        if (['measures', 'dimensions', 'segments', 'timeDimensions', 'filters'].includes(key)) {
+            if (Array.isArray(value) && value.length === 0) {
+                return [];
+            }
+        }
+        if (key === 'order' && value) {
+            if (Array.isArray(value) && value.length === 0) {
+                return [];
+            }
+            else if (!Object.keys(value).length) {
+                return [];
+            }
+        }
+        return [[key, value]];
+    }));
+}
+export function validateQuery(_query) {
+    const query = _query || {};
+    return removeEmptyQueryFields({
+        ...query,
+        filters: (query.filters || []).filter((f) => 'operator' in f),
+        timeDimensions: (query.timeDimensions || []).filter((td) => !(!td.dateRange && !td.granularity)),
+    });
+}
+export function areQueriesEqual(query1, query2) {
+    return (equals(Object.entries(query1?.order || {}), Object.entries(query2?.order || {})) && equals(query1, query2));
+}
+export function defaultOrder(query) {
+    const granularity = (query.timeDimensions || []).find((d) => d.granularity);
+    if (granularity) {
+        return {
+            [granularity.dimension]: 'asc',
+        };
+    }
+    else if ((query.measures || []).length > 0 &&
+        (query.dimensions || []).length > 0) {
+        return {
+            [query.measures[0]]: 'desc',
+        };
+    }
+    else if ((query.dimensions || []).length > 0) {
+        return {
+            [query.dimensions[0]]: 'asc',
+        };
+    }
+    return {};
+}
+export function defaultHeuristics(newState, oldQuery, options) {
+    const { query, ...props } = clone(newState);
+    const { meta, sessionGranularity } = options;
+    const granularity = sessionGranularity || DEFAULT_GRANULARITY;
+    let state = {
+        shouldApplyHeuristicOrder: false,
+        pivotConfig: null,
+        query,
+        ...props,
+    };
+    let newQuery = null;
+    if (!areQueriesEqual(query, oldQuery)) {
+        newQuery = query;
+    }
+    if (Array.isArray(newQuery) || Array.isArray(oldQuery)) {
+        return {
+            shouldApplyHeuristicOrder: false,
+            pivotConfig: null,
+            ...newState,
+        };
+    }
+    if (newQuery) {
+        if ((oldQuery.timeDimensions || []).length === 1 &&
+            (newQuery.timeDimensions || []).length === 1 &&
+            newQuery.timeDimensions[0].granularity &&
+            oldQuery.timeDimensions[0].granularity !==
+                newQuery.timeDimensions[0].granularity) {
+            state = {
+                ...state,
+                sessionGranularity: newQuery.timeDimensions[0].granularity,
+            };
+        }
+        if (((oldQuery.measures || []).length === 0 &&
+            (newQuery.measures || []).length > 0) ||
+            ((oldQuery.measures || []).length === 1 &&
+                (newQuery.measures || []).length === 1 &&
+                oldQuery.measures[0] !== newQuery.measures[0])) {
+            const [td] = newQuery.timeDimensions || [];
+            const defaultTimeDimension = meta.defaultTimeDimensionNameFor(newQuery.measures[0]);
+            newQuery = {
+                ...newQuery,
+                timeDimensions: defaultTimeDimension
+                    ? [
+                        {
+                            dimension: defaultTimeDimension,
+                            granularity: td?.granularity || granularity,
+                            dateRange: td?.dateRange,
+                        },
+                    ]
+                    : [],
+            };
+            return {
+                ...state,
+                pivotConfig: null,
+                shouldApplyHeuristicOrder: true,
+                query: newQuery,
+                chartType: defaultTimeDimension ? 'line' : 'number',
+            };
+        }
+        if ((oldQuery.dimensions || []).length === 0 &&
+            (newQuery.dimensions || []).length > 0) {
+            newQuery = {
+                ...newQuery,
+                timeDimensions: (newQuery.timeDimensions || []).map((td) => ({
+                    ...td,
+                    granularity: undefined,
+                })),
+            };
+            return {
+                ...state,
+                pivotConfig: null,
+                shouldApplyHeuristicOrder: true,
+                query: newQuery,
+                chartType: 'table',
+            };
+        }
+        if ((oldQuery.dimensions || []).length > 0 &&
+            (newQuery.dimensions || []).length === 0) {
+            newQuery = {
+                ...newQuery,
+                timeDimensions: (newQuery.timeDimensions || []).map((td) => ({
+                    ...td,
+                    granularity: td.granularity || granularity,
+                })),
+            };
+            return {
+                ...state,
+                pivotConfig: null,
+                shouldApplyHeuristicOrder: true,
+                query: newQuery,
+                chartType: (newQuery.timeDimensions || []).length ? 'line' : 'number',
+            };
+        }
+        if (((oldQuery.dimensions || []).length > 0 ||
+            (oldQuery.measures || []).length > 0) &&
+            (newQuery.dimensions || []).length === 0 &&
+            (newQuery.measures || []).length === 0) {
+            newQuery = {
+                ...newQuery,
+                timeDimensions: [],
+                filters: [],
+            };
+            return {
+                ...state,
+                pivotConfig: null,
+                shouldApplyHeuristicOrder: true,
+                query: newQuery,
+                sessionGranularity: null,
+            };
+        }
+        return state;
+    }
+    if (state.chartType) {
+        const newChartType = state.chartType;
+        if ((newChartType === 'line' || newChartType === 'area') &&
+            (oldQuery.timeDimensions || []).length === 1 &&
+            !oldQuery.timeDimensions[0].granularity) {
+            const [td] = oldQuery.timeDimensions;
+            return {
+                ...state,
+                pivotConfig: null,
+                query: {
+                    ...oldQuery,
+                    timeDimensions: [{ ...td, granularity }],
+                },
+            };
+        }
+        if ((newChartType === 'pie' ||
+            newChartType === 'table' ||
+            newChartType === 'number') &&
+            (oldQuery.timeDimensions || []).length === 1 &&
+            oldQuery.timeDimensions[0].granularity) {
+            const [td] = oldQuery.timeDimensions;
+            return {
+                ...state,
+                pivotConfig: null,
+                shouldApplyHeuristicOrder: true,
+                query: {
+                    ...oldQuery,
+                    timeDimensions: [{ ...td, granularity: undefined }],
+                },
+            };
+        }
+    }
+    return state;
+}
+export function isQueryPresent(query) {
+    if (!query) {
+        return false;
+    }
+    return (Array.isArray(query) ? query : [query]).every((q) => q.measures?.length || q.dimensions?.length || q.timeDimensions?.length);
+}
+export function movePivotItem(pivotConfig, sourceIndex, destinationIndex, sourceAxis, destinationAxis) {
+    const nextPivotConfig = {
+        ...pivotConfig,
+        x: [...(pivotConfig.x || [])],
+        y: [...(pivotConfig.y || [])],
+    };
+    const id = pivotConfig[sourceAxis][sourceIndex];
+    const lastIndex = nextPivotConfig[destinationAxis].length - 1;
+    if (id === 'measures') {
+        destinationIndex = lastIndex + 1;
+    }
+    else if (sourceAxis === destinationAxis &&
+        destinationIndex >= lastIndex &&
+        nextPivotConfig[destinationAxis][lastIndex] === 'measures') {
+        destinationIndex = lastIndex - 1;
+    }
+    else if (sourceAxis !== destinationAxis &&
+        destinationIndex > lastIndex &&
+        nextPivotConfig[destinationAxis][lastIndex] === 'measures') {
+        destinationIndex = lastIndex;
+    }
+    nextPivotConfig[sourceAxis].splice(sourceIndex, 1);
+    nextPivotConfig[destinationAxis].splice(destinationIndex, 0, id);
+    return nextPivotConfig;
+}
+export function moveItemInArray(list, sourceIndex, destinationIndex) {
+    const result = [...list];
+    const [removed] = result.splice(sourceIndex, 1);
+    result.splice(destinationIndex, 0, removed);
+    return result;
+}
+export function flattenFilters(filters = []) {
+    return filters.reduce((memo, filter) => {
+        if ('or' in filter) {
+            return [...memo, ...flattenFilters(filter.or)];
+        }
+        if ('and' in filter) {
+            return [...memo, ...flattenFilters(filter.and)];
+        }
+        return [...memo, filter];
+    }, []);
+}
+export function getQueryMembers(query = {}) {
+    const keys = ['measures', 'dimensions', 'segments'];
+    const members = new Set();
+    keys.forEach((key) => (query[key] || []).forEach((member) => members.add(member)));
+    (query.timeDimensions || []).forEach((td) => members.add(td.dimension));
+    const filters = flattenFilters(query.filters);
+    filters.forEach((filter) => {
+        const member = filter.dimension || filter.member;
+        if (typeof member === 'string') {
+            members.add(member);
+        }
+    });
+    return [...members];
+}
+export function getOrderMembersFromOrder(orderMembers, order) {
+    const ids = new Set();
+    const indexedOrderMembers = indexBy(prop('id'), orderMembers);
+    const entries = Array.isArray(order) ? order : Object.entries(order || {});
+    const nextOrderMembers = [];
+    entries.forEach(([memberId, currentOrder]) => {
+        if (currentOrder !== 'none' && indexedOrderMembers[memberId]) {
+            ids.add(memberId);
+            nextOrderMembers.push({
+                ...indexedOrderMembers[memberId],
+                order: currentOrder,
+            });
+        }
+    });
+    orderMembers.forEach((member) => {
+        if (!ids.has(member.id)) {
+            nextOrderMembers.push({
+                ...member,
+                order: member.order || 'none',
+            });
+        }
+    });
+    return nextOrderMembers;
+}
+export function aliasSeries(values, index, pivotConfig, duplicateMeasures = new Set()) {
+    const nonNullValues = values.filter((value) => value != null);
+    if (pivotConfig?.aliasSeries?.[index]) {
+        return [pivotConfig.aliasSeries[index], ...nonNullValues];
+    }
+    else if (duplicateMeasures.has(nonNullValues[0])) {
+        return [index, ...nonNullValues];
+    }
+    return nonNullValues;
+}

package/dist/test/CubeApi.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license MIT License
+ * @copyright Cube Dev, Inc.
+ * @fileoverview Test signal parameter in CubeApi
+ */
+export {};
+//# sourceMappingURL=CubeApi.test.d.ts.map

package/dist/test/CubeApi.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CubeApi.test.d.ts","sourceRoot":"","sources":["../../test/CubeApi.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/test/CubeApi.test.js

@@ -0,0 +1,279 @@
+/**
+ * @license MIT License
+ * @copyright Cube Dev, Inc.
+ * @fileoverview Test signal parameter in CubeApi
+ */
+/* globals describe,test,expect,jest,beforeEach */
+/* eslint-disable import/first */
+import { CubeApi as CubeApiOriginal } from '../src';
+import HttpTransport from '../src/HttpTransport';
+import { DescriptiveQueryRequest, DescriptiveQueryRequestCompact, DescriptiveQueryResponse, NumericCastedData } from './helpers';
+import ResultSet from '../src/ResultSet';
+class CubeApi extends CubeApiOriginal {
+    getTransport() {
+        return this.transport;
+    }
+    makeRequest(method, params) {
+        return this.request(method, params);
+    }
+}
+describe('CubeApi Constructor', () => {
+    test('throw error if no api url', async () => {
+        try {
+            const _cubeApi = new CubeApi('token', {});
+            throw new Error('Should not get here');
+        }
+        catch (e) {
+            expect(e.message).toBe('The `apiUrl` option is required');
+        }
+    });
+});
+describe('CubeApi Load', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+    });
+    test('simple query, no options', async () => {
+        // Create a spy on the request method
+        jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(DescriptiveQueryResponse)),
+                json: () => Promise.resolve(DescriptiveQueryResponse)
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1',
+        });
+        const res = await cubeApi.load(DescriptiveQueryRequest);
+        expect(res).toBeInstanceOf(ResultSet);
+        expect(res.rawData()).toEqual(DescriptiveQueryResponse.results[0].data);
+    });
+    test('simple query + { mutexKey, castNumerics }', async () => {
+        // Create a spy on the request method
+        jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(DescriptiveQueryResponse)),
+                json: () => Promise.resolve(DescriptiveQueryResponse)
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi({
+            apiUrl: 'http://localhost:4000/cubejs-api/v1',
+        });
+        const res = await cubeApi.load(DescriptiveQueryRequest, { mutexKey: 'mutexKey', castNumerics: true });
+        expect(res).toBeInstanceOf(ResultSet);
+        expect(res.rawData()).toEqual(NumericCastedData);
+    });
+    test('simple query + compact response format', async () => {
+        // Create a spy on the request method
+        jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(DescriptiveQueryResponse)),
+                json: () => Promise.resolve(DescriptiveQueryResponse)
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1',
+        });
+        const res = await cubeApi.load(DescriptiveQueryRequestCompact, undefined, undefined, 'compact');
+        expect(res).toBeInstanceOf(ResultSet);
+        expect(res.rawData()).toEqual(DescriptiveQueryResponse.results[0].data);
+    });
+    test('2 queries', async () => {
+        // Create a spy on the request method
+        jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(DescriptiveQueryResponse)),
+                json: () => Promise.resolve(DescriptiveQueryResponse)
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1',
+        });
+        const res = await cubeApi.load([DescriptiveQueryRequest, DescriptiveQueryRequest]);
+        expect(res).toBeInstanceOf(ResultSet);
+        expect(res.rawData()).toEqual(DescriptiveQueryResponse.results[0].data);
+    });
+    test('2 queries + compact response format', async () => {
+        // Create a spy on the request method
+        jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(DescriptiveQueryResponse)),
+                json: () => Promise.resolve(DescriptiveQueryResponse)
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1',
+        });
+        const res = await cubeApi.load([DescriptiveQueryRequestCompact, DescriptiveQueryRequestCompact], undefined, undefined, 'compact');
+        expect(res).toBeInstanceOf(ResultSet);
+        expect(res.rawData()).toEqual(DescriptiveQueryResponse.results[0].data);
+    });
+});
+describe('CubeApi with Abort Signal', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+    });
+    test('should pass signal from constructor to request', async () => {
+        const controller = new AbortController();
+        const { signal } = controller;
+        // Create a spy on the request method
+        const requestSpy = jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve('{"results":[]}'),
+                json: () => Promise.resolve({ results: [] })
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1',
+            signal
+        });
+        // Create a second spy on the load method to verify signal is passed to HttpTransport
+        jest.spyOn(cubeApi, 'load');
+        await cubeApi.load({
+            measures: ['Orders.count']
+        });
+        // Check if the signal was passed to request method through load
+        expect(requestSpy).toHaveBeenCalled();
+        // The request method should receive the signal in the call
+        // Create a request in the same way as CubeApi.load does
+        cubeApi.makeRequest('load', {
+            query: { measures: ['Orders.count'] },
+            queryType: 'multi'
+        });
+        // Verify the transport is using the signal
+        expect(cubeApi.getTransport().signal).toBe(signal);
+    });
+    test('should pass signal from options to request', async () => {
+        const controller = new AbortController();
+        const { signal } = controller;
+        // Mock for this specific test
+        const requestSpy = jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve('{"results":[]}'),
+                json: () => Promise.resolve({ results: [] })
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1'
+        });
+        await cubeApi.load({ measures: ['Orders.count'] }, { signal });
+        expect(requestSpy).toHaveBeenCalled();
+        expect(requestSpy.mock.calls[0]?.[1]?.signal).toBe(signal);
+    });
+    test('options signal should override constructor signal', async () => {
+        const constructorController = new AbortController();
+        const optionsController = new AbortController();
+        // Mock for this specific test
+        const requestSpy = jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve('{"results":[]}'),
+                json: () => Promise.resolve({ results: [] })
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1',
+            signal: constructorController.signal
+        });
+        await cubeApi.load({ measures: ['Orders.count'] }, { signal: optionsController.signal });
+        expect(requestSpy).toHaveBeenCalled();
+        expect(requestSpy.mock.calls[0]?.[1]?.signal).toBe(optionsController.signal);
+        expect(requestSpy.mock.calls[0]?.[1]?.signal).not.toBe(constructorController.signal);
+    });
+    test('should pass signal to meta request', async () => {
+        const controller = new AbortController();
+        const { signal } = controller;
+        // Mock for meta with proper format - include dimensions, segments, and measures with required properties
+        const requestSpy = jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({
+                    cubes: [{
+                            name: 'Orders',
+                            title: 'Orders',
+                            measures: [{
+                                    name: 'count',
+                                    title: 'Count',
+                                    shortTitle: 'Count',
+                                    type: 'number'
+                                }],
+                            dimensions: [{
+                                    name: 'status',
+                                    title: 'Status',
+                                    type: 'string'
+                                }],
+                            segments: []
+                        }]
+                })),
+                json: () => Promise.resolve({
+                    cubes: [{
+                            name: 'Orders',
+                            title: 'Orders',
+                            measures: [{
+                                    name: 'count',
+                                    title: 'Count',
+                                    shortTitle: 'Count',
+                                    type: 'number'
+                                }],
+                            dimensions: [{
+                                    name: 'status',
+                                    title: 'Status',
+                                    type: 'string'
+                                }],
+                            segments: []
+                        }]
+                })
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1'
+        });
+        await cubeApi.meta({ signal });
+        expect(requestSpy).toHaveBeenCalled();
+        expect(requestSpy.mock.calls[0]?.[1]?.signal).toBe(signal);
+    });
+    test('should pass signal to sql request', async () => {
+        const controller = new AbortController();
+        const { signal } = controller;
+        // Mock for SQL response
+        const requestSpy = jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve('{"sql":{"sql":"SELECT * FROM orders"}}'),
+                json: () => Promise.resolve({ sql: { sql: 'SELECT * FROM orders' } })
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1'
+        });
+        await cubeApi.sql({ measures: ['Orders.count'] }, { signal });
+        expect(requestSpy).toHaveBeenCalled();
+        expect(requestSpy.mock.calls[0]?.[1]?.signal).toBe(signal);
+    });
+    test('should pass signal to dryRun request', async () => {
+        const controller = new AbortController();
+        const { signal } = controller;
+        // Mock for dryRun response
+        const requestSpy = jest.spyOn(HttpTransport.prototype, 'request').mockImplementation(() => ({
+            subscribe: (cb) => Promise.resolve(cb({
+                status: 200,
+                text: () => Promise.resolve('{"queryType":"regular"}'),
+                json: () => Promise.resolve({ queryType: 'regular' })
+            }, async () => undefined))
+        }));
+        const cubeApi = new CubeApi('token', {
+            apiUrl: 'http://localhost:4000/cubejs-api/v1'
+        });
+        await cubeApi.dryRun({ measures: ['Orders.count'] }, { signal });
+        expect(requestSpy).toHaveBeenCalled();
+        expect(requestSpy.mock.calls[0]?.[1]?.signal).toBe(signal);
+    });
+});

package/dist/test/HttpTransport.test.d.ts

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

package/dist/test/HttpTransport.test.d.ts.map

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