Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

10.9 KB
Raw Blame
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project

const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const {test} = require('node:test');
const {transformSync} = require('@babel/core');
const {createStore} = require('zustand/vanilla');

// Exercise the adapter's state/middleware contract without loading WebGL or
// downloading DuckDB. The task runtime and Zustand store are the real modules.
function loadTypeScript(filename, dependencies = {}) {
  const {code} = transformSync(fs.readFileSync(filename, 'utf8'), {
    filename,
    babelrc: false,
    configFile: false,
    presets: [['@babel/preset-typescript', {allowDeclareFields: true}]],
    plugins: ['@babel/plugin-transform-modules-commonjs']
  });
  const module = {exports: {}};
  const load = id => {
    if (Object.hasOwn(dependencies, id)) return dependencies[id];
    return require(id);
  };
  new Function('require', 'module', 'exports', code)(load, module, module.exports);
  return module.exports;
}

const sourceDir = path.resolve(__dirname, '../src');
const tasks = loadTypeScript(path.resolve(sourceDir, '../../tasks-core/src/index.ts'));
const config = loadTypeScript(path.join(sourceDir, 'config/index.ts'));
const persistence = loadTypeScript(path.join(sourceDir, 'keplerConfigPersistence.ts'));
const tableIdentity = table => `"${table.database}"."${table.schema}"."${table.table}"`;
const duckdbCore = {
  getTableIdentity: tableIdentity,
  getUnqualifiedSqlIdentifier: value => value.split('.').at(-1).replaceAll('"', '')
};
const tableSelection = loadTypeScript(path.join(sourceDir, 'keplerTableSelection.ts'), {
  '@sqlrooms/duckdb-core': duckdbCore
});
const wrapTo = (id, action) => {
  const wrap = input => ({...input, payload: {...input.payload, meta: {_id_: id}}});
  return action ? wrap(action) : wrap;
};
const actions = {
  ActionTypes: {LAYER_HOVER: 'hover', UPDATE_MAP: 'pan', MOUSE_MOVE: 'mouse'},
  wrapTo,
  registerEntry: payload => ({type: 'register', payload}),
  deleteEntry: id => ({type: 'delete', payload: {id}}),
  addDataToMap: payload => ({type: 'add-data', payload}),
  requestMapStyles: payload => ({type: 'styles', payload})
};

function emptyMap() {
  return {
    visState: {
      layers: [],
      filters: [],
      datasets: {},
      layerToBeMerged: [],
      filterToBeMerged: [],
      splitMapsToBeMerged: [],
      interactionToBeMerged: {},
      isMergingDatasets: {}
    },
    mapState: {},
    mapStyle: {mapStyles: {}, styleType: 'positron'},
    uiState: {}
  };
}

function reducer(state = {}, action) {
  if (action.type === 'register') return {...state, [action.payload.id]: emptyMap()};
  if (action.type === 'delete') {
    const result = {...state};
    delete result[action.payload.id];
    return result;
  }
  const id = action.payload.meta._id_;
  const map = state[id];
  if (action.type === 'add-data') {
    let visState = {...map.visState};
    if (action.payload.config?.visState) {
      // Kepler keeps configurations waiting for datasets in these collections.
      visState.layerToBeMerged = action.payload.config.visState.layers ?? [];
      visState.filterToBeMerged = action.payload.config.visState.filters ?? [];
    }
    const dataset = action.payload.datasets;
    const nextState = {...state, [id]: {...map, visState}};
    if (!Array.isArray(dataset)) {
      const createDataset = tasks.fromPromise(
        () => new Promise(resolve => setTimeout(() => resolve(dataset), 15)),
        'CREATE_DATASET'
      )();
      // The real Kepler reducer combines dataset creation tasks this way.
      return tasks.withTask(
        nextState,
        tasks
          .allSettled([createDataset])
          .map(([result]) => ({type: 'dataset-ready', payload: {dataset: result.value}}))
      );
    }
    return nextState;
  }
  if (action.type === 'dataset-ready') {
    const dataset = action.payload.dataset;
    const datasets = {...map.visState.datasets, [dataset.info.id]: dataset};
    return {
      ...state,
      [id]: {
        ...map,
        visState: {
          ...map.visState,
          datasets,
          layers: map.visState.layerToBeMerged,
          filters: map.visState.filterToBeMerged,
          layerToBeMerged: [],
          filterToBeMerged: []
        }
      }
    };
  }
  return state;
}
reducer.initialState = () => reducer;

