@volcanicminds/typeorm 2.0.1 → 2.1.0

package/dist/lib/loader/userManager.js

@@ -1,337 +1,255 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    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) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImplemented = isImplemented;
-exports.isValidUser = isValidUser;
-exports.createUser = createUser;
-exports.deleteUser = deleteUser;
-exports.resetExternalId = resetExternalId;
-exports.updateUserById = updateUserById;
-exports.retrieveUserById = retrieveUserById;
-exports.retrieveUserByEmail = retrieveUserByEmail;
-exports.retrieveUserByUsername = retrieveUserByUsername;
-exports.retrieveUserByConfirmationToken = retrieveUserByConfirmationToken;
-exports.retrieveUserByResetPasswordToken = retrieveUserByResetPasswordToken;
-exports.retrieveUserByExternalId = retrieveUserByExternalId;
-exports.retrieveUserByPassword = retrieveUserByPassword;
-exports.changePassword = changePassword;
-exports.forgotPassword = forgotPassword;
-exports.resetPassword = resetPassword;
-exports.userConfirmation = userConfirmation;
-exports.blockUserById = blockUserById;
-exports.unblockUserById = unblockUserById;
-exports.isPasswordToBeChanged = isPasswordToBeChanged;
-exports.countQuery = countQuery;
-exports.findQuery = findQuery;
-exports.disableUserById = disableUserById;
-const bcrypt = __importStar(require("bcrypt"));
-const Crypto = require('crypto');
-const query_1 = require("../query");
-function isImplemented() {
+import * as bcrypt from 'bcrypt';
+import * as Crypto from 'crypto';
+import { executeCountQuery, executeFindQuery } from '../query.js';
+export function isImplemented() {
     return true;
 }
-function isValidUser(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return !!data && (!!data._id || !!data.id) && !!data.externalId && !!data.email && !!data.password;
-    });
+export async function isValidUser(data) {
+    return !!data && (!!data._id || !!data.id) && !!data.externalId && !!data.email && !!data.password;
 }
-function createUser(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { username, email, password } = data;
-        if (!email || !password) {
-            throw new Error('Email or password missing');
-        }
-        const salt = yield bcrypt.genSalt(12);
-        const hashedPassword = yield bcrypt.hash(password, salt);
-        try {
-            let externalId, user;
-            do {
-                externalId = Crypto.randomUUID({ disableEntropyCache: true });
-                user = yield global.repository.users.findOneBy({ externalId: externalId });
-            } while (user != null);
-            user = yield global.entity.User.create(Object.assign(Object.assign({}, data), { passwordChangedAt: new Date(), confirmed: false, confirmationToken: Crypto.randomBytes(64).toString('hex'), blocked: false, blockedReason: null, externalId: externalId, email: email, username: username || email, password: hashedPassword }));
-            return yield global.entity.User.save(user);
-        }
-        catch (error) {
-            if ((error === null || error === void 0 ? void 0 : error.code) == 23505) {
-                throw new Error('Email or username already registered');
-            }
-            throw error;
+export async function createUser(data) {
+    const { username, email, password } = data;
+    if (!email || !password) {
+        throw new Error('Email or password missing');
+    }
+    const salt = await bcrypt.genSalt(12);
+    const hashedPassword = await bcrypt.hash(password, salt);
+    try {
+        let externalId, user;
+        do {
+            externalId = Crypto.randomUUID({ disableEntropyCache: true });
+            user = await global.repository.users.findOneBy({ externalId: externalId });
+        } while (user != null);
+        user = await global.entity.User.create({
+            ...data,
+            passwordChangedAt: new Date(),
+            confirmed: false,
+            confirmationToken: Crypto.randomBytes(64).toString('hex'),
+            blocked: false,
+            blockedReason: null,
+            externalId: externalId,
+            email: email,
+            username: username || email,
+            password: hashedPassword
+        });
+        return await global.entity.User.save(user);
+    }
+    catch (error) {
+        if (error?.code == 23505) {
+            throw new Error('Email or username already registered');
         }
-    });
+        throw error;
+    }
 }
