@spytecgps/nova-orm 1.2.23 → 1.2.25

package/dist/repositories/security/getUserRolesByClientId.js

@@ -1,26 +1,26 @@
-import { UserSecurityRole } from '../../entities';
-export const getUserRolesByClientId = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.clientId) {
-        logger.warn({ params }, 'SecurityRepository::getUserRolesByClientId - missing required parameters');
-        return [];
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
-        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
-        const queryBuilder = userSecurityRolesRepository
-            .createQueryBuilder()
-            .where('clientId = :clientId', { clientId: params.filters.clientId });
-        if (params.filters.role) {
-            queryBuilder.andWhere('securityRoleId = :securityRoleId', {
-                securityRoleId: params.filters.role,
-            });
-        }
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        const userRoles = await queryBuilder.getMany();
-        return userRoles;
-    }, 'SecurityRepository::getUserRolesByClientId', dbQueryRunner);
-};
+import { UserSecurityRole } from '../../entities';
+export const getUserRolesByClientId = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId) {
+        logger.warn({ params }, 'SecurityRepository::getUserRolesByClientId - missing required parameters');
+        return [];
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const queryBuilder = userSecurityRolesRepository
+            .createQueryBuilder()
+            .where('clientId = :clientId', { clientId: params.filters.clientId });
+        if (params.filters.role) {
+            queryBuilder.andWhere('securityRoleId = :securityRoleId', {
+                securityRoleId: params.filters.role,
+            });
+        }
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        const userRoles = await queryBuilder.getMany();
+        return userRoles;
+    }, 'SecurityRepository::getUserRolesByClientId', dbQueryRunner);
+};
 //# sourceMappingURL=getUserRolesByClientId.js.map

package/dist/repositories/security/index.d.ts