const {createKeplerSlice} = loadTypeScript(path.join(sourceDir, 'KeplerSlice.ts'), {
  '@kepler.gl/actions': actions,
  '@kepler.gl/constants': {ALL_FIELD_TYPES: {}},
  '@kepler.gl/duckdb': {
    getDuckDBColumnTypes: async () => [],
    getDuckDBColumnTypesMap: () => ({}),
    castDuckDBTypesForKepler: table => `SELECT * FROM ${table}`,
    setGeoArrowWKBExtension: () => {},
    restoreGeoarrowMetadata: () => {}
  },
  '@kepler.gl/processors': {arrowSchemaToFields: () => []},
  '@kepler.gl/reducers': {keplerGlReducer: reducer, INITIAL_UI_STATE: {mapControls: {}}},
  '@kepler.gl/schemas': {
    KeplerGLSchemaClass: class {
      parseSavedConfig(value) {
        return value.config;
      }
      getConfigToSave(map) {
        return {
          version: 'v1',
          config: {
            visState: {
              layers: [...map.visState.layers, ...map.visState.layerToBeMerged],
              filters: [...map.visState.filters, ...map.visState.filterToBeMerged]
            },
            mapState: map.mapState,
            mapStyle: map.mapStyle,
            uiState: map.uiState
          }
        };
      }
    }
  },
  '@kepler.gl/table': {KeplerTable: class {}},
  '@kepler.gl/utils': {initApplicationConfig: () => {}},
  '@kepler.gl/tasks-core': tasks,
  '@sqlrooms/room-shell': {createSlice: creator => creator},
  '@sqlrooms/ui': {getTheme: () => 'light'},
  '@sqlrooms/duckdb-core': duckdbCore,
  './config': config,
  './keplerConfigPersistence': persistence,
  './keplerTableSelection': tableSelection
});

const table = {table: {database: 'memory', schema: 'main', table: 'earthquakes'}};
function savedConfig() {
  return {
    maps: [
      {
        id: 'map',
        name: 'Saved map',
        config: {
          version: 'v1',
          config: {
            visState: {
              layers: [{id: 'points', config: {dataId: 'earthquakes'}}],
              filters: [{id: 'magnitude', dataId: ['earthquakes']}]
            },
            mapState: {zoom: 4},
            mapStyle: {},
            uiState: {}
          }
        }
      }
    ]
  };
}
function makeStore(initialConfig = {maps: [{id: 'map', name: 'Map'}]}) {
  tasks.drainTasksForTesting();
  const queriedTables = [];
  const store = createStore((set, get, api) => ({
    db: {
      tables: [table],
      currentDatabase: 'memory',
      currentSchema: 'main',
      getConnector: async () => ({
        query: sql => {
          queriedTables.push(sql);
          return {result: Promise.resolve({numCols: 0})};
        }
      })
    },
    ...createKeplerSlice({config: initialConfig})(set, get, api)
  }));
  return {store, queriedTables};
}

test('addTableToMap resolves after tasks-core has installed the dataset', async () => {
  const {store} = makeStore();
  await store.getState().kepler.initialize();
  await store.getState().kepler.addTableToMap('map', 'earthquakes');
  assert.ok(store.getState().kepler.map.map.visState.datasets.earthquakes);
});

