libpiggy/lib/create-store.js

Use a PostgreSQL database like a JSON document store.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _defaultsDeep = require('lodash/defaultsDeep');

var _defaultsDeep2 = _interopRequireDefault(_defaultsDeep);

var _createClient = require('./create-client');

var _createClient2 = _interopRequireDefault(_createClient);

var _createTable = require('./create-table');

var _createTable2 = _interopRequireDefault(_createTable);

var _createWatchedTable = require('./create-watched-table');

var _createWatchedTable2 = _interopRequireDefault(_createWatchedTable);

var _tableExists = require('./table-exists');

var _tableExists2 = _interopRequireDefault(_tableExists);

var _createStoreIndexes = require('./create-store-indexes');

var _createStoreIndexes2 = _interopRequireDefault(_createStoreIndexes);

var _constants = require('./constants');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const defaults = {
  checkExists: false,
  watch: false,
  watchWhen: false,
  indexes: false,
  columnNames: {
    key: 'key',
    val: 'val',
    createdAt: 'created_at',
    updatedAt: 'updated_at'
  }
};

const createStore = (() => {
  var _ref = (0, _asyncToGenerator3.default)(function* ({ client, table, index, options }, globals) {
    let clientCreated = false;

    const settings = (0, _defaultsDeep2.default)({}, options, defaults);
    const {
      watch,
      watchWhen,
      checkExists,
      indexes,
      columnNames
    } = settings;
    const columns = `"${columnNames.key}" text primary key, "${columnNames.val}" jsonb, "${columnNames.createdAt}" timestamp with time zone, "${columnNames.updatedAt}" timestamp with time zone`;

    try {
      if (!client) {
        client = yield (0, _createClient2.default)(options, globals);
        clientCreated = true;
      }

      let results;
      let code;

      let exists = false;

      if (checkExists) {
        const existsResults = yield (0, _tableExists2.default)({ client, table });
        exists = existsResults.exists;
      }

      if (exists) {
        code = _constants.EXISTS;
      } else {
        if (watch) {
          results = yield (0, _createWatchedTable2.default)({
            client,
            table,
            columns,
            when: watchWhen,
            key: columnNames.key
          });
        } else {
          results = yield (0, _createTable2.default)({ client, table, columns });
        }

        const checkResults = yield (0, _tableExists2.default)({ client, table });

        if (checkResults.results) {
          code = _constants.CREATED;
        } else {
          throw new Error('created table does not exist');
        }
      }

      if (index) {
        yield (0, _createStoreIndexes2.default)({ client, table, indexes, columnNames });
      }

      return {
        settings,
        columns,
        client,
        table,
        results,
        code
      };
    } catch (error) {
      error.code = _constants.ERROR;
      throw error;
    } finally {
      if (clientCreated) {
        client.close();
      }
    }
  });

  return function createStore(_x, _x2) {
    return _ref.apply(this, arguments);
  };
})();

exports.default = createStore;