@@ -1,56 +1,56 @@
-import { SecurityRole, UserSecurityRole } from '../../entities';
-import { CreateUserRoleParams, GetUserRolesByClientIdParams, GetUserRolesParams, RemoveUserRolesParams, UpdateUserRoleParams, UserIsAdminOrOwnerParams, UserIsInRoleParams } from '../../types/security';
-import { BaseRepository } from '../baseRepository';
-export declare class SecurityRepository extends BaseRepository {
-    /**
-     * Get all security roles
-     */
-    getAllRoles(forceUseReplica?: boolean): Promise<SecurityRole[]>;
-    /**
-     * Get roles of the user
-     * @param  {GetUserRolesParams} params containing information to get roles of the user
-     * - filters.userId: The user id
-     */
-    getUserRoles(params: GetUserRolesParams): Promise<UserSecurityRole[]>;
-    /**
-     * Get user roles by clientId
-     * @param  {GetUserRolesByClientIdParams} params containing information to get user roles by clientId
-     * - filters.clientId: The client id
-     * - filters.role: The role to only obtain user roles with that role, optional
-     */
-    getUserRolesByClientId(params: GetUserRolesByClientIdParams): Promise<UserSecurityRole[]>;
-    /**
-     * Whether the user is in role
-     * @param  {UserIsInRoleParams} params containing information to know if the user is in role
-     * - filters.userId: The user id
-     * - filters.role: The role to check if the user is in that role
-     */
-    userIsInRole(params: UserIsInRoleParams): Promise<boolean>;
-    /**
-     * Whether the user is admin or owner
-     * @param  {UserIsAdminOrOwnerParams} params containing information to know if the user is admin or owner
-     * - filters.userId: The user id
-     */
-    userIsAdminOrOwner(params: UserIsAdminOrOwnerParams): Promise<boolean>;
-    /**
-     * Create user role
-     * @param  {CreateUserRoleParams} params containing information to create user role
-     * - userId: The user id
-     * - clientId: The client id
-     * - roleId: The role to assign to the user
-     */
-    createUserRole(params: CreateUserRoleParams): Promise<UserSecurityRole>;
-    /**
-     * Update user role
-     * @param  {UpdateUserRoleParams} params containing information to update user role
-     * - filters.userId: The user id to update role
-     * - values.roleId: The role to assign to the user
-     */
-    updateUserRole(params: UpdateUserRoleParams): Promise<boolean>;
-    /**
-     * Remove user roles
-     * @param  {RemoveUserRolesParams} params containing information to remove user roles
-     * - filters.userId: The user id to remove roles from
-     */
-    removeUserRoles(params: RemoveUserRolesParams): Promise<boolean>;
-}
+import { SecurityRole, UserSecurityRole } from '../../entities';
+import { CreateUserRoleParams, GetUserRolesByClientIdParams, GetUserRolesParams, RemoveUserRolesParams, UpdateUserRoleParams, UserIsAdminOrOwnerParams, UserIsInRoleParams } from '../../types/security';
+import { BaseRepository } from '../baseRepository';
+export declare class SecurityRepository extends BaseRepository {
+    /**
+     * Get all security roles
+     */
+    getAllRoles(forceUseReplica?: boolean): Promise<SecurityRole[]>;
+    /**
+     * Get roles of the user
+     * @param  {GetUserRolesParams} params containing information to get roles of the user
+     * - filters.userId: The user id
+     */
+    getUserRoles(params: GetUserRolesParams): Promise<UserSecurityRole[]>;
+    /**
+     * Get user roles by clientId
+     * @param  {GetUserRolesByClientIdParams} params containing information to get user roles by clientId
+     * - filters.clientId: The client id
+     * - filters.role: The role to only obtain user roles with that role, optional
+     */
+    getUserRolesByClientId(params: GetUserRolesByClientIdParams): Promise<UserSecurityRole[]>;
+    /**
+     * Whether the user is in role
+     * @param  {UserIsInRoleParams} params containing information to know if the user is in role
+     * - filters.userId: The user id
+     * - filters.role: The role to check if the user is in that role
+     */
+    userIsInRole(params: UserIsInRoleParams): Promise<boolean>;
+    /**
+     * Whether the user is admin or owner
+     * @param  {UserIsAdminOrOwnerParams} params containing information to know if the user is admin or owner
+     * - filters.userId: The user id
+     */
+    userIsAdminOrOwner(params: UserIsAdminOrOwnerParams): Promise<boolean>;
+    /**
+     * Create user role
+     * @param  {CreateUserRoleParams} params containing information to create user role
+     * - userId: The user id
+     * - clientId: The client id
+     * - roleId: The role to assign to the user
+     */
+    createUserRole(params: CreateUserRoleParams): Promise<UserSecurityRole>;
+    /**
+     * Update user role
+     * @param  {UpdateUserRoleParams} params containing information to update user role
+     * - filters.userId: The user id to update role
+     * - values.roleId: The role to assign to the user
+     */
+    updateUserRole(params: UpdateUserRoleParams): Promise<boolean>;
+    /**
+     * Remove user roles
+     * @param  {RemoveUserRolesParams} params containing information to remove user roles
+     * - filters.userId: The user id to remove roles from
+     */
+    removeUserRoles(params: RemoveUserRolesParams): Promise<boolean>;
+}

package/dist/repositories/security/index.js

