@openland/foundationdb-core/lib/index.js

Node.js bindings for the FoundationDB database

"use strict";
// Stuff that hasn't been ported over:
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
// const Transactional = require('./retryDecorator')
// const locality = require('./locality')
// const directory = require('./directory')
const native_1 = __importDefault(require("./native"));
const database_1 = require("./database");
const opts_1 = require("./opts");
const opts_g_1 = require("./opts.g");
const apiVersion = __importStar(require("./apiVersion"));
// Must be called before fdb is initialized. Eg setAPIVersion(510).
var apiVersion_1 = require("./apiVersion");
exports.setAPIVersion = apiVersion_1.set;
// This is called implicitly when the first cluster / db is opened.
let initCalled = false;
const init = () => {
    if (apiVersion.get() == null) {
        throw Error('You must specify an API version to connect to FoundationDB. Eg: fdb.setAPIVersion(510);');
    }
    if (initCalled) {
        return;
    }
    initCalled = true;
    native_1.default.startNetwork();
    process.on('exit', () => native_1.default.stopNetwork());
};
// Destroy the network thread. This is not needed under normal circumstances;
// but can be used to de-init FDB.
exports.stopNetworkSync = native_1.default.stopNetwork;
var error_1 = require("./error");
exports.FDBError = error_1.default;
var keySelector_1 = require("./keySelector");
exports.keySelector = keySelector_1.default;
// These are exported to give consumers access to the type. Databases must
// always be constructed using open or via a cluster object.
var database_2 = require("./database");
exports.Database = database_2.default;
var transaction_1 = require("./transaction");
exports.Transaction = transaction_1.default;
var opts_g_2 = require("./opts.g");
exports.NetworkOptionCode = opts_g_2.NetworkOptionCode;
exports.DatabaseOptionCode = opts_g_2.DatabaseOptionCode;
exports.TransactionOptionCode = opts_g_2.TransactionOptionCode;
exports.StreamingMode = opts_g_2.StreamingMode;
exports.MutationType = opts_g_2.MutationType;
exports.ConflictRangeType = opts_g_2.ConflictRangeType;
exports.ErrorPredicate = opts_g_2.ErrorPredicate;
const wrapCluster = (cluster) => ({
    openDatabase(dbName = 'DB', opts) {
        return __awaiter(this, void 0, void 0, function* () {
            const db = database_1.createDatabase(cluster.openDatabaseSync(dbName));
            if (opts) {
                db.setNativeOptions(opts);
            }
            return db;
        });
    },
    close() { cluster.close(); }
});
exports.createCluster = (clusterFile) => __awaiter(this, void 0, void 0, function* () {
    init();
    let c = native_1.default.createClusterSync(clusterFile);
    return wrapCluster(c);
});
// Can only be called before open() or openSync().
function configNetwork(netOpts) {
    if (initCalled) {
        throw Error('configNetwork must be called before FDB connections are opened');
    }
    opts_1.eachOption(opts_g_1.networkOptionData, netOpts, (code, val) => native_1.default.setNetworkOption(code, val));
}
exports.configNetwork = configNetwork;
// Returns a promise to a database.
// Note any network configuration must preceed this call.
function open(clusterFile, dbOpts) {
    return exports.createCluster(clusterFile).then(c => c.openDatabase('DB', dbOpts));
}
exports.open = open;
// TODO: Should I expose a method here for stopping the network for clean shutdown?
// I feel like I should.. but I'm not sure when its useful. Will the network thread
// keep the process running?
//# sourceMappingURL=index.js.map