@spytecgps/nova-orm 1.2.32 → 1.2.34

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

@@ -1,46 +1,46 @@
-import { BLEMeshConfiguration } from '../../entities';
-import { CreateBLEMeshConfigurationParams, DeleteBLEMeshConfigurationParams, GetBLEMeshConfigurationParams, UpdateBLEMeshConfigurationParams } from '../../types/bleMeshConfiguration';
-import { BaseRepository } from '../baseRepository';
-/**
- * @deprecated Use BLEMeshRepository instead
- */
-export declare class BLEMeshConfigurationRepository extends BaseRepository {
-    /**
-     * Get ble mesh configuration
-     * @param params params containing information to get ble mesh configuration with filters
-     * At least one of the following filters is required:
-     * filters.imeiMain: the main device IMEI
-     * filters.btmacMain: the main device bluetooth MAC
-     * @returns Promise<BLEMeshConfiguration[]> the BLE Mesh configurations
-     */
-    getBLEMeshConfiguration(params: GetBLEMeshConfigurationParams): Promise<BLEMeshConfiguration[]>;
-    /**
-     * Create a BLE mesh configuration
-     * @param params params containing information to create BLE Mesh Configuration
-     * params.imeiMain: the main device IMEI, required
-     * params.btmacMain: the main device bluetooth MAC, required
-     * params.bleMac: the BLE MAC, required
-     * params.connectionType: the connection type, optional
-     * @returns Promise<BLEMeshConfiguration> the created BLE Mesh Configuration
-     */
-    createBLEMeshConfiguration(params: CreateBLEMeshConfigurationParams): Promise<BLEMeshConfiguration>;
-    /**
-     * Update BLE mesh configuration
-     * @param params params containing information to update BLE Mesh Configuration
-     * filters.id: the BLE Mesh Configuration id
-     * At least one of the following values is required:
-     * values.imeiMain: the main device IMEI
-     * values.btmacMain: the main device bluetooth MAC
-     * values.bleMac: the BLE MAC
-     * values.connectionType: the connection type
-     * @returns Promise<boolean> true if the BLE Mesh configuration was updated, false otherwise
-     */
-    updateBLEMeshConfiguration(params: UpdateBLEMeshConfigurationParams): Promise<boolean>;
-    /**
-     * Delete BLE Mesh Configuration
-     * @param params params containing information to delete BLE Mesh Configuration
-     * filters.id: the BLE Mesh Configuration id
-     * @returns Promise<boolean> true if the BLE Mesh configuration was deleted, false otherwise
-     */
-    deleteBLEMeshConfiguration(params: DeleteBLEMeshConfigurationParams): Promise<boolean>;
-}
+import { BLEMeshConfiguration } from '../../entities';
+import { CreateBLEMeshConfigurationParams, DeleteBLEMeshConfigurationParams, GetBLEMeshConfigurationParams, UpdateBLEMeshConfigurationParams } from '../../types/bleMeshConfiguration';
+import { BaseRepository } from '../baseRepository';
+/**
+ * @deprecated Use BLEMeshRepository instead
+ */
+export declare class BLEMeshConfigurationRepository extends BaseRepository {
+    /**
+     * Get ble mesh configuration
+     * @param params params containing information to get ble mesh configuration with filters
+     * At least one of the following filters is required:
+     * filters.imeiMain: the main device IMEI
+     * filters.btmacMain: the main device bluetooth MAC
+     * @returns Promise<BLEMeshConfiguration[]> the BLE Mesh configurations
+     */
+    getBLEMeshConfiguration(params: GetBLEMeshConfigurationParams): Promise<BLEMeshConfiguration[]>;
+    /**
+     * Create a BLE mesh configuration
+     * @param params params containing information to create BLE Mesh Configuration
+     * params.imeiMain: the main device IMEI, required
+     * params.btmacMain: the main device bluetooth MAC, required
+     * params.bleMac: the BLE MAC, required
+     * params.connectionType: the connection type, optional
+     * @returns Promise<BLEMeshConfiguration> the created BLE Mesh Configuration
+     */
+    createBLEMeshConfiguration(params: CreateBLEMeshConfigurationParams): Promise<BLEMeshConfiguration>;
+    /**
+     * Update BLE mesh configuration
+     * @param params params containing information to update BLE Mesh Configuration
+     * filters.id: the BLE Mesh Configuration id
+     * At least one of the following values is required:
+     * values.imeiMain: the main device IMEI
+     * values.btmacMain: the main device bluetooth MAC
+     * values.bleMac: the BLE MAC
+     * values.connectionType: the connection type
+     * @returns Promise<boolean> true if the BLE Mesh configuration was updated, false otherwise
+     */
+    updateBLEMeshConfiguration(params: UpdateBLEMeshConfigurationParams): Promise<boolean>;
+    /**
+     * Delete BLE Mesh Configuration
+     * @param params params containing information to delete BLE Mesh Configuration
+     * filters.id: the BLE Mesh Configuration id
+     * @returns Promise<boolean> true if the BLE Mesh configuration was deleted, false otherwise
+     */
+    deleteBLEMeshConfiguration(params: DeleteBLEMeshConfigurationParams): Promise<boolean>;
+}