@@ -1,112 +1,112 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { BaseRepository } from '../baseRepository';
-import { createUserRole } from './createUserRole';
-import { getAllRoles } from './getAllRoles';
-import { getUserRoles } from './getUserRoles';
-import { getUserRolesByClientId } from './getUserRolesByClientId';
-import { removeUserRoles } from './removeUserRoles';
-import { updateUserRole } from './updateUserRole';
-import { userIsAdminOrOwner } from './userIsAdminOrOwner';
-import { userIsInRole } from './userIsInRole';
-export class SecurityRepository extends BaseRepository {
-    /**
-     * Get all security roles
-     */
-    async getAllRoles(forceUseReplica) {
-        this.logger.trace('SecurityRepository::getAllRoles started');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await getAllRoles(novaDataSource, forceUseReplica);
-        this.logger.trace(result, 'SecurityRepository::getAllRoles result');
-        return result;
-    }
-    /**
-     * Get roles of the user
-     * @param  {GetUserRolesParams} params containing information to get roles of the user
-     * - filters.userId: The user id
-     */
-    async getUserRoles(params) {
-        this.logger.trace(params, 'SecurityRepository::getUserRoles started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await getUserRoles(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'SecurityRepository::getUserRoles result');
-        return result;
-    }
-    /**
-     * Get user roles by clientId
-     * @param  {GetUserRolesByClientIdParams} params containing information to get user roles by clientId
-     * - filters.clientId: The client id
-     * - filters.role: The role to only obtain user roles with that role, optional
-     */
-    async getUserRolesByClientId(params) {
-        this.logger.trace(params, 'SecurityRepository::getUserRolesByClientId started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await getUserRolesByClientId(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'SecurityRepository::getUserRolesByClientId result');
-        return result;
-    }
-    /**
-     * Whether the user is in role
-     * @param  {UserIsInRoleParams} params containing information to know if the user is in role
-     * - filters.userId: The user id
-     * - filters.role: The role to check if the user is in that role
-     */
-    async userIsInRole(params) {
-        this.logger.trace(params, 'SecurityRepository::userIsInRole started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await userIsInRole(novaDataSource, params, this.logger);
-        this.logger.trace({ result }, 'SecurityRepository::userIsInRole result');
-        return result;
-    }
-    /**
-     * Whether the user is admin or owner
-     * @param  {UserIsAdminOrOwnerParams} params containing information to know if the user is admin or owner
-     * - filters.userId: The user id
-     */
-    async userIsAdminOrOwner(params) {
-        this.logger.trace(params, 'SecurityRepository::userIsAdminOrOwner started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await userIsAdminOrOwner(novaDataSource, params, this.logger);
-        this.logger.trace({ result }, 'SecurityRepository::userIsAdminOrOwner result');
-        return result;
-    }
-    /**
-     * Create user role
-     * @param  {CreateUserRoleParams} params containing information to create user role
-     * - userId: The user id
-     * - clientId: The client id
-     * - roleId: The role to assign to the user
-     */
-    async createUserRole(params) {
-        this.logger.trace(params, 'SecurityRepository::createUserRole started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await createUserRole(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'SecurityRepository::createUserRole result');
-        return result;
-    }
-    /**
-     * Update user role
-     * @param  {UpdateUserRoleParams} params containing information to update user role
-     * - filters.userId: The user id to update role
-     * - values.roleId: The role to assign to the user
-     */
-    async updateUserRole(params) {
-        this.logger.trace(params, 'SecurityRepository::updateUserRole started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await updateUserRole(novaDataSource, params, this.logger);
-        this.logger.trace({ result }, 'SecurityRepository::updateUserRole result');
-        return result;
-    }
-    /**
-     * Remove user roles
-     * @param  {RemoveUserRolesParams} params containing information to remove user roles
-     * - filters.userId: The user id to remove roles from
-     */
-    async removeUserRoles(params) {
-        this.logger.trace(params, 'SecurityRepository::removeUserRoles started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await removeUserRoles(novaDataSource, params, this.logger);
-        this.logger.trace({ result }, 'SecurityRepository::removeUserRoles result');
-        return result;
-    }
-}
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createUserRole } from './createUserRole';
+import { getAllRoles } from './getAllRoles';
+import { getUserRoles } from './getUserRoles';
+import { getUserRolesByClientId } from './getUserRolesByClientId';
+import { removeUserRoles } from './removeUserRoles';
+import { updateUserRole } from './updateUserRole';
+import { userIsAdminOrOwner } from './userIsAdminOrOwner';
+import { userIsInRole } from './userIsInRole';
+export class SecurityRepository extends BaseRepository {
+    /**
+     * Get all security roles
+     */
+    async getAllRoles(forceUseReplica) {
+        this.logger.trace('SecurityRepository::getAllRoles started');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await getAllRoles(novaDataSource, forceUseReplica);
+        this.logger.trace(result, 'SecurityRepository::getAllRoles result');
+        return result;
+    }
+    /**
+     * Get roles of the user
+     * @param  {GetUserRolesParams} params containing information to get roles of the user
+     * - filters.userId: The user id
+     */
+    async getUserRoles(params) {
+        this.logger.trace(params, 'SecurityRepository::getUserRoles started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await getUserRoles(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'SecurityRepository::getUserRoles result');
+        return result;
+    }
+    /**
+     * Get user roles by clientId
+     * @param  {GetUserRolesByClientIdParams} params containing information to get user roles by clientId
+     * - filters.clientId: The client id
+     * - filters.role: The role to only obtain user roles with that role, optional
+     */
+    async getUserRolesByClientId(params) {
+        this.logger.trace(params, 'SecurityRepository::getUserRolesByClientId started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await getUserRolesByClientId(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'SecurityRepository::getUserRolesByClientId result');
+        return result;
+    }
+    /**
+     * Whether the user is in role
+     * @param  {UserIsInRoleParams} params containing information to know if the user is in role
+     * - filters.userId: The user id
+     * - filters.role: The role to check if the user is in that role
+     */
+    async userIsInRole(params) {
+        this.logger.trace(params, 'SecurityRepository::userIsInRole started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await userIsInRole(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'SecurityRepository::userIsInRole result');
+        return result;
+    }
+    /**
+     * Whether the user is admin or owner
+     * @param  {UserIsAdminOrOwnerParams} params containing information to know if the user is admin or owner
+     * - filters.userId: The user id
+     */
+    async userIsAdminOrOwner(params) {
+        this.logger.trace(params, 'SecurityRepository::userIsAdminOrOwner started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await userIsAdminOrOwner(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'SecurityRepository::userIsAdminOrOwner result');
+        return result;
+    }
+    /**
+     * Create user role
+     * @param  {CreateUserRoleParams} params containing information to create user role
+     * - userId: The user id
+     * - clientId: The client id
+     * - roleId: The role to assign to the user
+     */
+    async createUserRole(params) {
+        this.logger.trace(params, 'SecurityRepository::createUserRole started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await createUserRole(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'SecurityRepository::createUserRole result');
+        return result;
+    }
+    /**
+     * Update user role
+     * @param  {UpdateUserRoleParams} params containing information to update user role
+     * - filters.userId: The user id to update role
+     * - values.roleId: The role to assign to the user
+     */
+    async updateUserRole(params) {
+        this.logger.trace(params, 'SecurityRepository::updateUserRole started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await updateUserRole(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'SecurityRepository::updateUserRole result');
+        return result;
+    }
+    /**
+     * Remove user roles
+     * @param  {RemoveUserRolesParams} params containing information to remove user roles
+     * - filters.userId: The user id to remove roles from
+     */
+    async removeUserRoles(params) {
+        this.logger.trace(params, 'SecurityRepository::removeUserRoles started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await removeUserRoles(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'SecurityRepository::removeUserRoles result');
+        return result;
+    }
+}
 //# sourceMappingURL=index.js.map

package/dist/repositories/security/removeUserRoles.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { Logger } from '../../types/logger';
-import { RemoveUserRolesParams } from '../../types/security';
-export declare const removeUserRoles: (novaDataSource: NovaDataSource, params: RemoveUserRolesParams, logger: Logger) => Promise<boolean>;
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { RemoveUserRolesParams } from '../../types/security';
+export declare const removeUserRoles: (novaDataSource: NovaDataSource, params: RemoveUserRolesParams, logger: Logger) => Promise<boolean>;

package/dist/repositories/security/removeUserRoles.js

@@ -1,22 +1,22 @@
-import { UserSecurityRole } from '../../entities';
-import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
-export const removeUserRoles = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.userId) {
-        logger.warn({ params }, 'SecurityRepository::removeUserRoles - missing required parameters');
-        return false;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
-        const userRoles = await userSecurityRolesRepository.find({
-            where: {
-                userId: uuidStringToBinaryBuffer(params.filters.userId),
-            },
-        });
-        if (!userRoles.length) {
-            return true; // nothing to remove
-        }
-        await userSecurityRolesRepository.remove(userRoles);
-        return true;
-    }, 'SecurityRepository::removeUserRoles');
-};
+import { UserSecurityRole } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const removeUserRoles = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'SecurityRepository::removeUserRoles - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const userRoles = await userSecurityRolesRepository.find({
+            where: {
+                userId: uuidStringToBinaryBuffer(params.filters.userId),
+            },
+        });
+        if (!userRoles.length) {
+            return true; // nothing to remove
+        }
+        await userSecurityRolesRepository.remove(userRoles);
+        return true;
+    }, 'SecurityRepository::removeUserRoles');
+};
 //# sourceMappingURL=removeUserRoles.js.map

package/dist/repositories/security/updateUserRole.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { Logger } from '../../types/logger';
-import { UpdateUserRoleParams } from '../../types/security';
-export declare const updateUserRole: (novaDataSource: NovaDataSource, params: UpdateUserRoleParams, logger: Logger) => Promise<boolean>;
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { UpdateUserRoleParams } from '../../types/security';
+export declare const updateUserRole: (novaDataSource: NovaDataSource, params: UpdateUserRoleParams, logger: Logger) => Promise<boolean>;

package/dist/repositories/security/updateUserRole.js

@@ -1,28 +1,28 @@
-import { UserSecurityRole } from '../../entities';
-import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
-export const updateUserRole = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.userId) {
-        logger.warn({ params }, 'SecurityRepository::updateUserRole - missing required parameters');
-        return false;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
-        const userId = uuidStringToBinaryBuffer(params.filters.userId);
-        const userRole = await userSecurityRolesRepository.findOne({
-            where: {
-                userId,
-            },
-        });
-        if (!userRole) {
-            return false;
-        }
-        if (userRole.securityRoleId === params.values.roleId) {
-            return true; // nothing to update
-        }
-        const oldRoleId = userRole.securityRoleId;
-        userRole.securityRoleId = params.values.roleId;
-        const result = await userSecurityRolesRepository.update({ userId, securityRoleId: oldRoleId }, userRole);
-        return result.affected > 0;
-    }, 'SecurityRepository::updateUserRole');
-};
+import { UserSecurityRole } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateUserRole = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'SecurityRepository::updateUserRole - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const userId = uuidStringToBinaryBuffer(params.filters.userId);
+        const userRole = await userSecurityRolesRepository.findOne({
+            where: {
+                userId,
+            },
+        });
+        if (!userRole) {
+            return false;
+        }
+        if (userRole.securityRoleId === params.values.roleId) {
+            return true; // nothing to update
+        }
+        const oldRoleId = userRole.securityRoleId;
+        userRole.securityRoleId = params.values.roleId;
+        const result = await userSecurityRolesRepository.update({ userId, securityRoleId: oldRoleId }, userRole);
+        return result.affected > 0;
+    }, 'SecurityRepository::updateUserRole');
+};
 //# sourceMappingURL=updateUserRole.js.map