-function deleteUser(id) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!id) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            const userEx = yield retrieveUserById(id);
-            if (!userEx) {
-                throw new Error('User not found');
-            }
-            return global.entity.User.delete(id);
-        }
-        catch (error) {
-            throw error;
+export async function deleteUser(id) {
+    if (!id) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        const userEx = await retrieveUserById(id);
+        if (!userEx) {
+            throw new Error('User not found');
         }
-    });
+        return global.entity.User.delete(id);
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function resetExternalId(id) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!id) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            let externalId, user;
-            do {
-                externalId = Crypto.randomUUID({ disableEntropyCache: true });
-                user = yield global.repository.users.findOneBy({ externalId: externalId });
-            } while (user != null);
-            return yield updateUserById(id, { externalId: externalId });
-        }
-        catch (error) {
-            if ((error === null || error === void 0 ? void 0 : error.code) == 23505) {
-                throw new Error('External ID not changed');
-            }
-            throw error;
+export async function resetExternalId(id) {
+    if (!id) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        let externalId, user;
+        do {
+            externalId = Crypto.randomUUID({ disableEntropyCache: true });
+            user = await global.repository.users.findOneBy({ externalId: externalId });
+        } while (user != null);
+        return await updateUserById(id, { externalId: externalId });
+    }
+    catch (error) {
+        if (error?.code == 23505) {
+            throw new Error('External ID not changed');
         }
-    });
+        throw error;
+    }
 }
-function updateUserById(id, user) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!id || !user) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            const userEx = yield retrieveUserById(id);
-            if (!userEx) {
-                throw new Error('User not found');
-            }
-            const merged = global.repository.users.merge(userEx, user);
-            return yield global.entity.User.save(merged);
-        }
-        catch (error) {
-            throw error;
+export async function updateUserById(id, user) {
+    if (!id || !user) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        const userEx = await retrieveUserById(id);
+        if (!userEx) {
+            throw new Error('User not found');
         }
-    });
+        const merged = global.repository.users.merge(userEx, user);
+        return await global.entity.User.save(merged);
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function retrieveUserById(id) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!id) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            return yield global.repository.users.findOneById(id);
-        }
-        catch (error) {
-            throw error;
-        }
-    });
+export async function retrieveUserById(id) {
+    if (!id) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        return await global.repository.users.findOneById(id);
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function retrieveUserByEmail(email) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!email) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            return yield global.repository.users.findOneBy({ email: email });
-        }
-        catch (error) {
-            throw error;
-        }
-    });
+export async function retrieveUserByEmail(email) {
+    if (!email) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        return await global.repository.users.findOneBy({ email: email });
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function retrieveUserByUsername(username) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!username) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            return yield global.repository.users.findOneBy({ username });
-        }
-        catch (error) {
-            throw error;
-        }
-    });
+export async function retrieveUserByUsername(username) {
+    if (!username) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        return await global.repository.users.findOneBy({ username });
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function retrieveUserByConfirmationToken(code) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!code) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            return yield global.repository.users.findOneBy({ confirmationToken: code });
-        }
-        catch (error) {
-            throw error;
-        }
-    });
+export async function retrieveUserByConfirmationToken(code) {
+    if (!code) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        return await global.repository.users.findOneBy({ confirmationToken: code });
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function retrieveUserByResetPasswordToken(code) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!code) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            return yield global.repository.users.findOneBy({ resetPasswordToken: code });
-        }
-        catch (error) {
-            throw error;
-        }
-    });
+export async function retrieveUserByResetPasswordToken(code) {
+    if (!code) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        return await global.repository.users.findOneBy({ resetPasswordToken: code });
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function retrieveUserByExternalId(externalId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!externalId) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            return yield global.repository.users.findOne({
-                where: { externalId: externalId },
-                cache: global.cacheTimeout
-            });
-        }
-        catch (error) {
-            throw error;
-        }
-    });
+export async function retrieveUserByExternalId(externalId) {
+    if (!externalId) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        return await global.repository.users.findOne({
+            where: { externalId: externalId },
+            cache: global.cacheTimeout
+        });
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function retrieveUserByPassword(email, password) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!email || !password) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            const user = yield global.repository.users.findOneBy({ email: email });
-            if (!user) {
-                throw new Error('User not found');
-            }
-            const match = yield bcrypt.compare(password, user.password);
-            return match ? user : null;
-        }
-        catch (error) {
-            throw error;
+export async function retrieveUserByPassword(email, password) {
+    if (!email || !password) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        const user = await global.repository.users.findOneBy({ email: email });
+        if (!user) {
+            throw new Error('User not found');
         }
-    });
+        const match = await bcrypt.compare(password, user.password);
+        return match ? user : null;
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function changePassword(email, password, oldPassword) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!email || !password || !oldPassword) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            const user = yield global.repository.users.findOneBy({ email: email });
-            const match = yield bcrypt.compare(oldPassword, user.password);
-            if (match) {
-                const salt = yield bcrypt.genSalt(12);
-                const hashedPassword = yield bcrypt.hash(password, salt);
-                return yield global.entity.User.save(Object.assign(Object.assign({}, user), { passwordChangedAt: new Date(), password: hashedPassword }));
-            }
-            return null;
-        }
-        catch (error) {
-            throw error;
-        }
-    });
+export async function changePassword(email, password, oldPassword) {
+    if (!email || !password || !oldPassword) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        const user = await global.repository.users.findOneBy({ email: email });
+        const match = await bcrypt.compare(oldPassword, user.password);
+        if (match) {
+            const salt = await bcrypt.genSalt(12);
+            const hashedPassword = await bcrypt.hash(password, salt);
+            return await global.entity.User.save({ ...user, passwordChangedAt: new Date(), password: hashedPassword });
+        }
+        return null;
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function forgotPassword(email) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!email) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            const user = yield global.repository.users.findOneBy({ email: email });
-            if (user) {
-                return yield global.entity.User.save(Object.assign(Object.assign({}, user), { resetPasswordToken: Crypto.randomBytes(64).toString('hex') }));
-            }
-            return null;
-        }
-        catch (error) {
-            throw error;
+export async function forgotPassword(email) {
+    if (!email) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        const user = await global.repository.users.findOneBy({ email: email });
+        if (user) {
+            return await global.entity.User.save({
+                ...user,
+                resetPasswordToken: Crypto.randomBytes(64).toString('hex')
+            });
         }
-    });
+        return null;
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function resetPassword(user, password) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!user || !password) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            const salt = yield bcrypt.genSalt(12);
-            const hashedPassword = yield bcrypt.hash(password, salt);
-            return yield global.entity.User.save(Object.assign(Object.assign({}, user), { passwordChangedAt: new Date(), confirmed: true, confirmedAt: new Date(), resetPasswordToken: null, password: hashedPassword }));
-        }
-        catch (error) {
-            throw error;
-        }
-    });
+export async function resetPassword(user, password) {
+    if (!user || !password) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        const salt = await bcrypt.genSalt(12);
+        const hashedPassword = await bcrypt.hash(password, salt);
+        return await global.entity.User.save({
+            ...user,
+            passwordChangedAt: new Date(),
+            confirmed: true,
+            confirmedAt: new Date(),
+            resetPasswordToken: null,
+            password: hashedPassword
+        });
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function userConfirmation(user) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!user) {
-            throw new Error('Invalid parameters');
-        }
-        try {
-            return yield global.entity.User.save(Object.assign(Object.assign({}, user), { confirmed: true, confirmedAt: new Date(), confirmationToken: null }));
-        }
-        catch (error) {
-            throw error;
-        }
-    });
+export async function userConfirmation(user) {
+    if (!user) {
+        throw new Error('Invalid parameters');
+    }
+    try {
+        return await global.entity.User.save({ ...user, confirmed: true, confirmedAt: new Date(), confirmationToken: null });
+    }
+    catch (error) {
+        throw error;
+    }
 }
