@spytecgps/nova-orm 1.2.29-rc3 → 1.2.29-rc5

package/dist/repositories/boundaries/getBoundariesReport.js

@@ -11,9 +11,7 @@ export const getBoundariesReport = async (novaDataSource, params, logger) => {
         logger.warn({ params }, 'BoundariesRepository::getBoundariesReport - user id should be a valid UUID');
         return null;
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const boundariesRepository = dataSource.getRepository(BoundaryEvent);
         const queryBuilder = boundariesRepository
             .createQueryBuilder('boundaryEvent')
@@ -21,9 +19,6 @@ export const getBoundariesReport = async (novaDataSource, params, logger) => {
             .innerJoin(Boundary, 'boundary', 'boundary.id = boundaryEvent.boundaryId')
             .where('boundaryEvent.userId = :userId', { userId: userIdBinaryBuffer })
             .andWhere('device.status = :deviceStatus', { deviceStatus: Enums.DeviceStatus.Active });
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
         if (params.filters.boundaryId) {
             queryBuilder.andWhere('boundaryEvent.boundaryId = :boundaryId', {
                 boundaryId: params.filters.boundaryId,
@@ -142,6 +137,5 @@ export const getBoundariesReport = async (novaDataSource, params, logger) => {
             inOutDuration: row.duration,
             totalCount: row.totalCount,
         }));
-    }, 'BoundariesRepository::getBoundariesReport', dbQueryRunner);
+    }, 'BoundariesRepository::getBoundariesReport');
 };
-//# sourceMappingURL=getBoundariesReport.js.map

package/dist/repositories/boundaries/getBoundaryById.js

@@ -4,20 +4,11 @@ export const getBoundaryById = async (novaDataSource, params, logger) => {
         logger.warn({ params }, 'BoundariesRepository::getBoundaryById - missing required parameters');
         return null;
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const boundariesRepository = dataSource.getRepository(Boundary);
-        const queryBuilder = boundariesRepository
-            .createQueryBuilder('boundary')
-            .where('boundary.id = :boundaryId', { boundaryId: params.filters.boundaryId });
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        const boundary = await queryBuilder
-            .where('id = :id', { id: params.filters.boundaryId })
-            .getOne();
+        const boundary = await boundariesRepository.findOne({
+            where: { id: params.filters.boundaryId },
+        });
         return boundary;
-    }, 'BoundariesRepository::getBoundaryById', dbQueryRunner);
+    }, 'BoundariesRepository::getBoundaryById');
 };
-//# sourceMappingURL=getBoundaryById.js.map

package/dist/repositories/boundaries/index.js

