@cubejs-client/core 1.3.15 → 1.3.16

package/src/HttpTransport.js

@@ -1,60 +0,0 @@
-import fetch from 'cross-fetch';
-import 'url-search-params-polyfill';
-
-class HttpTransport {
-  constructor({ authorization, apiUrl, method, headers = {}, credentials, fetchTimeout }) {
-    this.authorization = authorization;
-    this.apiUrl = apiUrl;
-    this.method = method;
-    this.headers = headers;
-    this.credentials = credentials;
-    this.fetchTimeout = fetchTimeout;
-  }
-
-  request(method, { baseRequestId, ...params }) {
-    let spanCounter = 1;
-    const searchParams = new URLSearchParams(
-      params && Object.keys(params)
-        .map(k => ({ [k]: typeof params[k] === 'object' ? JSON.stringify(params[k]) : params[k] }))
-        .reduce((a, b) => ({ ...a, ...b }), {})
-    );
-
-    let url = `${this.apiUrl}/${method}${searchParams.toString().length ? `?${searchParams}` : ''}`;
-
-    const requestMethod = this.method || (url.length < 2000 ? 'GET' : 'POST');
-    if (requestMethod === 'POST') {
-      url = `${this.apiUrl}/${method}`;
-      this.headers['Content-Type'] = 'application/json';
-    }
-
-    // Currently, all methods make GET requests. If a method makes a request with a body payload,
-    // remember to add {'Content-Type': 'application/json'} to the header.
-    const runRequest = () => fetch(url, {
-      method: requestMethod,
-      headers: {
-        Authorization: this.authorization,
-        'x-request-id': baseRequestId && `${baseRequestId}-span-${spanCounter++}`,
-        ...this.headers
-      },
-      credentials: this.credentials,
-      body: requestMethod === 'POST' ? JSON.stringify(params) : null,
-      signal: this.fetchTimeout ? AbortSignal.timeout(this.fetchTimeout) : undefined,
-    });
-
-    return {
-      /* eslint no-unsafe-finally: off */
-      async subscribe(callback) {
-        let result = {
-          error: 'network Error' // add default error message
-        };
-        try {
-          result = await runRequest();
-        } finally {
-          return callback(result, () => this.subscribe(callback));
-        }
-      }
-    };
-  }
-}
-
-export default HttpTransport;

package/src/HttpTransport.test.js

@@ -1,117 +0,0 @@
-/* eslint-disable import/first */
-/* eslint-disable import/newline-after-import */
-/* globals describe,test,expect,jest,afterEach,beforeAll */
-import '@babel/runtime/regenerator';
-jest.mock('cross-fetch');
-import fetch from 'cross-fetch';
-import HttpTransport from './HttpTransport';
-
-describe('HttpTransport', () => {
-  const apiUrl = 'http://localhost:3000/cubejs-api/v1';
-  const query = {
-    measures: ['Orders.count'],
-    dimensions: ['Users.country']
-  };
-  const queryUrlEncoded = '%7B%22measures%22%3A%5B%22Orders.count%22%5D%2C%22dimensions%22%3A%5B%22Users.country%22%5D%7D';
-  const queryJson = '{"query":{"measures":["Orders.count"],"dimensions":["Users.country"]}}';
-
-  const ids = [];
-  for (let i = 0; i < 40; i++) ids.push('a40b2052-4137-11eb-b378-0242ac130002');
-  const LargeQuery = {
-    measures: ['Orders.count'],
-    dimensions: ['Users.country'],
-    filters: [
-      {
-        member: 'Users.id',
-        operator: 'equals',
-        values: ids
-      }
-    ]
-  };
-  const largeQueryJson = `{"query":{"measures":["Orders.count"],"dimensions":["Users.country"],"filters":[{"member":"Users.id","operator":"equals","values":${JSON.stringify(ids)}}]}}`;
-
-  beforeAll(() => {
-    fetch.mockReturnValue(Promise.resolve({ ok: true }));
-  });
-
-  afterEach(() => {
-    fetch.mockClear();
-  });
-
-  test('it serializes the query object and sends it in the query string', async () => {
-    const transport = new HttpTransport({
-      authorization: 'token',
-      apiUrl,
-    });
-    const req = transport.request('load', { query });
-    await req.subscribe(() => { });
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith(`${apiUrl}/load?query=${queryUrlEncoded}`, {
-      method: 'GET',
-      headers: {
-        Authorization: 'token',
-      },
-      body: null
-    });
-  });
-
-  test('it passes extra headers and serializes extra params', async () => {
-    const extraParams = { foo: 'bar' };
-    const serializedExtraParams = encodeURIComponent(JSON.stringify(extraParams));
-    const transport = new HttpTransport({
-      authorization: 'token',
-      apiUrl,
-      headers: {
-        'X-Extra-Header': '42'
-      }
-    });
-    const req = transport.request('meta', { extraParams });
-    await req.subscribe(() => { });
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith(`${apiUrl}/meta?extraParams=${serializedExtraParams}`, {
-      method: 'GET',
-      headers: {
-        Authorization: 'token',
-        'X-Extra-Header': '42'
-      },
-      body: null
-    });
-  });
-
-  test('it serializes the query object and sends it in the body', async () => {
-    const transport = new HttpTransport({
-      authorization: 'token',
-      apiUrl,
-      method: 'POST'
-    });
-    const req = transport.request('load', { query });
-    await req.subscribe(() => { });
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith(`${apiUrl}/load`, {
-      method: 'POST',
-      headers: {
-        Authorization: 'token',
-        'Content-Type': 'application/json'
-      },
-      body: queryJson
-    });
-  });
-
-  test('it use POST over GET if url length is more than 2000 characters', async () => {
-    const transport = new HttpTransport({
-      authorization: 'token',
-      apiUrl
-    });
-    const req = transport.request('load', { query: LargeQuery });
-    await req.subscribe(() => { });
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith(`${apiUrl}/load`, {
-      method: 'POST',
-      headers: {
-        Authorization: 'token',
-        'Content-Type': 'application/json'
-      },
-      body: largeQueryJson
-    });
-  });
-});