-function blockUserById(id, reason) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return updateUserById(id, { blocked: true, blockedAt: new Date(), blockedReason: reason });
-    });
+export async function blockUserById(id, reason) {
+    return updateUserById(id, { blocked: true, blockedAt: new Date(), blockedReason: reason });
 }
-function unblockUserById(id) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return updateUserById(id, { blocked: false, blockedAt: new Date(), blockedReason: null });
-    });
+export async function unblockUserById(id) {
+    return updateUserById(id, { blocked: false, blockedAt: new Date(), blockedReason: null });
 }
-function isPasswordToBeChanged(user) {
+export function isPasswordToBeChanged(user) {
     if (process.env.PASSWORD_EXPIRATION_DAYS != null) {
         let passwordExpirationDays = -1;
         try {
@@ -352,20 +270,14 @@ function isPasswordToBeChanged(user) {
     }
     return false;
 }
-function countQuery(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield (0, query_1.executeCountQuery)(global.repository.users, data);
-    });
+export async function countQuery(data) {
+    return await executeCountQuery(global.repository.users, data);
 }
-function findQuery(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield (0, query_1.executeFindQuery)(global.repository.users, {}, data);
-    });
+export async function findQuery(data) {
+    return await executeFindQuery(global.repository.users, {}, data);
 }
-function disableUserById(id) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield updateUserById(id, { blocked: true, blockedAt: new Date(), blockedReason: 'User disabled to unregister' });
-        return resetExternalId(id);
-    });
+export async function disableUserById(id) {
+    await updateUserById(id, { blocked: true, blockedAt: new Date(), blockedReason: 'User disabled to unregister' });
+    return resetExternalId(id);
 }
 //# sourceMappingURL=userManager.js.map