@spytecgps/nova-orm 1.2.23 → 1.2.24

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

@@ -1,80 +1,80 @@
-import { LiveLink } from '../../entities';
-import { CreateLiveLinkParams, GetLiveLinkDataCountParams, GetLiveLinkDataParams, GetLiveLinksCountParams, GetLiveLinksParams, LiveLinkData, UpdateLiveLinkParams } from '../../types/liveLinks';
-import { BaseRepository2 } from '../baseRepository';
-export declare class LiveLinksRepository extends BaseRepository2 {
-    /**
-     * Create a new live link
-     * @param params - The parameters to create a live link
-     * id: the liveLink id, required. It should be a valid UUID.
-     * name: the liveLink name, required
-     * clientId: the client id, required
-     * startDate: the start date, optional
-     * endDate: the end date, optional
-     * deviceAccess: the device access, required. Values: 'full', 'limited'
-     * devices: array of devices the liveLink have access to, required if deviceAccess is 'limited'
-     * createdBy: the user who created the live link, optional
-     * @returns The created live link
-     */
-    createLiveLink(params: CreateLiveLinkParams): Promise<LiveLink>;
-    /**
-     * Update a live link
-     * @param params - The parameters to update a live link
-     * filters.id: the liveLink id, required. It should be a valid UUID.
-     * At least one value must be provided:
-     * values.name: the liveLink name, optional
-     * values.status: the liveLink status, optional
-     * values.startDate: the start date, optional
-     * values.endDate: the end date, optional
-     * values.deviceAccess: the device access, optional. Values: 'full', 'limited'
-     * values.devices: array of devices the liveLink have access to, optional
-     * values.modifiedBy: the user who modified the live link, optional
-     * @returns True if the live link was updated
-     */
-    updateLiveLink(params: UpdateLiveLinkParams): Promise<boolean>;
-    /**
-     * Get live links
-     * @param params - The parameters to get live links
-     * One of the following filters is required:
-     * filters.id: the liveLink id, optional. It should be a valid UUID.
-     * filters.clientId: the client id, optional
-     * filters.status: the liveLink status, optional
-     * filters.name: the liveLink name for partial match, optional
-     * filters.imeis: array of devices the liveLink have access to for partial match, optional
-     * pagingOptions.pageSize: the page size, optional. Default: 100
-     * pagingOptions.pageIndex: the page index, optional. Default: 0
-     * sortOptions.sortField: the sort field, optional. Default: 'id'
-     * sortOptions.sortOrder: the sort order, optional. Default: 'DESC'
-     * @returns The live links
-     */
-    getLiveLinks(params: GetLiveLinksParams): Promise<LiveLink[]>;
-    /**
-     * Get live links count
-     * @param params - The parameters to get live links count
-     * filters.clientId: the client id, required
-     * filters.status: the liveLink status, optional
-     * filters.name: the liveLink name for partial match, optional
-     * filters.imeis: array of devices the liveLink have access to for partial match, optional
-     * @returns The live links count
-     */
-    getLiveLinksCount(params: GetLiveLinksCountParams): Promise<number>;
-    /**
-     * Get trackers with location data associated with a live link
-     * @param params - The parameters to get live link data
-     * filters.id: the liveLink id, required. It should be a valid UUID.
-     * filters.clientId: the client id, required
-     * filters.minSendTime: the min send time, optional
-     * pagingOptions.pageSize: the page size, optional. Default: 100
-     * pagingOptions.pageIndex: the page index, optional. Default: 0
-     * @returns The live link data
-     */
-    getLiveLinkData(params: GetLiveLinkDataParams): Promise<LiveLinkData>;
-    /**
-     * Get total count of trackers with location data associated with a live link
-     * @param params - The parameters to get live link data count
-     * filters.id: the liveLink id, required. It should be a valid UUID.
-     * filters.clientId: the client id, required
-     * filters.minSendTime: the min send time, optional
-     * @returns The live link data count
-     */
-    getLiveLinkDataCount(params: GetLiveLinkDataCountParams): Promise<number>;
-}
+import { LiveLink } from '../../entities';
+import { CreateLiveLinkParams, GetLiveLinkDataCountParams, GetLiveLinkDataParams, GetLiveLinksCountParams, GetLiveLinksParams, LiveLinkData, UpdateLiveLinkParams } from '../../types/liveLinks';
+import { BaseRepository2 } from '../baseRepository';
+export declare class LiveLinksRepository extends BaseRepository2 {
+    /**
+     * Create a new live link
+     * @param params - The parameters to create a live link
+     * id: the liveLink id, required. It should be a valid UUID.
+     * name: the liveLink name, required
+     * clientId: the client id, required
+     * startDate: the start date, optional
+     * endDate: the end date, optional
+     * deviceAccess: the device access, required. Values: 'full', 'limited'
+     * devices: array of devices the liveLink have access to, required if deviceAccess is 'limited'
+     * createdBy: the user who created the live link, optional
+     * @returns The created live link
+     */
+    createLiveLink(params: CreateLiveLinkParams): Promise<LiveLink>;
+    /**
+     * Update a live link
+     * @param params - The parameters to update a live link
+     * filters.id: the liveLink id, required. It should be a valid UUID.
+     * At least one value must be provided:
+     * values.name: the liveLink name, optional
+     * values.status: the liveLink status, optional
+     * values.startDate: the start date, optional
+     * values.endDate: the end date, optional
+     * values.deviceAccess: the device access, optional. Values: 'full', 'limited'
+     * values.devices: array of devices the liveLink have access to, optional
+     * values.modifiedBy: the user who modified the live link, optional
+     * @returns True if the live link was updated
+     */
+    updateLiveLink(params: UpdateLiveLinkParams): Promise<boolean>;
+    /**
+     * Get live links
+     * @param params - The parameters to get live links
+     * One of the following filters is required:
+     * filters.id: the liveLink id, optional. It should be a valid UUID.
+     * filters.clientId: the client id, optional
+     * filters.status: the liveLink status, optional
+     * filters.name: the liveLink name for partial match, optional
+     * filters.imeis: array of devices the liveLink have access to for partial match, optional
+     * pagingOptions.pageSize: the page size, optional. Default: 100
+     * pagingOptions.pageIndex: the page index, optional. Default: 0
+     * sortOptions.sortField: the sort field, optional. Default: 'id'
+     * sortOptions.sortOrder: the sort order, optional. Default: 'DESC'
+     * @returns The live links
+     */
+    getLiveLinks(params: GetLiveLinksParams): Promise<LiveLink[]>;
+    /**
+     * Get live links count
+     * @param params - The parameters to get live links count
+     * filters.clientId: the client id, required
+     * filters.status: the liveLink status, optional
+     * filters.name: the liveLink name for partial match, optional
+     * filters.imeis: array of devices the liveLink have access to for partial match, optional
+     * @returns The live links count
+     */
+    getLiveLinksCount(params: GetLiveLinksCountParams): Promise<number>;
+    /**
+     * Get trackers with location data associated with a live link
+     * @param params - The parameters to get live link data
+     * filters.id: the liveLink id, required. It should be a valid UUID.
+     * filters.clientId: the client id, required
+     * filters.minSendTime: the min send time, optional
+     * pagingOptions.pageSize: the page size, optional. Default: 100
+     * pagingOptions.pageIndex: the page index, optional. Default: 0
+     * @returns The live link data
+     */
+    getLiveLinkData(params: GetLiveLinkDataParams): Promise<LiveLinkData>;
+    /**
+     * Get total count of trackers with location data associated with a live link
+     * @param params - The parameters to get live link data count
+     * filters.id: the liveLink id, required. It should be a valid UUID.
+     * filters.clientId: the client id, required
+     * filters.minSendTime: the min send time, optional
+     * @returns The live link data count
+     */
+    getLiveLinkDataCount(params: GetLiveLinkDataCountParams): Promise<number>;
+}