package/src/Meta.js

@@ -1,142 +0,0 @@
-/**
- * @module @cubejs-client/core
- */
-
-import { unnest, fromPairs } from 'ramda';
-
-const memberMap = (memberArray) => fromPairs(memberArray.map((m) => [m.name, m]));
-
-const operators = {
-  string: [
-    { name: 'contains', title: 'contains' },
-    { name: 'notContains', title: 'does not contain' },
-    { name: 'equals', title: 'equals' },
-    { name: 'notEquals', title: 'does not equal' },
-    { name: 'set', title: 'is set' },
-    { name: 'notSet', title: 'is not set' },
-    { name: 'startsWith', title: 'starts with' },
-    { name: 'notStartsWith', title: 'does not start with' },
-    { name: 'endsWith', title: 'ends with' },
-    { name: 'notEndsWith', title: 'does not end with' },
-  ],
-  number: [
-    { name: 'equals', title: 'equals' },
-    { name: 'notEquals', title: 'does not equal' },
-    { name: 'set', title: 'is set' },
-    { name: 'notSet', title: 'is not set' },
-    { name: 'gt', title: '>' },
-    { name: 'gte', title: '>=' },
-    { name: 'lt', title: '<' },
-    { name: 'lte', title: '<=' },
-  ],
-  time: [
-    { name: 'equals', title: 'equals' },
-    { name: 'notEquals', title: 'does not equal' },
-    { name: 'inDateRange', title: 'in date range' },
-    { name: 'notInDateRange', title: 'not in date range' },
-    { name: 'afterDate', title: 'after date' },
-    { name: 'afterOrOnDate', title: 'after or on date' },
-    { name: 'beforeDate', title: 'before date' },
-    { name: 'beforeOrOnDate', title: 'before or on date' },
-  ],
-};
-
-/**
- * Contains information about available cubes and it's members.
- */
-class Meta {
-  constructor(metaResponse) {
-    this.meta = metaResponse;
-    const { cubes } = this.meta;
-    this.cubes = cubes;
-    this.cubesMap = fromPairs(
-      cubes.map((c) => [
-        c.name,
-        {
-          measures: memberMap(c.measures),
-          dimensions: memberMap(c.dimensions),
-          segments: memberMap(c.segments),
-        },
-      ])
-    );
-  }
-
-  membersForQuery(query, memberType) {
-    return unnest(this.cubes.map((c) => c[memberType])).sort((a, b) => (a.title > b.title ? 1 : -1));
-  }
-
-  membersGroupedByCube() {
-    const memberKeys = ['measures', 'dimensions', 'segments', 'timeDimensions'];
-
-    return this.cubes.reduce(
-      (memo, cube) => {
-        memberKeys.forEach((key) => {
-          let members = cube[key];
-
-          if (key === 'timeDimensions') {
-            members = cube.dimensions.filter((m) => m.type === 'time');
-          }
-
-          memo[key] = [
-            ...memo[key],
-            {
-              cubeName: cube.name,
-              cubeTitle: cube.title,
-              type: cube.type,
-              public: cube.public,
-              members
-            },
-          ];
-        });
-
-        return memo;
-      },
-      {
-        measures: [],
-        dimensions: [],
-        segments: [],
-        timeDimensions: [],
-      }
-    );
-  }
-
-  resolveMember(memberName, memberType) {
-    const [cube] = memberName.split('.');
-
-    if (!this.cubesMap[cube]) {
-      return { title: memberName, error: `Cube not found ${cube} for path '${memberName}'` };
-    }
-
-    const memberTypes = Array.isArray(memberType) ? memberType : [memberType];
-    const member = memberTypes
-      .map((type) => this.cubesMap[cube][type] && this.cubesMap[cube][type][memberName])
-      .find((m) => m);
-
-    if (!member) {
-      return {
-        title: memberName,
-        error: `Path not found '${memberName}'`,
-      };
-    }
-
-    return member;
-  }
-
-  defaultTimeDimensionNameFor(memberName) {
-    const [cube] = memberName.split('.');
-    if (!this.cubesMap[cube]) {
-      return null;
-    }
-    return Object.keys(this.cubesMap[cube].dimensions || {}).find(
-      (d) => this.cubesMap[cube].dimensions[d].type === 'time'
-    );
-  }
-
-  filterOperatorsForMember(memberName, memberType) {
-    const member = this.resolveMember(memberName, memberType);
-
-    return operators[member.type] || operators.string;
-  }
-}
-
-export default Meta;

package/src/ProgressResult.js

@@ -1,13 +0,0 @@
-export default class ProgressResult {
-  constructor(progressResponse) {
-    this.progressResponse = progressResponse;
-  }
-
-  stage() {
-    return this.progressResponse.stage;
-  }
-
-  timeElapsed() {
-    return this.progressResponse.timeElapsed;
-  }
-}

package/src/RequestError.js

@@ -1,7 +0,0 @@
-export default class RequestError extends Error {
-  constructor(message, response, status) {
-    super(message);
-    this.response = response;
-    this.status = status;
-  }
-}