machinomy/lib/Storage.js

Micropayments powered by Ethereum

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const logger_1 = require("@machinomy/logger");
async function buildNedb(databaseUrl, inflator, namespace) {
    let EngineNedb = (await Promise.resolve().then(() => require('./storage/nedb/EngineNedb'))).default;
    let NedbTokensDatabase = (await Promise.resolve().then(() => require('./storage/nedb/NedbTokensDatabase'))).default;
    let NedbPaymentsDatabase = (await Promise.resolve().then(() => require('./storage/nedb/NedbPaymentsDatabase'))).default;
    let NedbChannelsDatabase = (await Promise.resolve().then(() => require('./storage/nedb/NedbChannelsDatabase'))).default;
    let NedbMigrator = (await Promise.resolve().then(() => require('./storage/nedb/NedbMigrator'))).default;
    let engine = new EngineNedb(databaseUrl, false);
    return {
        engine: engine,
        tokensDatabase: new NedbTokensDatabase(engine, namespace),
        paymentsDatabase: new NedbPaymentsDatabase(engine, namespace),
        channelsDatabase: new NedbChannelsDatabase(engine, inflator, namespace),
        migrator: new NedbMigrator()
    };
}
async function buildSqlite(databaseUrl, inflator, namespace) {
    let EngineSqlite = (await Promise.resolve().then(() => require('./storage/sqlite/EngineSqlite'))).default;
    let SqliteTokensDatabase = (await Promise.resolve().then(() => require('./storage/sqlite/SqliteTokensDatabase'))).default;
    let SqlitePaymentsDatabase = (await Promise.resolve().then(() => require('./storage/sqlite/SqlitePaymentsDatabase'))).default;
    let SqliteChannelsDatabase = (await Promise.resolve().then(() => require('./storage/sqlite/SqliteChannelsDatabase'))).default;
    let SqliteMigrator = (await Promise.resolve().then(() => require('./storage/sqlite/SqliteMigrator'))).default;
    let engine = new EngineSqlite(databaseUrl);
    return {
        engine: engine,
        tokensDatabase: new SqliteTokensDatabase(engine, namespace),
        paymentsDatabase: new SqlitePaymentsDatabase(engine, namespace),
        channelsDatabase: new SqliteChannelsDatabase(engine, inflator, namespace),
        migrator: new SqliteMigrator(databaseUrl)
    };
}
async function buildPostgres(databaseUrl, inflator, namespace) {
    let EnginePostgres = (await Promise.resolve().then(() => require('./storage/postgresql/EnginePostgres'))).default;
    let PostgresTokensDatabase = (await Promise.resolve().then(() => require('./storage/postgresql/PostgresTokensDatabase'))).default;
    let PostgresPaymentsDatabase = (await Promise.resolve().then(() => require('./storage/postgresql/PostgresPaymentsDatabase'))).default;
    let PostgresChannelsDatabase = (await Promise.resolve().then(() => require('./storage/postgresql/PostgresChannelsDatabase'))).default;
    let PostgresqlMigrator = (await Promise.resolve().then(() => require('./storage/postgresql/PostgresqlMigrator'))).default;
    let engine = new EnginePostgres(databaseUrl);
    return {
        engine: engine,
        tokensDatabase: new PostgresTokensDatabase(engine, namespace),
        paymentsDatabase: new PostgresPaymentsDatabase(engine, namespace),
        channelsDatabase: new PostgresChannelsDatabase(engine, inflator, namespace),
        migrator: new PostgresqlMigrator(databaseUrl)
    };
}
const log = new logger_1.default('storage');
var Storage;
(function (Storage) {
    function build(databaseUrl, inflator) {
        const splits = databaseUrl.split('://');
        const protocol = splits[0];
        const namespace = 'shared'; // TODO Namespace
        log.info('Found protocol %s', protocol);
        switch (protocol) {
            case 'nedb':
                log.info('Use nedb database');
                return buildNedb(splits[1], inflator, namespace);
            case 'postgresql':
                log.info('Use postgresql database');
                return buildPostgres(databaseUrl, inflator, namespace);
            case 'sqlite':
                log.info('Use sqlite database');
                return buildSqlite(databaseUrl, inflator, namespace);
            default:
                throw new Error(`Unsupported database protocol: ${protocol}`);
        }
    }
    Storage.build = build;
})(Storage = exports.Storage || (exports.Storage = {}));
exports.default = Storage;
//# sourceMappingURL=Storage.js.map