package/dist/repositories/liveLinks/index.js

@@ -1,124 +1,124 @@
-import { BaseRepository2 } from '../baseRepository';
-import { DeviceStatusRepository } from '../deviceStatus';
-import { createLiveLink } from './createLiveLink';
-import { getLiveLinkData } from './getLiveLinkData';
-import { getLiveLinkDataCount } from './getLiveLinkDataCount';
-import { getLiveLinks } from './getLiveLinks';
-import { getLiveLinksCount } from './getLiveLinksCount';
-import { updateLiveLink } from './updateLiveLink';
-export class LiveLinksRepository extends BaseRepository2 {
-    /**
-     * Create a new live link
-     * @param params - The parameters to create a live link
-     * id: the liveLink id, required. It should be a valid UUID.
-     * name: the liveLink name, required
-     * clientId: the client id, required
-     * startDate: the start date, optional
-     * endDate: the end date, optional
-     * deviceAccess: the device access, required. Values: 'full', 'limited'
-     * devices: array of devices the liveLink have access to, required if deviceAccess is 'limited'
-     * createdBy: the user who created the live link, optional
-     * @returns The created live link
-     */
-    async createLiveLink(params) {
-        this.logger.trace(params, 'LiveLinksRepository::createLiveLink started with params');
-        const result = await createLiveLink(this.dataSource, params, this.logger);
-        this.logger.trace(result, 'LiveLinksRepository::createLiveLink result');
-        return result;
-    }
-    /**
-     * Update a live link
-     * @param params - The parameters to update a live link
-     * filters.id: the liveLink id, required. It should be a valid UUID.
-     * At least one value must be provided:
-     * values.name: the liveLink name, optional
-     * values.status: the liveLink status, optional
-     * values.startDate: the start date, optional
-     * values.endDate: the end date, optional
-     * values.deviceAccess: the device access, optional. Values: 'full', 'limited'
-     * values.devices: array of devices the liveLink have access to, optional
-     * values.modifiedBy: the user who modified the live link, optional
-     * @returns True if the live link was updated
-     */
-    async updateLiveLink(params) {
-        this.logger.trace(params, 'LiveLinksRepository::updateLiveLink started with params');
-        const result = await updateLiveLink(this.dataSource, params, this.logger);
-        this.logger.trace({ result }, 'LiveLinksRepository::updateLiveLink result');
-        return result;
-    }
-    /**
-     * Get live links
-     * @param params - The parameters to get live links
-     * One of the following filters is required:
-     * filters.id: the liveLink id, optional. It should be a valid UUID.
-     * filters.clientId: the client id, optional
-     * filters.status: the liveLink status, optional
-     * filters.name: the liveLink name for partial match, optional
-     * filters.imeis: array of devices the liveLink have access to for partial match, optional
-     * pagingOptions.pageSize: the page size, optional. Default: 100
-     * pagingOptions.pageIndex: the page index, optional. Default: 0
-     * sortOptions.sortField: the sort field, optional. Default: 'id'
-     * sortOptions.sortOrder: the sort order, optional. Default: 'DESC'
-     * @returns The live links
-     */
-    async getLiveLinks(params) {
-        this.logger.trace(params, 'LiveLinksRepository::getLiveLinks started with params');
-        const result = await getLiveLinks(this.dataSource, params, this.logger);
-        this.logger.trace(result, 'LiveLinksRepository::getLiveLinks result');
-        return result;
-    }
-    /**
-     * Get live links count
-     * @param params - The parameters to get live links count
-     * filters.clientId: the client id, required
-     * filters.status: the liveLink status, optional
-     * filters.name: the liveLink name for partial match, optional
-     * filters.imeis: array of devices the liveLink have access to for partial match, optional
-     * @returns The live links count
-     */
-    async getLiveLinksCount(params) {
-        this.logger.trace(params, 'LiveLinksRepository::getLiveLinksCount started with params');
-        const result = await getLiveLinksCount(this.dataSource, params, this.logger);
-        this.logger.trace({ result }, 'LiveLinksRepository::getLiveLinksCount result');
-        return result;
-    }
-    /**
-     * Get trackers with location data associated with a live link
-     * @param params - The parameters to get live link data
-     * filters.id: the liveLink id, required. It should be a valid UUID.
-     * filters.clientId: the client id, required
-     * filters.minSendTime: the min send time, optional
-     * pagingOptions.pageSize: the page size, optional. Default: 100
-     * pagingOptions.pageIndex: the page index, optional. Default: 0
-     * @returns The live link data
-     */
-    async getLiveLinkData(params) {
-        this.logger.trace(params, 'LiveLinksRepository::getLiveLinkData started with params');
-        const deviceStatusRepository = new DeviceStatusRepository({
-            dataSource: this.dataSource,
-            logger: this.logger,
-        });
-        const result = await getLiveLinkData(this.dataSource, params, this.logger, deviceStatusRepository);
-        this.logger.trace(result, 'LiveLinksRepository::getLiveLinkData result');
-        return result;
-    }
-    /**
-     * Get total count of trackers with location data associated with a live link
-     * @param params - The parameters to get live link data count
-     * filters.id: the liveLink id, required. It should be a valid UUID.
-     * filters.clientId: the client id, required
-     * filters.minSendTime: the min send time, optional
-     * @returns The live link data count
-     */
-    async getLiveLinkDataCount(params) {
-        this.logger.trace(params, 'LiveLinksRepository::getLiveLinkDataCount started with params');
-        const deviceStatusRepository = new DeviceStatusRepository({
-            dataSource: this.dataSource,
-            logger: this.logger,
-        });
-        const result = await getLiveLinkDataCount(this.dataSource, params, this.logger, deviceStatusRepository);
-        this.logger.trace({ result }, 'LiveLinksRepository::getLiveLinkDataCount result');
-        return result;
-    }
-}
+import { BaseRepository2 } from '../baseRepository';
+import { DeviceStatusRepository } from '../deviceStatus';
+import { createLiveLink } from './createLiveLink';
+import { getLiveLinkData } from './getLiveLinkData';
+import { getLiveLinkDataCount } from './getLiveLinkDataCount';
+import { getLiveLinks } from './getLiveLinks';
+import { getLiveLinksCount } from './getLiveLinksCount';
+import { updateLiveLink } from './updateLiveLink';
+export class LiveLinksRepository extends BaseRepository2 {
+    /**
+     * Create a new live link
+     * @param params - The parameters to create a live link
+     * id: the liveLink id, required. It should be a valid UUID.
+     * name: the liveLink name, required
+     * clientId: the client id, required
+     * startDate: the start date, optional
+     * endDate: the end date, optional
+     * deviceAccess: the device access, required. Values: 'full', 'limited'
+     * devices: array of devices the liveLink have access to, required if deviceAccess is 'limited'
+     * createdBy: the user who created the live link, optional
+     * @returns The created live link
+     */
+    async createLiveLink(params) {
+        this.logger.trace(params, 'LiveLinksRepository::createLiveLink started with params');
+        const result = await createLiveLink(this.dataSource, params, this.logger);
+        this.logger.trace(result, 'LiveLinksRepository::createLiveLink result');
+        return result;
+    }
+    /**
+     * Update a live link
+     * @param params - The parameters to update a live link
+     * filters.id: the liveLink id, required. It should be a valid UUID.
+     * At least one value must be provided:
+     * values.name: the liveLink name, optional
+     * values.status: the liveLink status, optional
+     * values.startDate: the start date, optional
+     * values.endDate: the end date, optional
+     * values.deviceAccess: the device access, optional. Values: 'full', 'limited'
+     * values.devices: array of devices the liveLink have access to, optional
+     * values.modifiedBy: the user who modified the live link, optional
+     * @returns True if the live link was updated
+     */
+    async updateLiveLink(params) {
+        this.logger.trace(params, 'LiveLinksRepository::updateLiveLink started with params');
+        const result = await updateLiveLink(this.dataSource, params, this.logger);
+        this.logger.trace({ result }, 'LiveLinksRepository::updateLiveLink result');
+        return result;
+    }
+    /**
+     * Get live links
+     * @param params - The parameters to get live links
+     * One of the following filters is required:
+     * filters.id: the liveLink id, optional. It should be a valid UUID.
+     * filters.clientId: the client id, optional
+     * filters.status: the liveLink status, optional
+     * filters.name: the liveLink name for partial match, optional
+     * filters.imeis: array of devices the liveLink have access to for partial match, optional
+     * pagingOptions.pageSize: the page size, optional. Default: 100
+     * pagingOptions.pageIndex: the page index, optional. Default: 0
+     * sortOptions.sortField: the sort field, optional. Default: 'id'
+     * sortOptions.sortOrder: the sort order, optional. Default: 'DESC'
+     * @returns The live links
+     */
+    async getLiveLinks(params) {
+        this.logger.trace(params, 'LiveLinksRepository::getLiveLinks started with params');
+        const result = await getLiveLinks(this.dataSource, params, this.logger);
+        this.logger.trace(result, 'LiveLinksRepository::getLiveLinks result');
+        return result;
+    }
+    /**
+     * Get live links count
+     * @param params - The parameters to get live links count
+     * filters.clientId: the client id, required
+     * filters.status: the liveLink status, optional
+     * filters.name: the liveLink name for partial match, optional
+     * filters.imeis: array of devices the liveLink have access to for partial match, optional
+     * @returns The live links count
+     */
+    async getLiveLinksCount(params) {
+        this.logger.trace(params, 'LiveLinksRepository::getLiveLinksCount started with params');
+        const result = await getLiveLinksCount(this.dataSource, params, this.logger);
+        this.logger.trace({ result }, 'LiveLinksRepository::getLiveLinksCount result');
+        return result;
+    }
+    /**
+     * Get trackers with location data associated with a live link
+     * @param params - The parameters to get live link data
+     * filters.id: the liveLink id, required. It should be a valid UUID.
+     * filters.clientId: the client id, required
+     * filters.minSendTime: the min send time, optional
+     * pagingOptions.pageSize: the page size, optional. Default: 100
+     * pagingOptions.pageIndex: the page index, optional. Default: 0
+     * @returns The live link data
+     */
+    async getLiveLinkData(params) {
+        this.logger.trace(params, 'LiveLinksRepository::getLiveLinkData started with params');
+        const deviceStatusRepository = new DeviceStatusRepository({
+            dataSource: this.dataSource,
+            logger: this.logger,
+        });
+        const result = await getLiveLinkData(this.dataSource, params, this.logger, deviceStatusRepository);
+        this.logger.trace(result, 'LiveLinksRepository::getLiveLinkData result');
+        return result;
+    }
+    /**
+     * Get total count of trackers with location data associated with a live link
+     * @param params - The parameters to get live link data count
+     * filters.id: the liveLink id, required. It should be a valid UUID.
+     * filters.clientId: the client id, required
+     * filters.minSendTime: the min send time, optional
+     * @returns The live link data count
+     */
+    async getLiveLinkDataCount(params) {
+        this.logger.trace(params, 'LiveLinksRepository::getLiveLinkDataCount started with params');
+        const deviceStatusRepository = new DeviceStatusRepository({
+            dataSource: this.dataSource,
+            logger: this.logger,
+        });
+        const result = await getLiveLinkDataCount(this.dataSource, params, this.logger, deviceStatusRepository);
+        this.logger.trace({ result }, 'LiveLinksRepository::getLiveLinkDataCount result');
+        return result;
+    }
+}
 //# sourceMappingURL=index.js.map

