@accounts/boost/lib/index.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var database_manager_1 = require("@accounts/database-manager");
var graphql_api_1 = require("@accounts/graphql-api");
exports.AccountsModule = graphql_api_1.AccountsModule;
exports.authenticated = graphql_api_1.authenticated;
var server_1 = require("@accounts/server");
var apollo_server_1 = require("apollo-server");
var jsonwebtoken_1 = require("jsonwebtoken");
var lodash_1 = require("lodash");
var defaultAccountsBoostOptions = {
    storage: {
        uri: 'mongodb://localhost:27017',
        name: 'accounts-js',
    },
};
var requirePackage = function (packageName) {
    if (require.resolve(packageName)) {
        return require(packageName);
    }
};
exports.accountsBoost = function (userOptions) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
    var options, databasePackages, storage, servicePackages, services;
    var _a, _b;
    return tslib_1.__generator(this, function (_c) {
        switch (_c.label) {
            case 0:
                options = lodash_1.merge({}, defaultAccountsBoostOptions, userOptions);
                databasePackages = (_a = {},
                    _a['@accounts/mongo'] = function (requiredPackage) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
                        var mongodb, mongoClient;
                        return tslib_1.__generator(this, function (_a) {
                            switch (_a.label) {
                                case 0:
                                    mongodb = require('mongodb');
                                    return [4 /*yield*/, mongodb.MongoClient.connect(lodash_1.get(options, 'storage.uri'))];
                                case 1:
                                    mongoClient = (_a.sent()).db(lodash_1.get(options, 'storage.name'));
                                    return [2 /*return*/, new requiredPackage.Mongo(mongoClient, options)];
                            }
                        });
                    }); },
                    _a);
                return [4 /*yield*/, Object.keys(databasePackages).reduce(function (res, packageName) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
                        var requiredPackage;
                        return tslib_1.__generator(this, function (_a) {
                            requiredPackage = requirePackage(packageName);
                            if (requiredPackage) {
                                return [2 /*return*/, databasePackages[packageName](requiredPackage)];
                            }
                            return [2 /*return*/, res];
                        });
                    }); }, Promise.resolve([]))];
            case 1:
                storage = _c.sent();
                if (!storage) {
                    throw new Error('A database package could not be loaded. Did you install one?');
                }
                options.db = new database_manager_1.DatabaseManager({
                    userStorage: storage,
                    sessionStorage: storage,
                });
                servicePackages = (_b = {},
                    _b['@accounts/password'] = function (requiredPackage) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
                        var AccountsPassword;
                        return tslib_1.__generator(this, function (_a) {
                            AccountsPassword = requiredPackage.default;
                            return [2 /*return*/, new AccountsPassword(lodash_1.get(options, ['services', 'password']))];
                        });
                    }); },
                    _b);
                return [4 /*yield*/, Object.keys(servicePackages).reduce(function (res, packageName) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
                        var requiredPackage, service;
                        var _a;
                        return tslib_1.__generator(this, function (_b) {
                            switch (_b.label) {
                                case 0:
                                    requiredPackage = requirePackage(packageName);
                                    if (!requiredPackage) return [3 /*break*/, 2];
                                    return [4 /*yield*/, servicePackages[packageName](requiredPackage)];
                                case 1:
                                    service = _b.sent();
                                    return [2 /*return*/, tslib_1.__assign(tslib_1.__assign({}, res), (_a = {}, _a[service.serviceName] = service, _a))];
                                case 2: return [2 /*return*/, res];
                            }
                        });
                    }); }, Promise.resolve({}))];
            case 2:
                services = _c.sent();
                // eslint-disable-next-line
                return [2 /*return*/, new AccountsBoost(options, services)];
        }
    });
}); };
var defaultAccountsBoostListenOptions = {
    port: 4003,
};
var AccountsBoost = /** @class */ (function () {
    function AccountsBoost(options, services) {
        this.accountsServer = new server_1.AccountsServer(options, services);
        this.options = options;
        this.accountsGraphQL = graphql_api_1.AccountsModule.forRoot({
            accountsServer: this.accountsServer,
        });
        var _a = this.accountsGraphQL, schema = _a.schema, context = _a.context;
        this.apolloServer = new apollo_server_1.ApolloServer({
            schema: schema,
            context: context,
        });
    }
    AccountsBoost.prototype.listen = function (options) {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var res;
            return tslib_1.__generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.apolloServer.listen(lodash_1.merge({}, defaultAccountsBoostListenOptions, options))];
                    case 1:
                        res = _a.sent();
                        console.log("Accounts GraphQL server running at " + res.url);
                        return [2 /*return*/, res];
                }
            });
        });
    };
    AccountsBoost.prototype.graphql = function () {
        var _this = this;
        // Cache `this.accountsGraphQL` to avoid regenerating the schema if the user calls `accountsBoost.graphql()` multple times.
        if (this.accountsGraphQL) {
            return this.accountsGraphQL;
        }
        if (this.options.micro) {
            this.accountsServer.resumeSession = function (accessToken) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                var decoded, secretOrPublicKey;
                return tslib_1.__generator(this, function (_a) {
                    if (!lodash_1.isString(accessToken)) {
                        throw new Error('An access token is required');
                    }
                    try {
                        secretOrPublicKey = typeof this.options.tokenSecret === 'string'
                            ? this.options.tokenSecret
                            : this.options.tokenSecret.publicKey;
                        decoded = jsonwebtoken_1.verify(accessToken, secretOrPublicKey);
                    }
                    catch (err) {
                        throw new Error('Access token is not valid');
                    }
                    return [2 /*return*/, {
                            id: decoded.data.userId,
                        }];
                });
            }); };
        }
        return this.accountsGraphQL;
    };
    return AccountsBoost;
}());
exports.AccountsBoost = AccountsBoost;
exports.default = exports.accountsBoost;
//# sourceMappingURL=index.js.map