stitch-ui/src/services/mongodb/reducers.js

import { createReducer } from "redux-act";
import { OrderedMap } from "immutable";
import * as actions from "./actions";
import * as svcActions from "../actions";
import { MongoDBServiceRule } from "./mongodb_rule";
import { isMongoService } from "../registry";

export default createReducer(
  {
    [svcActions.loadSvcActions.rcv]: (state, payload) => {
      if (!isMongoService(payload.payload.type)) {
        return state;
      }
      return {
        ...state,
        rules: new OrderedMap(payload.payload.rules || {}).map(
          raw => new MongoDBServiceRule(raw)
        )
      };
    },
    [actions.setDatabase]: (state, payload) => ({
      ...state,
      database: payload
    }),
    [actions.setCollection]: (state, payload) => ({
      ...state,
      collection: payload
    }),
    [actions.setCreateNamespaceError]: (state, payload) => ({
      ...state,
      createNamespaceError: payload
    }),

    [actions.addFilter]: (state, { ruleId }) => ({
      ...state,
      rules: state.rules.update(ruleId, r => r.addFilter())
    }),

    [actions.removeFilter]: (state, { ruleId, index }) => ({
      ...state,
      rules: state.rules.update(ruleId, r => r.removeFilter(index))
    }),

    [actions.setRule]: (state, { rule }) => ({
      ...state,
      rules: state.rules.set(rule._id, rule)
    }),

    [actions.setEditingPath]: (state, { ruleId, path, elements, other }) => ({
      ...state,
      rulesEditState: state.rulesEditState
        .setIn([ruleId, "editingPath", "path"], path)
        .setIn([ruleId, "editingPath", "elements"], elements)
        .setIn([ruleId, "editingPath", "other"], other)
    }),

    [actions.unsetEditingPath]: (state, { ruleId }) => ({
      ...state,
      rulesEditState: state.rulesEditState.setIn([ruleId, "editingPath"], null)
    }),

    [actions.pushHoveringPath]: (state, { ruleId, path, elements, other }) => ({
      ...state,
      rulesEditState: state.rulesEditState.updateIn(
        [ruleId, "hoveringPath"],
        x => (x || []).concat([{ path, elements, other }])
      )
    }),

    [actions.popHoveringPath]: (state, { ruleId }) => ({
      ...state,
      rulesEditState: state.rulesEditState.updateIn(
        [ruleId, "hoveringPath"],
        x => (!x || x.length === 0 ? x : x.slice(0, x.length - 1))
      )
    }),

    [actions.setNewFieldInput]: (state, { ruleId, path, value }) => ({
      ...state,
      rules: state.rules.update(ruleId, r => r.changeNewFieldInput(path, value))
    }),

    [actions.setOtherFieldsEnabled]: (state, { ruleId, path, enabled }) => ({
      ...state,
      rules: state.rules.update(ruleId, r =>
        r.setOtherFieldsEnabled(path, enabled)
      )
    }),

    [actions.addField]: (state, { ruleId, path, field }) => ({
      ...state,
      rules: state.rules.update(ruleId, r => r.addField(path, field))
    }),
    [actions.removeField]: (state, { ruleId, path }) => ({
      ...state,
      rules: state.rules.update(ruleId, r => r.removeField(path))
    }),
    [actions.setFieldType]: (state, { ruleId, field, type }) => ({
      ...state,
      rules: state.rules.update(ruleId, r => r.setFieldType(field, type))
    }),
    [actions.discardFilterChanges]: (state, { ruleId, index }) => ({
      ...state,
      rules: state.rules.update(ruleId, r => r.discardFilterChanges(index))
    }),
    [actions.setFilterWhenInput]: (state, { ruleId, index, value }) => ({
      ...state,
      rules: state.rules.update(ruleId, r => r.setFilterWhenInput(index, value))
    }),
    [actions.setFilterMatchInput]: (state, { ruleId, index, value }) => ({
      ...state,
      rules: state.rules.update(ruleId, r =>
        r.setFilterMatchInput(index, value)
      )
    }),

    [actions.discardPermissionsInput]: (state, { ruleId, type }) => {
      const { editingPath } = state.rulesEditState.get(ruleId).toJS();
      return {
        ...state,
        rules: state.rules.update(ruleId, r =>
          r.discardPermissionsInput(
            editingPath.path,
            editingPath.elements,
            editingPath.other,
            type
          )
        )
      };
    },

    [actions.setPermissionsInput]: (state, { ruleId, field, value }) => {
      const { editingPath } = state.rulesEditState.get(ruleId).toJS();
      return {
        ...state,
        rules: state.rules.updateIn([ruleId, "fieldRules"], r =>
          r.updatePermissionsInput(
            editingPath.path,
            editingPath.elements,
            editingPath.other,
            field,
            value
          )
        )
      };
    }
  },
  {
    database: "",
    collection: "",
    createNamespaceError: null,
    rules: new OrderedMap(),
    rulesEditState: new OrderedMap()
  }
);