package/dist/repositories/liveLinks/updateLiveLink.d.ts

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

package/dist/repositories/liveLinks/updateLiveLink.js

@@ -1,36 +1,36 @@
-import { LiveLink } from '../../entities/liveLink';
-import { anyAttributeHasValue } from '../../utils/anyAttributeHasValue';
-import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
-export const updateLiveLink = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.id) {
-        logger.warn({ params }, 'LiveLinksRepository::updateLiveLink - missing required parameters');
-        return false;
-    }
-    if (!anyAttributeHasValue(params?.values)) {
-        logger.warn({ params }, 'LiveLinksRepository::updateLiveLink - missing fields to update');
-        return false;
-    }
-    const binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.id);
-    if (!binaryBuffer?.length) {
-        logger.warn({ params }, 'LiveLinksRepository::updateLiveLink - id should be a valid UUID');
-        return null;
-    }
-    if (params.values?.deviceAccess === 'limited' && !params?.values.devices) {
-        logger.warn({ params }, 'LiveLinksRepository::updateLiveLink - devices should be provided if deviceAccess is limited');
-        return null;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const liveLinksRepository = dataSource.getRepository(LiveLink);
-        const queryBuilder = liveLinksRepository
-            .createQueryBuilder()
-            .update(LiveLink)
-            .set({
-            ...params.values,
-            modifiedAt: new Date(),
-        })
-            .where('id = :id', { id: binaryBuffer });
-        const result = await queryBuilder.execute();
-        return result.affected > 0;
-    }, 'LiveLinksRepository::updateLiveLink');
-};
+import { LiveLink } from '../../entities/liveLink';
+import { anyAttributeHasValue } from '../../utils/anyAttributeHasValue';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateLiveLink = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id) {
+        logger.warn({ params }, 'LiveLinksRepository::updateLiveLink - missing required parameters');
+        return false;
+    }
+    if (!anyAttributeHasValue(params?.values)) {
+        logger.warn({ params }, 'LiveLinksRepository::updateLiveLink - missing fields to update');
+        return false;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.id);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'LiveLinksRepository::updateLiveLink - id should be a valid UUID');
+        return null;
+    }
+    if (params.values?.deviceAccess === 'limited' && !params?.values.devices) {
+        logger.warn({ params }, 'LiveLinksRepository::updateLiveLink - devices should be provided if deviceAccess is limited');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const liveLinksRepository = dataSource.getRepository(LiveLink);
+        const queryBuilder = liveLinksRepository
+            .createQueryBuilder()
+            .update(LiveLink)
+            .set({
+            ...params.values,
+            modifiedAt: new Date(),
+        })
+            .where('id = :id', { id: binaryBuffer });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'LiveLinksRepository::updateLiveLink');
+};
 //# sourceMappingURL=updateLiveLink.js.map