package/dist/repositories/security/userIsAdminOrOwner.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { Logger } from '../../types/logger';
-import { UserIsAdminOrOwnerParams } from '../../types/security';
-export declare const userIsAdminOrOwner: (novaDataSource: NovaDataSource, params: UserIsAdminOrOwnerParams, logger: Logger) => Promise<boolean>;
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { UserIsAdminOrOwnerParams } from '../../types/security';
+export declare const userIsAdminOrOwner: (novaDataSource: NovaDataSource, params: UserIsAdminOrOwnerParams, logger: Logger) => Promise<boolean>;

package/dist/repositories/security/userIsAdminOrOwner.js

@@ -1,26 +1,26 @@
-import { UserSecurityRole } from '../../entities';
-import { HapnSecurityRole } from '../../types/enums';
-import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
-export const userIsAdminOrOwner = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.userId) {
-        logger.warn({ params }, 'SecurityRepository::userIsAdminOrOwner - missing required parameters');
-        return false;
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
-        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
-        const queryBuilder = userSecurityRolesRepository.createQueryBuilder();
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        const userRole = await queryBuilder
-            .where('userId = :userId', { userId: uuidStringToBinaryBuffer(params.filters.userId) })
-            .andWhere('securityRoleId IN (:...roles)', {
-            roles: [HapnSecurityRole.Admin, HapnSecurityRole.Owner],
-        })
-            .getOne();
-        return userRole !== null;
-    }, 'SecurityRepository::userIsAdminOrOwner', dbQueryRunner);
-};
+import { UserSecurityRole } from '../../entities';
+import { HapnSecurityRole } from '../../types/enums';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const userIsAdminOrOwner = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'SecurityRepository::userIsAdminOrOwner - missing required parameters');
+        return false;
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const queryBuilder = userSecurityRolesRepository.createQueryBuilder();
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        const userRole = await queryBuilder
+            .where('userId = :userId', { userId: uuidStringToBinaryBuffer(params.filters.userId) })
+            .andWhere('securityRoleId IN (:...roles)', {
+            roles: [HapnSecurityRole.Admin, HapnSecurityRole.Owner],
+        })
+            .getOne();
+        return userRole !== null;
+    }, 'SecurityRepository::userIsAdminOrOwner', dbQueryRunner);
+};
 //# sourceMappingURL=userIsAdminOrOwner.js.map