test('initial saved config restores pending layers and filters from DuckDB', async () => {
  const {store, queriedTables} = makeStore(savedConfig());
  await store.getState().kepler.initialize();
  const state = store.getState().kepler;
  assert.equal(queriedTables.length, 1);
  assert.ok(state.map.map.visState.datasets.earthquakes);
  assert.equal(state.map.map.visState.layers[0].id, 'points');
  assert.equal(state.map.map.visState.filters[0].id, 'magnitude');
  assert.equal(state.isRestoringConfig, false);
  assert.deepEqual(state.config, savedConfig());
});

test('setConfig and waitForConfigRestore wait for pending dataset tasks', async () => {
  const {store} = makeStore();
  await store.getState().kepler.initialize();
  store.getState().kepler.setConfig(savedConfig());
  await store.getState().kepler.waitForConfigRestore();
  assert.ok(store.getState().kepler.map.map.visState.datasets.earthquakes);
  assert.equal(store.getState().kepler.map.map.visState.layers[0].id, 'points');
  assert.equal(store.getState().kepler.isRestoringConfig, false);
});

test('saved filter references restore a table without any map layers', async () => {
  const initialConfig = savedConfig();
  initialConfig.maps[0].config.config.visState.layers = [];
  const {store} = makeStore(initialConfig);
  await store.getState().kepler.initialize();
  assert.ok(store.getState().kepler.map.map.visState.datasets.earthquakes);
  assert.equal(store.getState().kepler.map.map.visState.filters[0].id, 'magnitude');
});

test('Redux facade dispatch runs task middleware and notifies subscribers', async () => {
  const {store} = makeStore();
  await store.getState().kepler.initialize();
  const redux = store.getState().kepler.__reduxProviderStore;
  let changes = 0;
  const unsubscribe = redux.subscribe(() => changes++);
  await redux.dispatch(
    wrapTo(
      'map',
      actions.addDataToMap({
        datasets: {info: {id: 'direct'}, data: {}}
      })
    )
  );
  assert.ok(redux.getState().map.visState.datasets.direct);
  assert.ok(changes >= 2);
  unsubscribe();
  const previousChanges = changes;
  await store.getState().kepler.addTableToMap('map', 'earthquakes');
  assert.equal(changes, previousChanges);
});

test('task middleware waits for callback task error actions', async () => {
  tasks.drainTasksForTesting();
  const task = tasks
    .fromCallback((_arg, done) => {
      setTimeout(() => done(new Error('Dataset unavailable')), 15);
    }, 'CALLBACK_DATASET')()
    .bimap(
      () => ({type: 'success'}),
      error => ({type: 'failure', message: error.message})
    );
  const received = [];
  const dispatch = tasks.taskMiddleware({dispatch: action => dispatch(action)})(action => {
    if (action.type === 'start') tasks.withTask({}, task);
    else received.push(action);
  });
  await dispatch({type: 'start'});
  assert.deepEqual(received, [{type: 'failure', message: 'Dataset unavailable'}]);
});

test('task middleware rejects when an asynchronous mapper throws', {timeout: 1000}, async () => {
  tasks.drainTasksForTesting();
  const task = tasks
    .fromPromise(async () => null, 'THROWING_MAPPER')()
    .map(() => {
      throw new Error('Invalid dataset result');
    });
  const dispatch = tasks.taskMiddleware({dispatch: action => dispatch(action)})(action => {
    if (action.type === 'start') tasks.withTask({}, task);
  });
  await assert.rejects(dispatch({type: 'start'}), /Invalid dataset result/);
});

test('parallel task simulation remains synchronous', () => {
  const create = tasks.fromPromise(async () => 'unused', 'SIMULATED_TASK');
  const combined = tasks.allSettled([create(), create()]);
  assert.deepEqual(tasks.succeedTaskInTest(combined, 'fixture'), [
    {status: 'fulfilled', value: 'fixture'},
    {status: 'fulfilled', value: 'fixture'}
  ]);
});