package/dist/repositories/notificationRecipients/createNotificationRecipient.d.ts

@@ -1,5 +1,5 @@
-import { NotificationRecipient } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { Logger } from '../../types/logger';
-import { CreateNotificationRecipientParams } from '../../types/notificationRecipients';
-export declare const createNotificationRecipient: (novaDataSource: NovaDataSource, params: CreateNotificationRecipientParams, logger: Logger) => Promise<NotificationRecipient>;
+import { NotificationRecipient } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { CreateNotificationRecipientParams } from '../../types/notificationRecipients';
+export declare const createNotificationRecipient: (novaDataSource: NovaDataSource, params: CreateNotificationRecipientParams, logger: Logger) => Promise<NotificationRecipient>;

package/dist/repositories/notificationRecipients/createNotificationRecipient.js

@@ -1,39 +1,39 @@
-import { NotificationRecipient } from '../../entities';
-import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
-export const createNotificationRecipient = async (novaDataSource, params, logger) => {
-    if (!params?.clientId ||
-        !params?.userId ||
-        !params?.notificationType ||
-        !params?.recipient ||
-        params?.isEnabled == null ||
-        params?.isUserProfile == null) {
-        logger.warn({ params }, 'NotificationRecipientsRepository::createNotificationRecipient - missing required parameters');
-        return null;
-    }
-    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
-    if (!userIdBinaryBuffer?.length) {
-        logger.warn({ params }, 'NotificationRecipientsRepository::createNotificationRecipient - user id should be a valid UUID');
-        return null;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const notificationRecipientsRepository = dataSource.getRepository(NotificationRecipient);
-        const now = new Date();
-        const newNotificationRecipient = {
-            id: params.id,
-            userId: userIdBinaryBuffer,
-            clientId: params.clientId,
-            notificationType: params.notificationType,
-            recipient: params.recipient,
-            isEnabled: params.isEnabled,
-            isUserProfile: params.isUserProfile,
-            unsubscribed: params.unsubscribed,
-            unsubscribedInfo: params.unsubscribedInfo,
-            dataSourceTypeId: params.dataSourceTypeId,
-            createdAt: now,
-            modifiedAt: now,
-            userAlertConfigurationId: params.userAlertConfigurationId,
-        };
-        return await notificationRecipientsRepository.save(newNotificationRecipient);
-    }, 'NotificationRecipientsRepository::createNotificationRecipient');
-};
+import { NotificationRecipient } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createNotificationRecipient = async (novaDataSource, params, logger) => {
+    if (!params?.clientId ||
+        !params?.userId ||
+        !params?.notificationType ||
+        !params?.recipient ||
+        params?.isEnabled == null ||
+        params?.isUserProfile == null) {
+        logger.warn({ params }, 'NotificationRecipientsRepository::createNotificationRecipient - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'NotificationRecipientsRepository::createNotificationRecipient - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const notificationRecipientsRepository = dataSource.getRepository(NotificationRecipient);
+        const now = new Date();
+        const newNotificationRecipient = {
+            id: params.id,
+            userId: userIdBinaryBuffer,
+            clientId: params.clientId,
+            notificationType: params.notificationType,
+            recipient: params.recipient,
+            isEnabled: params.isEnabled,
+            isUserProfile: params.isUserProfile,
+            unsubscribed: params.unsubscribed,
+            unsubscribedInfo: params.unsubscribedInfo,
+            dataSourceTypeId: params.dataSourceTypeId,
+            createdAt: now,
+            modifiedAt: now,
+            userAlertConfigurationId: params.userAlertConfigurationId,
+        };
+        return await notificationRecipientsRepository.save(newNotificationRecipient);
+    }, 'NotificationRecipientsRepository::createNotificationRecipient');
+};
 //# sourceMappingURL=createNotificationRecipient.js.map

package/dist/repositories/notificationRecipients/deleteNotificationRecipients.d.ts

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