package/dist/repositories/security/userIsInRole.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { Logger } from '../../types/logger';
-import { UserIsInRoleParams } from '../../types/security';
-export declare const userIsInRole: (novaDataSource: NovaDataSource, params: UserIsInRoleParams, logger: Logger) => Promise<boolean>;
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { UserIsInRoleParams } from '../../types/security';
+export declare const userIsInRole: (novaDataSource: NovaDataSource, params: UserIsInRoleParams, logger: Logger) => Promise<boolean>;

package/dist/repositories/security/userIsInRole.js

@@ -1,23 +1,23 @@
-import { UserSecurityRole } from '../../entities';
-import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
-export const userIsInRole = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.userId) {
-        logger.warn({ params }, 'SecurityRepository::userIsInRole - missing required parameters');
-        return false;
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
-        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
-        const queryBuilder = userSecurityRolesRepository.createQueryBuilder();
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        const userRole = await queryBuilder
-            .where('userId = :userId', { userId: uuidStringToBinaryBuffer(params.filters.userId) })
-            .andWhere('securityRoleId = :securityRoleId', { securityRoleId: params.filters.role })
-            .getOne();
-        return userRole !== null;
-    }, 'SecurityRepository::userIsInRole', dbQueryRunner);
-};
+import { UserSecurityRole } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const userIsInRole = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'SecurityRepository::userIsInRole - missing required parameters');
+        return false;
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+        const userSecurityRolesRepository = dataSource.getRepository(UserSecurityRole);
+        const queryBuilder = userSecurityRolesRepository.createQueryBuilder();
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        const userRole = await queryBuilder
+            .where('userId = :userId', { userId: uuidStringToBinaryBuffer(params.filters.userId) })
+            .andWhere('securityRoleId = :securityRoleId', { securityRoleId: params.filters.role })
+            .getOne();
+        return userRole !== null;
+    }, 'SecurityRepository::userIsInRole', dbQueryRunner);
+};
 //# sourceMappingURL=userIsInRole.js.map