@lomray/microservice-users/services/identity-provider/abstract.js

Users microservice based on NodeJS & inverted json.

'use strict';

var tslib = require('tslib');
var microserviceNodejsLib = require('@lomray/microservice-nodejs-lib');
var classValidator = require('class-validator');
var identityProvider = require('../../entities/identity-provider.js');
var profile = require('../../entities/profile.js');
var user = require('../../repositories/user.js');

/**
 * Abstract class for identity providers
 */
class Abstract {
    /**
     * @constructor
     */
    constructor(provider, token, manager) {
        /**
         * Is should attach user photo
         */
        this.isShouldAttachUserPhoto = true;
        /**
         * Is approve provider (prevent overriding for account)
         */
        this.isShouldApproveProvider = false;
        this.provider = provider;
        this.token = token;
        this.userRepository = manager.getCustomRepository(user);
        this.providerRepository = manager.getRepository(identityProvider);
        this.profileRepository = manager.getRepository(profile);
        this.manager = manager;
    }
    /**
     * Validate entities
     * @private
     */
    validateEntities(entitiesObj) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            const entities = entitiesObj.filter(Boolean);
            const errors = yield Promise.all(entities.map((entity) => {
                var _a;
                return classValidator.validate(entity, {
                    whitelist: true,
                    forbidNonWhitelisted: true,
                    groups: ['create', 'sign-in-social', (_a = entity === null || entity === void 0 ? void 0 : entity.constructor) === null || _a === void 0 ? void 0 : _a.name],
                    always: true,
                    validationError: { target: false },
                });
            }));
            if (errors.some((entityErrors) => entityErrors.length > 0)) {
                throw new microserviceNodejsLib.BaseException({
                    status: 422,
                    message: 'Validation failed.',
                    payload: errors,
                });
            }
        });
    }
    /**
     * Create user and add related identity provider, update user profile
     * @protected
     */
    createUser(entityUser, entityIdentityProvider, entityProfile) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            yield this.validateEntities([entityUser, entityIdentityProvider, entityProfile]);
            return this.manager.transaction((transactionManager) => tslib.__awaiter(this, void 0, void 0, function* () {
                const user$1 = yield transactionManager.getCustomRepository(user).save(entityUser);
                const profileRepository = transactionManager.getRepository(profile);
                entityIdentityProvider.userId = user$1.id;
                let profile$1 = (yield profileRepository.findOne({ userId: user$1.id }));
                if (entityProfile) {
                    profile$1 = profileRepository.merge(profile$1, entityProfile);
                }
                yield Promise.all([
                    transactionManager.getRepository(identityProvider).save(entityIdentityProvider),
                    entityProfile ? profileRepository.save(profile$1) : Promise.resolve(null),
                ]);
                // add profile to response
                user$1.profile = profile$1;
                return user$1;
            }));
        });
    }
    /**
     * Add new identity provider to existing user and update: profile, user
     * @protected
     */
    assign(entityIdentityProvider, user$1, profile$1) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            yield this.validateEntities([entityIdentityProvider, user$1, profile$1]);
            return this.manager.transaction((transactionManager) => tslib.__awaiter(this, void 0, void 0, function* () {
                entityIdentityProvider.userId = user$1.id;
                const [updatedUser] = yield Promise.all([
                    transactionManager.getCustomRepository(user).save(user$1),
                    transactionManager.getRepository(identityProvider).save(entityIdentityProvider),
                    profile$1 ? transactionManager.getRepository(profile).save(profile$1) : Promise.resolve(null),
                ]);
                return updatedUser;
            }));
        });
    }
}

module.exports = Abstract;