package/dist/repositories/bleMeshConfiguration/index.js

@@ -1,74 +1,74 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { BaseRepository } from '../baseRepository';
-import { createBLEMeshConfigurationParams } from './createBLEMeshConfigurationParams';
-import { deleteBLEMeshConfiguration } from './deleteBLEMeshConfiguration';
-import { getBLEMeshConfiguration } from './getBLEMeshConfiguration';
-import { updateBLEMeshConfiguration } from './updateBLEMeshConfiguration';
-/**
- * @deprecated Use BLEMeshRepository instead
- */
-export class BLEMeshConfigurationRepository extends BaseRepository {
-    /**
-     * Get ble mesh configuration
-     * @param params params containing information to get ble mesh configuration with filters
-     * At least one of the following filters is required:
-     * filters.imeiMain: the main device IMEI
-     * filters.btmacMain: the main device bluetooth MAC
-     * @returns Promise<BLEMeshConfiguration[]> the BLE Mesh configurations
-     */
-    async getBLEMeshConfiguration(params) {
-        this.logger.trace(params, 'BLEMeshConfigurationRepository::getBLEMeshConfiguration started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await getBLEMeshConfiguration(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'BLEMeshConfigurationRepository::getBLEMeshConfiguration result');
-        return result;
-    }
-    /**
-     * Create a BLE mesh configuration
-     * @param params params containing information to create BLE Mesh Configuration
-     * params.imeiMain: the main device IMEI, required
-     * params.btmacMain: the main device bluetooth MAC, required
-     * params.bleMac: the BLE MAC, required
-     * params.connectionType: the connection type, optional
-     * @returns Promise<BLEMeshConfiguration> the created BLE Mesh Configuration
-     */
-    async createBLEMeshConfiguration(params) {
-        this.logger.trace(params, 'BLEMeshConfigurationRepository::createBLEMeshConfiguration started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await createBLEMeshConfigurationParams(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'BLEMeshConfigurationRepository::createBLEMeshConfiguration result');
-        return result;
-    }
-    /**
-     * Update BLE mesh configuration
-     * @param params params containing information to update BLE Mesh Configuration
-     * filters.id: the BLE Mesh Configuration id
-     * At least one of the following values is required:
-     * values.imeiMain: the main device IMEI
-     * values.btmacMain: the main device bluetooth MAC
-     * values.bleMac: the BLE MAC
-     * values.connectionType: the connection type
-     * @returns Promise<boolean> true if the BLE Mesh configuration was updated, false otherwise
-     */
-    async updateBLEMeshConfiguration(params) {
-        this.logger.trace(params, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await updateBLEMeshConfiguration(novaDataSource, params, this.logger);
-        this.logger.trace({ result }, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration result');
-        return result;
-    }
-    /**
-     * Delete BLE Mesh Configuration
-     * @param params params containing information to delete BLE Mesh Configuration
-     * filters.id: the BLE Mesh Configuration id
-     * @returns Promise<boolean> true if the BLE Mesh configuration was deleted, false otherwise
-     */
-    async deleteBLEMeshConfiguration(params) {
-        this.logger.trace(params, 'BLEMeshConfigurationRepository::deleteBLEMeshConfiguration started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await deleteBLEMeshConfiguration(novaDataSource, params, this.logger);
-        this.logger.trace({ result }, 'BLEMeshConfigurationRepository::deleteBLEMeshConfiguration result');
-        return result;
-    }
-}
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createBLEMeshConfigurationParams } from './createBLEMeshConfigurationParams';
+import { deleteBLEMeshConfiguration } from './deleteBLEMeshConfiguration';
+import { getBLEMeshConfiguration } from './getBLEMeshConfiguration';
+import { updateBLEMeshConfiguration } from './updateBLEMeshConfiguration';
+/**
+ * @deprecated Use BLEMeshRepository instead
+ */
+export class BLEMeshConfigurationRepository extends BaseRepository {
+    /**
+     * Get ble mesh configuration
+     * @param params params containing information to get ble mesh configuration with filters
+     * At least one of the following filters is required:
+     * filters.imeiMain: the main device IMEI
+     * filters.btmacMain: the main device bluetooth MAC
+     * @returns Promise<BLEMeshConfiguration[]> the BLE Mesh configurations
+     */
+    async getBLEMeshConfiguration(params) {
+        this.logger.trace(params, 'BLEMeshConfigurationRepository::getBLEMeshConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await getBLEMeshConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'BLEMeshConfigurationRepository::getBLEMeshConfiguration result');
+        return result;
+    }
+    /**
+     * Create a BLE mesh configuration
+     * @param params params containing information to create BLE Mesh Configuration
+     * params.imeiMain: the main device IMEI, required
+     * params.btmacMain: the main device bluetooth MAC, required
+     * params.bleMac: the BLE MAC, required
+     * params.connectionType: the connection type, optional
+     * @returns Promise<BLEMeshConfiguration> the created BLE Mesh Configuration
+     */
+    async createBLEMeshConfiguration(params) {
+        this.logger.trace(params, 'BLEMeshConfigurationRepository::createBLEMeshConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await createBLEMeshConfigurationParams(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'BLEMeshConfigurationRepository::createBLEMeshConfiguration result');
+        return result;
+    }
+    /**
+     * Update BLE mesh configuration
+     * @param params params containing information to update BLE Mesh Configuration
+     * filters.id: the BLE Mesh Configuration id
+     * At least one of the following values is required:
+     * values.imeiMain: the main device IMEI
+     * values.btmacMain: the main device bluetooth MAC
+     * values.bleMac: the BLE MAC
+     * values.connectionType: the connection type
+     * @returns Promise<boolean> true if the BLE Mesh configuration was updated, false otherwise
+     */
+    async updateBLEMeshConfiguration(params) {
+        this.logger.trace(params, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await updateBLEMeshConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration result');
+        return result;
+    }
+    /**
+     * Delete BLE Mesh Configuration
+     * @param params params containing information to delete BLE Mesh Configuration
+     * filters.id: the BLE Mesh Configuration id
+     * @returns Promise<boolean> true if the BLE Mesh configuration was deleted, false otherwise
+     */
+    async deleteBLEMeshConfiguration(params) {
+        this.logger.trace(params, 'BLEMeshConfigurationRepository::deleteBLEMeshConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await deleteBLEMeshConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'BLEMeshConfigurationRepository::deleteBLEMeshConfiguration result');
+        return result;
+    }
+}
 //# sourceMappingURL=index.js.map

package/dist/repositories/bleMeshConfiguration/updateBLEMeshConfiguration.d.ts

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

package/dist/repositories/bleMeshConfiguration/updateBLEMeshConfiguration.js

@@ -1,31 +1,31 @@
-import { BLEMeshConfiguration } from '../../entities';
-export const updateBLEMeshConfiguration = async (novaDataSource, params, logger) => {
-    // id is required
-    if (!params?.filters?.id) {
-        logger.warn({ params }, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration missing required parameters');
-        return false;
-    }
-    // at least one field to update is required
-    if (!params?.values?.imeiMain &&
-        !params?.values?.bleMac &&
-        !params?.values?.btmacMain &&
-        !params?.values?.connectionType) {
-        logger.warn({ params }, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration missing required parameters');
-        return false;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const bleMeshConfigRepository = dataSource.getRepository(BLEMeshConfiguration);
-        const now = new Date();
-        const queryBuilder = bleMeshConfigRepository
-            .createQueryBuilder()
-            .update(BLEMeshConfiguration)
-            .set({
-            ...params.values,
-            modifiedAt: now,
-        })
-            .where('id = :id', { id: params.filters.id });
-        const result = await queryBuilder.execute();
-        return result.affected > 0;
-    }, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration');
-};
+import { BLEMeshConfiguration } from '../../entities';
+export const updateBLEMeshConfiguration = async (novaDataSource, params, logger) => {
+    // id is required
+    if (!params?.filters?.id) {
+        logger.warn({ params }, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (!params?.values?.imeiMain &&
+        !params?.values?.bleMac &&
+        !params?.values?.btmacMain &&
+        !params?.values?.connectionType) {
+        logger.warn({ params }, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const bleMeshConfigRepository = dataSource.getRepository(BLEMeshConfiguration);
+        const now = new Date();
+        const queryBuilder = bleMeshConfigRepository
+            .createQueryBuilder()
+            .update(BLEMeshConfiguration)
+            .set({
+            ...params.values,
+            modifiedAt: now,
+        })
+            .where('id = :id', { id: params.filters.id });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'BLEMeshConfigurationRepository::updateBLEMeshConfiguration');
+};
 //# sourceMappingURL=updateBLEMeshConfiguration.js.map

package/dist/repositories/boundaries/createBoundary.d.ts

@@ -1,5 +1,5 @@
-import { Boundary } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { CreateBoundaryParams } from '../../types/boundaries';
-import { Logger } from '../../types/logger';
-export declare const createBoundary: (novaDataSource: NovaDataSource, params: CreateBoundaryParams, logger: Logger) => Promise<Boundary>;
+import { Boundary } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { CreateBoundaryParams } from '../../types/boundaries';
+import { Logger } from '../../types/logger';
+export declare const createBoundary: (novaDataSource: NovaDataSource, params: CreateBoundaryParams, logger: Logger) => Promise<Boundary>;

package/dist/repositories/boundaries/createBoundary.js

@@ -1,53 +1,53 @@
-import { Boundary } from '../../entities';
-import { BoundaryStatus } from '../../types/enums';
-const MIN_BOUNDARY_RADIUS_IN_M = 50; // in meters
-const DEFAULT_BOUNDARY_COLOR = '#e74c3c';
-const DEFAULT_BOUNDARY_DISPLAY_UNIT = 'm';
-export const createBoundary = async (novaDataSource, params, logger) => {
-    if (!params?.clientId ||
-        params.clientId === 0 ||
-        !params?.name ||
-        !params?.type ||
-        !params?.location ||
-        !params?.geometry) {
-        logger.warn({ params }, 'BoundariesRepository::createBoundary - missing required parameters');
-        return null;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const boundariesRepository = dataSource.getRepository(Boundary);
-        const now = new Date();
-        // radius
-        let buffer = parseFloat(params.buffer);
-        if (Number.isNaN(buffer)) {
-            buffer = 0;
-        }
-        const normalizedRadius = Math.max(buffer, MIN_BOUNDARY_RADIUS_IN_M);
-        // display unit
-        const radiusDisplayUnit = params.radiusDisplayUnit || DEFAULT_BOUNDARY_DISPLAY_UNIT;
-        // if not color default
-        const color = params.color || DEFAULT_BOUNDARY_COLOR;
-        // status
-        const status = params.status > 0 && params.status < 4 ? params.status : BoundaryStatus.Active;
-        const newBoundary = {
-            id: params.boundaryId,
-            name: params.name,
-            type: params.type,
-            buffer: `${normalizedRadius}`,
-            radiusDisplayUnit,
-            clientId: params.clientId,
-            createdAt: now,
-            modifiedAt: now,
-            createdBy: params.createdBy,
-            modifiedBy: params.createdBy,
-            location: params.location,
-            color,
-            geometry: params.geometry,
-            isUserCreated: params.isUserCreated ?? true,
-            status,
-            area: params.area,
-            dataSourceTypeId: params.dataSourceTypeId,
-        };
-        return await boundariesRepository.save(newBoundary);
-    }, 'BoundariesRepository::createBoundary');
-};
+import { Boundary } from '../../entities';
+import { BoundaryStatus } from '../../types/enums';
+const MIN_BOUNDARY_RADIUS_IN_M = 50; // in meters
+const DEFAULT_BOUNDARY_COLOR = '#e74c3c';
+const DEFAULT_BOUNDARY_DISPLAY_UNIT = 'm';
+export const createBoundary = async (novaDataSource, params, logger) => {
+    if (!params?.clientId ||
+        params.clientId === 0 ||
+        !params?.name ||
+        !params?.type ||
+        !params?.location ||
+        !params?.geometry) {
+        logger.warn({ params }, 'BoundariesRepository::createBoundary - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const now = new Date();
+        // radius
+        let buffer = parseFloat(params.buffer);
+        if (Number.isNaN(buffer)) {
+            buffer = 0;
+        }
+        const normalizedRadius = Math.max(buffer, MIN_BOUNDARY_RADIUS_IN_M);
+        // display unit
+        const radiusDisplayUnit = params.radiusDisplayUnit || DEFAULT_BOUNDARY_DISPLAY_UNIT;
+        // if not color default
+        const color = params.color || DEFAULT_BOUNDARY_COLOR;
+        // status
+        const status = params.status > 0 && params.status < 4 ? params.status : BoundaryStatus.Active;
+        const newBoundary = {
+            id: params.boundaryId,
+            name: params.name,
+            type: params.type,
+            buffer: `${normalizedRadius}`,
+            radiusDisplayUnit,
+            clientId: params.clientId,
+            createdAt: now,
+            modifiedAt: now,
+            createdBy: params.createdBy,
+            modifiedBy: params.createdBy,
+            location: params.location,
+            color,
+            geometry: params.geometry,
+            isUserCreated: params.isUserCreated ?? true,
+            status,
+            area: params.area,
+            dataSourceTypeId: params.dataSourceTypeId,
+        };
+        return await boundariesRepository.save(newBoundary);
+    }, 'BoundariesRepository::createBoundary');
+};
 //# sourceMappingURL=createBoundary.js.map

package/dist/repositories/boundaries/deleteBoundary.d.ts

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

package/dist/repositories/boundaries/deleteBoundary.js

@@ -1,24 +1,24 @@
-import { Boundary } from '../../entities';
-import { BoundaryStatus } from '../../types/enums';
-export const deleteBoundary = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.boundaryId) {
-        logger.warn({ params }, 'BoundariesRepository::deleteBoundary - missing required parameters');
-        return false;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const boundariesRepository = dataSource.getRepository(Boundary);
-        const now = new Date();
-        const result = await boundariesRepository
-            .createQueryBuilder()
-            .update(Boundary)
-            .set({
-            status: BoundaryStatus.Deleted,
-            modifiedBy: params.values.modifiedBy,
-            modifiedAt: now,
-        })
-            .where('id = :id', { id: params.filters.boundaryId })
-            .execute();
-        return result.affected > 0;
-    }, 'BoundariesRepository::deleteBoundary');
-};
+import { Boundary } from '../../entities';
+import { BoundaryStatus } from '../../types/enums';
+export const deleteBoundary = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.boundaryId) {
+        logger.warn({ params }, 'BoundariesRepository::deleteBoundary - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const now = new Date();
+        const result = await boundariesRepository
+            .createQueryBuilder()
+            .update(Boundary)
+            .set({
+            status: BoundaryStatus.Deleted,
+            modifiedBy: params.values.modifiedBy,
+            modifiedAt: now,
+        })
+            .where('id = :id', { id: params.filters.boundaryId })
+            .execute();
+        return result.affected > 0;
+    }, 'BoundariesRepository::deleteBoundary');
+};
 //# sourceMappingURL=deleteBoundary.js.map

package/dist/repositories/boundaries/getBoundariesByClientId.d.ts

@@ -1,5 +1,5 @@
-import { Boundary } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { GetBoundariesByClientIdParams } from '../../types/boundaries';
-import { Logger } from '../../types/logger';
-export declare const getBoundariesByClientId: (novaDataSource: NovaDataSource, params: GetBoundariesByClientIdParams, logger: Logger) => Promise<Boundary[]>;
+import { Boundary } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { GetBoundariesByClientIdParams } from '../../types/boundaries';
+import { Logger } from '../../types/logger';
+export declare const getBoundariesByClientId: (novaDataSource: NovaDataSource, params: GetBoundariesByClientIdParams, logger: Logger) => Promise<Boundary[]>;

package/dist/repositories/boundaries/getBoundariesByClientId.js

@@ -1,54 +1,54 @@
-import { Boundary, EntityTag, Tag } from '../../entities';
-export const getBoundariesByClientId = async (novaDataSource, params, logger) => {
-    if (!params.filters.clientId) {
-        logger.warn({ params }, 'BoundariesRepository::getBoundariesByClientId - 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 boundariesRepository = dataSource.getRepository(Boundary);
-        const filterCondition = params.filters.status
-            ? { clientId: params.filters.clientId, status: params.filters.status }
-            : { clientId: params.filters.clientId };
-        const queryBuilder = boundariesRepository
-            .createQueryBuilder('boundary')
-            .where(filterCondition);
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        if (params.filters.tagIdList?.length) {
+import { Boundary, EntityTag, Tag } from '../../entities';
+export const getBoundariesByClientId = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundariesByClientId - 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 boundariesRepository = dataSource.getRepository(Boundary);
+        const filterCondition = params.filters.status
+            ? { clientId: params.filters.clientId, status: params.filters.status }
+            : { clientId: params.filters.clientId };
+        const queryBuilder = boundariesRepository
+            .createQueryBuilder('boundary')
+            .where(filterCondition);
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        if (params.filters.tagIdList?.length) {
             queryBuilder.innerJoin(EntityTag, 'entityTag', `entityTag.entityId = boundary.id 
            AND entityTag.entityType = 'Boundary'
-           AND entityTag.tagId IN (:...tagIdList)`, {
-                tagIdList: params.filters.tagIdList,
-            });
-        }
-        let boundaries = await queryBuilder.getMany();
-        if (params.projectionOptions?.withSecurityGroupTag) {
-            //TODO: Refactor this to a common function,
-            // change the approach to get the security group tags for all the users in one query,
-            // then map them to the users. Target methods: getDevices, getUsers
-            const entityTagRepo = dataSource.getRepository(EntityTag);
-            boundaries = await Promise.all(boundaries.map(async (boundary) => {
-                const entityTagQueryBuilder = entityTagRepo.createQueryBuilder('entityTag');
-                if (queryRunner) {
-                    entityTagQueryBuilder.setQueryRunner(queryRunner);
-                }
-                const securityGroupEntityTags = await entityTagQueryBuilder
-                    .where('entityTag.entityId = :entityId AND entityTag.entityType = :entityType', {
-                    entityId: boundary.id,
-                    entityType: 'Boundary',
-                })
-                    .innerJoin(Tag, 'tag', `tag.id = entityTag.tagId AND JSON_CONTAINS(tag.metadata, :metadata)`, { metadata: JSON.stringify({ isSecurityGroup: true }) })
-                    .getMany();
-                return {
-                    ...boundary,
-                    securityGroupEntityTags,
-                };
-            }));
-        }
-        return boundaries;
-    }, 'BoundariesRepository::getBoundariesByClientId', dbQueryRunner);
-};
+           AND entityTag.tagId IN (:...tagIdList)`, {
+                tagIdList: params.filters.tagIdList,
+            });
+        }
+        let boundaries = await queryBuilder.getMany();
+        if (params.projectionOptions?.withSecurityGroupTag) {
+            //TODO: Refactor this to a common function,
+            // change the approach to get the security group tags for all the users in one query,
+            // then map them to the users. Target methods: getDevices, getUsers
+            const entityTagRepo = dataSource.getRepository(EntityTag);
+            boundaries = await Promise.all(boundaries.map(async (boundary) => {
+                const entityTagQueryBuilder = entityTagRepo.createQueryBuilder('entityTag');
+                if (queryRunner) {
+                    entityTagQueryBuilder.setQueryRunner(queryRunner);
+                }
+                const securityGroupEntityTags = await entityTagQueryBuilder
+                    .where('entityTag.entityId = :entityId AND entityTag.entityType = :entityType', {
+                    entityId: boundary.id,
+                    entityType: 'Boundary',
+                })
+                    .innerJoin(Tag, 'tag', `tag.id = entityTag.tagId AND JSON_CONTAINS(tag.metadata, :metadata)`, { metadata: JSON.stringify({ isSecurityGroup: true }) })
+                    .getMany();
+                return {
+                    ...boundary,
+                    securityGroupEntityTags,
+                };
+            }));
+        }
+        return boundaries;
+    }, 'BoundariesRepository::getBoundariesByClientId', dbQueryRunner);
+};
 //# sourceMappingURL=getBoundariesByClientId.js.map

package/dist/repositories/boundaries/getBoundariesIdsByClientId.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { GetBoundariesByClientIdParams } from '../../types/boundaries';
-import { Logger } from '../../types/logger';
-export declare const getBoundariesIdsByClientId: (novaDataSource: NovaDataSource, params: GetBoundariesByClientIdParams, logger: Logger) => Promise<number[]>;
+import { NovaDataSource } from '../../novaDataSource';
+import { GetBoundariesByClientIdParams } from '../../types/boundaries';
+import { Logger } from '../../types/logger';
+export declare const getBoundariesIdsByClientId: (novaDataSource: NovaDataSource, params: GetBoundariesByClientIdParams, logger: Logger) => Promise<number[]>;