@@ -18,7 +18,7 @@ export class BoundariesRepository extends BaseRepository {
      */
     async getBoundariesByClientId(params) {
         this.logger.trace(params, 'BoundariesRepository::getBoundariesByClientId started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getBoundariesByClientId(novaDataSource, params, this.logger);
         this.logger.trace({ result: result.map(x => x.id) }, 'BoundariesRepository::getBoundariesByClientId result');
         return result;
@@ -31,7 +31,7 @@ export class BoundariesRepository extends BaseRepository {
      */
     async getBoundariesIdsByClientId(params) {
         this.logger.trace(params, 'BoundariesRepository::getBoundariesIdsByClientId started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getBoundariesIdsByClientId(novaDataSource, params, this.logger);
         this.logger.trace(result, 'BoundariesRepository::getBoundariesIdsByClientId result');
         return result;
@@ -43,7 +43,7 @@ export class BoundariesRepository extends BaseRepository {
      */
     async getBoundaryById(params) {
         this.logger.trace(params, 'BoundariesRepository::getBoundaryById started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getBoundaryById(novaDataSource, params, this.logger);
         this.logger.trace({
             result: {
@@ -72,7 +72,7 @@ export class BoundariesRepository extends BaseRepository {
      */
     async createBoundary(params) {
         this.logger.trace(params, 'BoundariesRepository::createBoundary started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await createBoundary(novaDataSource, params, this.logger);
         this.logger.trace({
             result: {
@@ -99,7 +99,7 @@ export class BoundariesRepository extends BaseRepository {
      */
     async updateBoundary(params) {
         this.logger.trace(params, 'BoundariesRepository::updateBoundary started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await updateBoundary(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'BoundariesRepository::updateBoundary result');
         return result;
@@ -113,7 +113,7 @@ export class BoundariesRepository extends BaseRepository {
      */
     async deleteBoundary(params) {
         this.logger.trace(params, 'BoundariesRepository::deleteBoundary started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await deleteBoundary(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'BoundariesRepository::deleteBoundary result');
         return result;
@@ -137,7 +137,7 @@ export class BoundariesRepository extends BaseRepository {
      */
     async getBoundariesReport(params) {
         this.logger.trace(params, 'BoundariesRepository::getBoundariesReport started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getBoundariesReport(novaDataSource, params, this.logger);
         this.logger.trace(result, 'BoundariesRepository::getBoundariesReport result');
         return result;
@@ -157,7 +157,7 @@ export class BoundariesRepository extends BaseRepository {
      */
     async processBoundaryEvent(params) {
         this.logger.trace(params, 'BoundariesRepository::processBoundaryEvent started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await processBoundaryEvent(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'BoundariesRepository::processBoundaryEvent result');
         return result;
@@ -170,10 +170,9 @@ export class BoundariesRepository extends BaseRepository {
      */
     async upsertBoundaryEvent(params) {
         this.logger.trace(params, 'BoundariesRepository::upsertBoundaryEvent started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await upsertBoundaryEvent(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'BoundariesRepository::upsertBoundaryEvent result');
         return result;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/repositories/boundaries/processBoundaryEvent.js

@@ -209,4 +209,3 @@ export const processBoundaryEvent = async (novaDataSource, params, logger) => {
         }
     }, 'BoundariesRepository::processBoundaryEvent');
 };
-//# sourceMappingURL=processBoundaryEvent.js.map

package/dist/repositories/boundaries/updateBoundary.js

@@ -51,4 +51,3 @@ export const updateBoundary = async (novaDataSource, params, logger) => {
         return result.affected > 0;
     }, 'BoundariesRepository::updateBoundary');
 };
-//# sourceMappingURL=updateBoundary.js.map

package/dist/repositories/boundaries/upsertBoundaryEvent.js

@@ -21,4 +21,3 @@ export const upsertBoundaryEvent = async (novaDataSource, params, logger) => {
         return result?.raw?.affectedRows > 0;
     }, 'BoundariesRepository::upsertBoundaryEvent');
 };
-//# sourceMappingURL=upsertBoundaryEvent.js.map

package/dist/repositories/clients/createClient.js

@@ -33,4 +33,3 @@ export const createClient = async (novaDataSource, params, logger) => {
         return await clientsRepository.save(newClient);
     }, 'ClientsRepository::createClient');
 };
-//# sourceMappingURL=createClient.js.map

package/dist/repositories/clients/createClientConfiguration.js

@@ -12,10 +12,7 @@ export const createClientConfiguration = async (novaDataSource, params, logger)
             stopTripThreshold: params.stopTripThreshold,
             mapUpdateMode: params.mapUpdateMode,
             maxUsersAllowed: params.maxUsersAllowed,
-            ssoDomain: params.ssoDomain,
-            ssoMetadata: params.ssoMetadata,
         };
         return await clientConfigurationRepository.save(newClientConfiguration);
     }, 'ClientsRepository::createClientConfiguration');
 };
-//# sourceMappingURL=createClientConfiguration.js.map

package/dist/repositories/clients/createCustomerAttribute.js

@@ -1,9 +1,6 @@
 import { CustomerAttribute } from '../../entities/customerAttribute';
-import { oneRequiredCreateCustomerAttributeParamsAttributes, requiredCreateCustomerAttributeParamsAttributes, } from '../../types/clients';
-import { allAttributesAreNull, anyAttributeIsNull } from '../../utils/paramsValidators';
 export const createCustomerAttribute = async (novaDataSource, params, logger) => {
-    if (anyAttributeIsNull(params, requiredCreateCustomerAttributeParamsAttributes) ||
-        allAttributesAreNull(params, oneRequiredCreateCustomerAttributeParamsAttributes)) {
+    if (!params?.clientId) {
         logger.warn({ params }, 'ClientsRepository::createCustomerAttribute - missing required parameters');
         return null;
     }
@@ -13,10 +10,7 @@ export const createCustomerAttribute = async (novaDataSource, params, logger) =>
             clientId: params.clientId,
             enterprise: params.enterprise,
             maintenanceModule: params.maintenanceModule,
-            billingMethod: params.billingMethod,
-            customerSegment: params.customerSegment,
         };
         return await clientConfigurationRepository.save(newCustomerAttribute);
     }, 'ClientsRepository::createCustomerAttribute');
 };
-//# sourceMappingURL=createCustomerAttribute.js.map

package/dist/repositories/clients/deleteClientAndConfiguration.js

@@ -23,4 +23,3 @@ export const deleteClientAndConfiguration = async (novaDataSource, params, logge
         await novaDataSource.disconnect();
     }
 };
-//# sourceMappingURL=deleteClientAndConfiguration.js.map

package/dist/repositories/clients/getClient.js

@@ -4,14 +4,9 @@ export const getClient = async (novaDataSource, params, logger) => {
         logger.warn({ params }, 'ClientsRepository::getClient - missing required parameters');
         return null;
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const clientsRepository = dataSource.getRepository(Client);
         let queryBuilder = clientsRepository.createQueryBuilder('client').comment(`test=value`);
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
         if (params.projectionOptions?.withCustomerAttribute) {
             queryBuilder = queryBuilder.leftJoinAndSelect('client.customerAttribute', 'customerAttribute');
         }
@@ -33,6 +28,5 @@ export const getClient = async (novaDataSource, params, logger) => {
             .select()
             .getOne();
         return client;
-    }, 'ClientsRepository::getClient', dbQueryRunner);
+    }, 'ClientsRepository::getClient');
 };
-//# sourceMappingURL=getClient.js.map

package/dist/repositories/clients/getClientConfiguration.js

@@ -1,31 +1,14 @@
 import { ClientConfiguration } from '../../entities';
-import { oneRequiredGetClientConfigurationParamsAttributes, } from '../../types/clients';
-import { allAttributesAreNull } from '../../utils/paramsValidators';
 export const getClientConfiguration = async (novaDataSource, params, logger) => {
-    if (allAttributesAreNull(params, oneRequiredGetClientConfigurationParamsAttributes)) {
+    if (!params.filters.clientId) {
         logger.warn({ params }, 'ClientsRepository::getClientConfiguration - missing required parameters');
         return null;
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const clientConfigurationRepository = dataSource.getRepository(ClientConfiguration);
-        const queryBuilder = clientConfigurationRepository.createQueryBuilder('clientConfiguration');
-        if (params.filters.clientId) {
-            queryBuilder.andWhere('clientConfiguration.clientId = :clientId', {
-                clientId: params.filters.clientId,
-            });
-        }
-        if (params.filters.ssoDomain) {
-            queryBuilder.andWhere('clientConfiguration.ssoDomain = :ssoDomain', {
-                ssoDomain: params.filters.ssoDomain,
-            });
-        }
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        const clientConfiguration = await queryBuilder.getOne();
+        const clientConfiguration = await clientConfigurationRepository.findOne({
+            where: { clientId: params.filters.clientId },
+        });
         return clientConfiguration;
-    }, 'ClientsRepository::getClientConfiguration', dbQueryRunner);
+    }, 'ClientsRepository::getClientConfiguration');
 };
-//# sourceMappingURL=getClientConfiguration.js.map

package/dist/repositories/clients/getClients.js

@@ -4,18 +4,13 @@ export const getClients = async (novaDataSource, params, logger) => {
         logger.warn({ params }, 'ClientsRepository::getClients - missing required parameters');
         return [];
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const clientsRepository = dataSource.getRepository(Client);
         let queryBuilder = clientsRepository
             .createQueryBuilder('client')
             .where('LOWER(client.email) = LOWER(:email)', {
             email: params.filters.email,
         });
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
         if (params.projectionOptions?.withCustomerAttribute) {
             queryBuilder = queryBuilder.leftJoinAndSelect('client.customerAttribute', 'customerAttribute');
         }
@@ -27,6 +22,5 @@ export const getClients = async (novaDataSource, params, logger) => {
             .select()
             .getMany();
         return clients;
-    }, 'ClientsRepository::getClients', dbQueryRunner);
+    }, 'ClientsRepository::getClients');
 };
-//# sourceMappingURL=getClients.js.map

package/dist/repositories/clients/getCustomerAttribute.js

@@ -4,20 +4,11 @@ export const getCustomerAttribute = async (novaDataSource, params, logger) => {
         logger.warn({ params }, 'ClientsRepository::getCustomerAttribute - missing required parameters');
         return null;
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const clientConfigurationRepository = dataSource.getRepository(CustomerAttribute);
-        const queryBuilder = clientConfigurationRepository
-            .createQueryBuilder('customerAttribute')
-            .where('customerAttribute.clientId = :clientId', {
-            clientId: params.filters.clientId,
+        const clientConfiguration = await clientConfigurationRepository.findOne({
+            where: { clientId: params.filters.clientId },
         });
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        const clientConfiguration = await queryBuilder.getOne();
         return clientConfiguration;
-    }, 'ClientsRepository::getCustomerAttribute', dbQueryRunner);
+    }, 'ClientsRepository::getCustomerAttribute');
 };
-//# sourceMappingURL=getCustomerAttribute.js.map

package/dist/repositories/clients/index.js

@@ -2,12 +2,10 @@ import { NovaDataSource } from '../../novaDataSource';
 import { BaseRepository } from '../baseRepository';
 import { createClient } from './createClient';
 import { createClientConfiguration } from './createClientConfiguration';
-import { createClientIngestorConfiguration } from './createClientIngestorConfiguration';
 import { createCustomerAttribute } from './createCustomerAttribute';
 import { deleteClientAndConfiguration } from './deleteClientAndConfiguration';
 import { getClient } from './getClient';
 import { getClientConfiguration } from './getClientConfiguration';
-import { getClientIngestorConfigurations } from './getClientIngestorConfigurations';
 import { getClients } from './getClients';
 import { getCustomerAttribute } from './getCustomerAttribute';
 import { updateClient } from './updateClient';
@@ -22,7 +20,7 @@ export class ClientsRepository extends BaseRepository {
      */
     async getClient(params) {
         this.logger.trace(params, 'ClientsRepository::getClient started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getClient(novaDataSource, params, this.logger);
         this.logger.trace(result, 'ClientsRepository::getClient result');
         return result;
@@ -34,7 +32,7 @@ export class ClientsRepository extends BaseRepository {
      */
     async getClients(params) {
         this.logger.trace(params, 'ClientsRepository::getClients started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getClients(novaDataSource, params, this.logger);
         this.logger.trace(result, 'ClientsRepository::getClients result');
         return result;
@@ -60,7 +58,7 @@ export class ClientsRepository extends BaseRepository {
      */
     async createClient(params) {
         this.logger.trace(params, 'ClientsRepository::createClient started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await createClient(novaDataSource, params, this.logger);
         this.logger.trace(result, 'ClientsRepository::createClient result');
         return result;
@@ -87,7 +85,7 @@ export class ClientsRepository extends BaseRepository {
      */
     async updateClient(params) {
         this.logger.trace(params, 'ClientsRepository::updateClient started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await updateClient(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'ClientsRepository::updateClient result');
         return result;
@@ -100,7 +98,7 @@ export class ClientsRepository extends BaseRepository {
      */
     async deleteClientAndConfigurations(params) {
         this.logger.trace(params, 'ClientsRepository::deleteClientAndConfigurations started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await deleteClientAndConfiguration(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'ClientsRepository::deleteClientAndConfigurations result');
         return result;
@@ -112,7 +110,7 @@ export class ClientsRepository extends BaseRepository {
      */
     async getClientConfiguration(params) {
         this.logger.trace(params, 'ClientsRepository::getClientConfiguration started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getClientConfiguration(novaDataSource, params, this.logger);
         this.logger.trace(result, 'ClientsRepository::getClientConfiguration result');
         return result;
@@ -125,12 +123,10 @@ export class ClientsRepository extends BaseRepository {
      * - stopTripThreshold: The stop trip threshold
      * - mapUpdateMode: The map update mode
      * - maxUsersAllowed: The max users allowed
-     * - ssoDomain: The sso domain, optional
-     * - ssoMetadata: The sso metadata, optional
      */
     async createClientConfiguration(params) {
         this.logger.trace(params, 'ClientsRepository::createClientConfiguration started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await createClientConfiguration(novaDataSource, params, this.logger);
         this.logger.trace(result, 'ClientsRepository::createClientConfiguration result');
         return result;
@@ -143,13 +139,11 @@ export class ClientsRepository extends BaseRepository {
      * - values.stopTripThreshold: The stop trip threshold, optional
      * - values.mapUpdateMode: The map update mode, optional
      * - values.maxUsersAllowed: The max users allowed, optional
-     * - values.ssoDomain: The sso domain, optional
-     * - values.ssoMetadata: The sso metadata, optional
      * @returns {Promise<boolean>} True if the client configuration was updated, false otherwise
      */
     async updateClientConfiguration(params) {
         this.logger.trace(params, 'ClientsRepository::updateClientConfiguration started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await updateClientConfiguration(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'ClientsRepository::updateClientConfiguration result');
         return result;
@@ -163,7 +157,7 @@ export class ClientsRepository extends BaseRepository {
      */
     async createCustomerAttribute(params) {
         this.logger.trace(params, 'ClientsRepository::createCustomerAttribute started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await createCustomerAttribute(novaDataSource, params, this.logger);
         this.logger.trace(result, 'ClientsRepository::createCustomerAttribute result');
         return result;
@@ -178,7 +172,7 @@ export class ClientsRepository extends BaseRepository {
      */
     async updateCustomerAttribute(params) {
         this.logger.trace(params, 'ClientsRepository::updateCustomerAttribute started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await updateCustomerAttribute(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'ClientsRepository::updateCustomerAttribute result');
         return result;
@@ -190,39 +184,9 @@ export class ClientsRepository extends BaseRepository {
      */
     async getCustomerAttribute(params) {
         this.logger.trace(params, 'ClientsRepository::getCustomerAttribute started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getCustomerAttribute(novaDataSource, params, this.logger);
         this.logger.trace(result, 'ClientsRepository::getCustomerAttribute result');
         return result;
     }
-    /**
-     * Get client ingestor configurations
-     * @param params containing information to get client ingestor configurations
-     * @returns  {Promise<ClientIngestorConfiguration[]>} The client ingestor configurations
-     */
-    async getClientIngestorConfigurations(params) {
-        this.logger.trace(params, 'ClientsRepository::getClientIngestorConfigurations started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await getClientIngestorConfigurations(novaDataSource, params);
-        this.logger.trace(result, 'ClientsRepository::getClientIngestorConfigurations result');
-        return result;
-    }
-    /**
-     * Create a client ingestor configuration
-     * @param  {CreateClientIngestorConfigurationParams} params containing information to create a client ingestor configuration
-     * - clientId: The client id
-     * - userActivationId: The user activation id
-     * - tokenUrl: The token url
-     * - fleetUrl: The fleet url
-     * - requestBody: The request body
-     * @returns {Promise<ClientIngestorConfiguration>} The created client ingestor configuration
-     */
-    async createClientIngestorConfiguration(params) {
-        this.logger.trace(params, 'ClientsRepository::createClientIngestorConfiguration started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await createClientIngestorConfiguration(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'ClientsRepository::createClientIngestorConfiguration result');
-        return result;
-    }
 }
-//# sourceMappingURL=index.js.map

package/dist/repositories/clients/updateClient.js

@@ -50,4 +50,3 @@ export const updateClient = async (novaDataSource, params, logger) => {
         return result.affected > 0;
     }, 'ClientsRepository::updateClient');
 };
-//# sourceMappingURL=updateClient.js.map

package/dist/repositories/clients/updateClientConfiguration.js

@@ -1,10 +1,15 @@
 import { ClientConfiguration } from '../../entities';
-import { oneRequiredUpdateClientConfigurationParamsAttributes, requiredUpdateClientConfigurationParamsAttributes, } from '../../types/clients';
-import { allAttributesAreNull, anyAttributeIsNull } from '../../utils/paramsValidators';
 export const updateClientConfiguration = async (novaDataSource, params, logger) => {
-    // validate params required and optional attributes
-    if (anyAttributeIsNull(params, requiredUpdateClientConfigurationParamsAttributes) ||
-        allAttributesAreNull(params, oneRequiredUpdateClientConfigurationParamsAttributes)) {
+    // clientId is required
+    if (!params?.filters?.clientId) {
+        logger.warn({ params }, 'ClientsRepository::updateClientConfiguration - missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (!params?.values?.movementTripThreshold &&
+        !params?.values?.stopTripThreshold &&
+        !params?.values?.mapUpdateMode &&
+        !params?.values?.maxUsersAllowed) {
         logger.warn({ params }, 'ClientsRepository::updateClientConfiguration - missing required parameters');
         return false;
     }
@@ -18,12 +23,9 @@ export const updateClientConfiguration = async (novaDataSource, params, logger)
             stopTripThreshold: params.values.stopTripThreshold,
             mapUpdateMode: params.values.mapUpdateMode,
             maxUsersAllowed: params.values.maxUsersAllowed,
-            ssoDomain: params.values.ssoDomain,
-            ssoMetadata: params.values.ssoMetadata,
         })
             .where('clientId = :clientId', { clientId: params.filters.clientId })
             .execute();
         return result.affected > 0;
     }, 'ClientsRepository::updateClientConfiguration');
 };
-//# sourceMappingURL=updateClientConfiguration.js.map

package/dist/repositories/clients/updateCustomerAttribute.js

@@ -1,10 +1,13 @@
 import { ClientConfiguration } from '../../entities';
 import { CustomerAttribute } from '../../entities/customerAttribute';
-import { oneRequiredUpdateCustomerAttributeParamsAttributes, requiredUpdateCustomerAttributeParamsAttributes, } from '../../types/clients';
-import { allAttributesAreNull, anyAttributeIsNull } from '../../utils/paramsValidators';
 export const updateCustomerAttribute = async (novaDataSource, params, logger) => {
-    if (anyAttributeIsNull(params, requiredUpdateCustomerAttributeParamsAttributes) ||
-        allAttributesAreNull(params, oneRequiredUpdateCustomerAttributeParamsAttributes)) {
+    // clientId is required
+    if (!params?.filters?.clientId) {
+        logger.warn({ params }, 'ClientsRepository::updateClientConfiguration - missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (params?.values?.enterprise == null && params?.values?.maintenanceModule == null) {
         logger.warn({ params }, 'ClientsRepository::updateClientConfiguration - missing required parameters');
         return false;
     }
@@ -16,12 +19,9 @@ export const updateCustomerAttribute = async (novaDataSource, params, logger) =>
             .set({
             enterprise: params.values.enterprise,
             maintenanceModule: params.values.maintenanceModule,
-            billingMethod: params.values.billingMethod,
-            customerSegment: params.values.customerSegment,
         })
             .where('clientId = :clientId', { clientId: params.filters.clientId })
             .execute();
         return result.affected > 0;
     }, 'ClientsRepository::updateCustomerAttribute');
 };
-//# sourceMappingURL=updateCustomerAttribute.js.map

package/dist/repositories/countries/getCountries.js

@@ -1,13 +1,8 @@
 import { Country } from '../../entities';
 export const getCountries = async (novaDataSource, params) => {
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const countriesRepository = dataSource.getRepository(Country);
         let queryBuilder = countriesRepository.createQueryBuilder('country');
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
         if (params?.filters?.idList?.length) {
             queryBuilder = queryBuilder.where('country.id IN (:...idList)', {
                 idList: params.filters.idList,
@@ -15,6 +10,5 @@ export const getCountries = async (novaDataSource, params) => {
         }
         const result = await queryBuilder.getMany();
         return result;
-    }, 'CountriesRepository::getCountries', dbQueryRunner);
+    }, 'CountriesRepository::getCountries');
 };
-//# sourceMappingURL=getCountries.js.map

package/dist/repositories/countries/getCountry.js

@@ -4,26 +4,20 @@ export const getCountry = async (novaDataSource, params, logger) => {
         logger.warn({ params }, 'CountriesRepository::getCountry - missing required parameters');
         return null;
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const countriesRepository = dataSource.getRepository(Country);
         let queryBuilder = countriesRepository.createQueryBuilder('country');
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
         if (params.filters.id) {
-            queryBuilder = queryBuilder.andWhere('country.id = :id', {
+            queryBuilder = queryBuilder.where('country.id = :id', {
                 id: params.filters.id,
             });
         }
         if (params.filters.alpha2Code) {
-            queryBuilder = queryBuilder.andWhere('country.alpha2Code = :alpha2Code', {
+            queryBuilder = queryBuilder.where('country.alpha2Code = :alpha2Code', {
                 alpha2Code: params.filters.alpha2Code,
             });
         }
         const result = await queryBuilder.getOne();
         return result;
-    }, 'CountriesRepository::getCountry', dbQueryRunner);
+    }, 'CountriesRepository::getCountry');
 };
-//# sourceMappingURL=getCountry.js.map

package/dist/repositories/countries/index.js

@@ -12,7 +12,7 @@ export class CountriesRepository extends BaseRepository {
      */
     async getCountry(params) {
         this.logger.trace(params, 'CountriesRepository::getCountry started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getCountry(novaDataSource, params, this.logger);
         this.logger.trace(result, 'CountriesRepository::getCountry result');
         return result;
@@ -25,10 +25,9 @@ export class CountriesRepository extends BaseRepository {
      */
     async getCountries(params) {
         this.logger.trace(params, 'CountriesRepository::getCountries started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getCountries(novaDataSource, params);
         this.logger.trace(result, 'CountriesRepository::getCountries result');
         return result;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/repositories/deactivations/createDeactivation.js

@@ -14,4 +14,3 @@ export const createDeactivation = async (novaDataSource, params, logger) => {
         return await deactivationsRepository.save(newDeactivation);
     }, 'DeactivationsRepository::createDeactivation');
 };
-//# sourceMappingURL=createDeactivation.js.map