@spytecgps/nova-orm 0.0.224 → 0.0.226

package/dist/repositories/userActivations/index.js

@@ -0,0 +1,229 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createUserActivation } from './createUserActivation';
+import { createUserActivationDevice } from './createUserActivationDevice';
+import { createUserActivationEvent } from './createUserActivationEvent';
+import { createUserActivationMetric } from './createUserActivationMetric';
+import { deleteUserActivation } from './deleteUserActivation';
+import { getLastActivationDevice } from './getLastActivationDevice';
+import { getUserActivationDevices } from './getUserActivationDevices';
+import { getUserActivationDevicesByClientId } from './getUserActivationDevicesByClientId';
+import { getUserActivationMetrics } from './getUserActivationMetrics';
+import { getUserActivations } from './getUserActivations';
+import { updateUserActivationDevice } from './updateUserActivationDevice';
+import { updateUserActivationMetrics } from './updateUserActivationMetrics';
+export class UserActivationsRepository extends BaseRepository {
+    /**
+     * Create user activation
+     * @param {CreateUserActivationParams} params containing information to create a user activation
+     * - params.id: The user activation id, optional. If not provided, it will be generated
+     * - params.userId: The user id, required
+     * - params.clientId: The client id, required
+     * - params.status: The status, optional. If not provided, it will be set to 'A'
+     * @returns The created user activation
+     */
+    async createUserActivation(params) {
+        this.logger.trace(params, 'UserActivationsRepository::createUserActivation started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserActivation(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserActivationsRepository::createUserActivation result');
+        return result;
+    }
+    /**
+     * Get user activations
+     * @param {GetUserActivationsParams} params containing information to get user activations
+     * Filters:
+     * One of the following filters is required
+     * - params.filters.userId: The user id, optional
+     * - params.filters.clientId: The client id, optional
+     * @returns The user activations
+     */
+    async getUserActivations(params) {
+        this.logger.trace(params, 'UserActivationsRepository::getUserActivations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserActivations(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserActivationsRepository::getUserActivations result');
+        return result;
+    }
+    /**
+     * Delete user activation
+     * @param {DeleteUserActivationParams} params containing information to delete a user activation
+     * - params.userId: The user id, required
+     * @returns True if the user activation was deleted, false otherwise
+     */
+    async deleteUserActivation(params) {
+        this.logger.trace(params, 'UserActivationsRepository::deleteUserActivation started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteUserActivation(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserActivationsRepository::deleteUserActivation result');
+        return result;
+    }
+    /**
+     * Get user activation devices
+     * @param {GetUserActivationDevicesParams} params containing information to get user activation devices
+     * Filters:
+     * One of the following filters is required
+     * - params.filters.id: The user activation device id, optional
+     * - params.filters.imei: The user activation device imei, optional
+     * @returns The user activation devices
+     */
+    async getUserActivationDevices(params) {
+        this.logger.trace(params, 'UserActivationsRepository::getUserActivationDevices started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserActivationDevices(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserActivationsRepository::getUserActivationDevices result');
+        return result;
+    }
+    /**
+     * Get user activation devices by client id
+     * @param {GetUserActivationDevicesByClientIdParams} params containing information to get user activation devices by client id
+     * Filters:
+     * - params.filters.clientId: The client id, required
+     * @returns The user activation devices
+     */
+    async getUserActivationDevicesByClientId(params) {
+        this.logger.trace(params, 'UserActivationsRepository::getUserActivationDevicesByClientId started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserActivationDevicesByClientId(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserActivationsRepository::getUserActivationDevicesByClientId result');
+        return result;
+    }
+    /**
+     * Create user activation device
+     * @param {CreateUserActivationDeviceParams} params containing information to create a user activation device
+     * - params.id: The user activation device id, optional. If not provided, it will be generated
+     * - params.userActivationId: The user activation id, required
+     * - params.deviceId: The device id, required
+     * - params.imei: The device imei, required
+     * - params.model: The device model, optional
+     * - params.billingInterval: The billing interval, optional
+     * - params.deviceName: The device name, optional
+     * - params.status: The status, optional
+     * - params.trackingReason: The tracking reason, optional
+     * - params.deviceColor: The device color, optional
+     * - params.notificationByEmail: The notification by email, optional
+     * - params.notificationBySms: The notification by sms, optional
+     * - params.planAnnual: The plan annual, optional
+     * - params.dataSourceTypeId: The data source type id, optional
+     * - params.subscriptionId: The subscription id, optional
+     * - params.platform: The platform, optional
+     * - params.eventType: The event type, optional
+     * - params.planCode: The plan code, optional
+     * @returns The created user activation device
+     */
+    async createUserActivationDevice(params) {
+        this.logger.trace(params, 'UserActivationsRepository::createUserActivationDevice started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserActivationDevice(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserActivationsRepository::createUserActivationDevice result');
+        return result;
+    }
+    /**
+     * Get last activation device
+     * @param {GetLastActivationDeviceParams} params containing information to get last activation device
+     * Filters:
+     * - params.filters.imei: The user activation device imei, required
+     * Projection options:
+     * - params.projectionOptions.withDevice: If true, the device will be included in the result, optional
+     * - params.projectionOptions.withUserActivation: If true, the user activation will be included in the result, optional
+     * Sort options:
+     * - params.sortOptions.sortField: The sort field, optional. If not provided, it will be set to 'userActivationDevice.id'
+     * @returns The last activation device
+     */
+    async getLastActivationDevice(params) {
+        this.logger.trace(params, 'UserActivationsRepository::getLastActivationDevice started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getLastActivationDevice(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserActivationsRepository::getLastActivationDevice result');
+        return result;
+    }
+    /**
+     * Update user activation device
+     * @param {UpdateUserActivationDeviceParams} params containing information to update user activation device
+     * Filters:
+     * - params.filters.imei: The user activation device imei, required
+     * Values:
+     * At least one of the values is required
+     * - params.values.trackingReason: The tracking reason, optional
+     * - params.values.deviceName: The device name, optional
+     * - params.values.deviceColor: The device color, optional
+     * - params.values.planAnnual: The plan annual, optional
+     * - params.values.subscriptionId: The subscription id, optional
+     * - params.values.platform: The platform, optional
+     * @returns True if the user activation device was updated, false otherwise
+     */
+    async updateUserActivationDevice(params) {
+        this.logger.trace(params, 'UserActivationsRepository::updateUserActivationDevice started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateUserActivationDevice(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserActivationsRepository::updateUserActivationDevice result');
+        return result;
+    }
+    /**
+     * Get user activation metrics
+     * @param {GetUserActivationMetricsParams} params containing information to get user activation metrics
+     * Filters:
+     * - params.filters.userId: The user id, required
+     * @returns The user activation metrics
+     */
+    async getUserActivationMetrics(params) {
+        this.logger.trace(params, 'UserActivationsRepository::getUserActivationMetrics started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserActivationMetrics(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserActivationsRepository::getUserActivationMetrics result');
+        return result;
+    }
+    /**
+     * Update user activation metrics
+     * @param {UpdateUserActivationMetricsParams} params containing information to update user activation metrics
+     * Filters:
+     * - params.filters.userId: The user id, required
+     * Values: At least one of the values is required
+     * @returns True if the user activation metrics were updated, false otherwise
+     */
+    async updateUserActivationMetrics(params) {
+        this.logger.trace(params, 'UserActivationsRepository::updateUserActivationMetrics started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateUserActivationMetrics(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserActivationsRepository::updateUserActivationMetrics result');
+        return result;
+    }
+    /**
+     * Create user activation event
+     * @param {CreateUserActivationEventParams} params containing information to create a user activation event
+     * - params.userId: The user id, required
+     * - params.eventId: The event id, required
+     * - params.eventName: The event name, required
+     * - params.eventValue: The event value, optional
+     * - params.eventMetadata: The event metadata, optional
+     * - params.platform: The platform, optional
+     * - params.ip: The ip, optional
+     * - params.userAgent: The user agent, optional
+     * @returns The created user activation event
+     */
+    async createUserActivationEvent(params) {
+        this.logger.trace(params, 'UserActivationsRepository::createUserActivationEvent started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserActivationEvent(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserActivationsRepository::createUserActivationEvent result');
+        return result;
+    }
+    /**
+     * Create user activation metric
+     * @param {CreateUserActivationMetricParams} params containing information to create a user activation metric
+     * - params.id: The user activation metric id, optional. If not provided, it will be generated
+     * - params.userId: The user id, required
+     * - params.firstName: The first name, required
+     * - params.lastName: The last name, required
+     * - params.email: The email, required
+     * - params.phone: The phone, optional
+     * @returns The created user activation metric
+     */
+    async createUserActivationMetric(params) {
+        this.logger.trace(params, 'UserActivationsRepository::createUserActivationMetric started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserActivationMetric(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserActivationsRepository::createUserActivationMetric result');
+        return result;
+    }
+}

package/dist/repositories/userActivations/updateUserActivationDevice.js

@@ -0,0 +1,39 @@
+import { UserActivationDevice } from '../../entities';
+export const updateUserActivationDevice = async (novaDataSource, params, logger) => {
+    // at least one filter is required
+    if (!params?.filters?.imei && !params?.filters?.id) {
+        logger.warn({ params }, 'UserActivationsRepository::updateUserActivationDevice - missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (!params?.values?.trackingReason &&
+        !params?.values?.deviceName &&
+        !params?.values?.deviceColor &&
+        params?.values?.planAnnual == null &&
+        !params?.values?.subscriptionId &&
+        !params?.values?.platform &&
+        !params?.values?.model &&
+        !params?.values?.servicePlan) {
+        logger.warn({ params }, 'UserActivationsRepository::updateUserActivationDevice - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationDevicessRepository = dataSource.getRepository(UserActivationDevice);
+        const now = new Date();
+        let queryBuilder = userActivationDevicessRepository
+            .createQueryBuilder()
+            .update(UserActivationDevice)
+            .set({
+            ...params.values,
+            modifiedAt: now,
+        });
+        if (params.filters.imei) {
+            queryBuilder = queryBuilder.where('imei = :imei', { imei: params.filters.imei });
+        }
+        if (params.filters.id) {
+            queryBuilder = queryBuilder.andWhere('id = :id', { id: params.filters.id });
+        }
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserActivationsRepository::updateUserActivationDevice');
+};

package/dist/repositories/userActivations/updateUserActivationMetrics.js

@@ -0,0 +1,61 @@
+import { UserActivationMetric } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateUserActivationMetrics = async (novaDataSource, params, logger) => {
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    // at least one filter is required
+    if (!binaryBuffer) {
+        logger.warn({ params }, 'UserActivationsRepository::UpdateUserActivationMetrics - missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (!params?.values?.firstName &&
+        !params?.values?.lastName &&
+        !params?.values?.email &&
+        !params?.values?.phone &&
+        !params?.values?.trackingReason &&
+        !params?.values?.companyName &&
+        !params?.values?.role &&
+        !params?.values?.industry &&
+        !params?.values?.devicesActivatingCategory &&
+        !params?.values?.assetsCountRange &&
+        !params?.values?.devicesActivatingCount &&
+        !params?.values?.plan &&
+        !params?.values?.usersInvitedCount &&
+        params?.values?.meetingScheduled == null &&
+        !params?.values?.planAnnual &&
+        !params?.values?.planId &&
+        !params?.values?.spyEnvironment &&
+        !params?.values?.jarvisScore &&
+        !params?.values?.enrichmentCompanyDescription &&
+        !params?.values?.jarvisEnrichmentCompanyEin &&
+        !params?.values?.enrichmentCompanyEmployees &&
+        !params?.values?.enrichmentCompanyIndustry &&
+        !params?.values?.enrichmentCompanyLocation &&
+        !params?.values?.enrichmentCompanyName &&
+        !params?.values?.enrichmentCompanyRevenue &&
+        !params?.values?.enrichmentPrivateDomain &&
+        !params?.values?.enrichmentPublicTicker &&
+        !params?.values?.enrichmentRole &&
+        !params?.values?.enrichmentTags &&
+        !params?.values?.jenrichmentTitle &&
+        !params?.values?.enrichmentVerifiedEmployment) {
+        logger.warn({ params }, 'UserActivationsRepository::UpdateUserActivationMetrics - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userActivationMetricsRepository = dataSource.getRepository(UserActivationMetric);
+        const now = new Date();
+        let queryBuilder = userActivationMetricsRepository
+            .createQueryBuilder()
+            .update(UserActivationMetric)
+            .set({
+            ...params.values,
+            modifiedAt: now,
+        });
+        if (binaryBuffer) {
+            queryBuilder = queryBuilder.andWhere('userId = :userId', { userId: binaryBuffer });
+        }
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserActivationsRepository::UpdateUserActivationMetrics');
+};

package/dist/repositories/userAppFeedback/createUserAppFeedback.js

@@ -0,0 +1,26 @@
+import { UserAppFeedback } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserAppFeedback = async (novaDataSource, params, logger) => {
+    if (!params?.userId || !params?.platform || !params?.appVersion) {
+        logger.warn({ params }, 'UserAppFeedbackRepository::createUserAppFeedback - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ userId: params?.userId }, 'UserAppFeedbackRepository::createUserAppFeedback - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAppFeedbackRepository = dataSource.getRepository(UserAppFeedback);
+        const newUserAppFeedback = {
+            id: params.id,
+            userId: userIdBinaryBuffer,
+            platform: params.platform,
+            appVersion: params.appVersion,
+            feedback: params.feedback,
+            amazonReviewDate: params.amazonReviewDate,
+            createdAt: new Date(),
+        };
+        return await userAppFeedbackRepository.save(newUserAppFeedback);
+    }, 'UserAppFeedbackRepository::createUserAppFeedback');
+};

package/dist/repositories/userAppFeedback/index.js

@@ -0,0 +1,23 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createUserAppFeedback } from './createUserAppFeedback';
+export class UserAppFeedbackRepository extends BaseRepository {
+    /**
+     * Creates a new user app feedback record
+     * @param {CreateUserAppFeedbackParams} params containing information to create a user app feedback record
+     * - params.id: The user app feedback id, optional
+     * - params.userId: The user id, required
+     * - params.platform: The platform, required
+     * - params.appVersion: The app version, required
+     * - params.feedback: The feedback, optional
+     * - params.amazonReviewDate: The amazon review date, optional
+     * @returns The created user app feedback record
+     */
+    async createUserAppFeedback(params) {
+        this.logger.trace(params, 'UserAppFeedbackRepository::createUserAppFeedback started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserAppFeedback(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserAppFeedbackRepository::createUserAppFeedback result');
+        return result;
+    }
+}

package/dist/repositories/userAppIncidents/getUserAppIncidents.js

@@ -0,0 +1,28 @@
+import { UserAppIncident } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserAppIncidents = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'UserAppIncidentsRepository::getUserAppIncidents - missing required parameters');
+        return [];
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params.filters.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserAppIncidentsRepository::getUserAppIncidents - userId is not a valid UUID');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAppIncidentsRepository = dataSource.getRepository(UserAppIncident);
+        const queryBuilder = userAppIncidentsRepository
+            .createQueryBuilder('userAppIncident')
+            .where('userAppIncident.userId = :userId', {
+            userId: userIdBinaryBuffer,
+        })
+            .andWhere('userAppIncident.createdAt between :createdFrom and :createdTo', {
+            createdFrom: params.filters.createdFrom,
+            createdTo: params.filters.createdTo,
+        })
+            .orderBy('userAppIncident.createdAt', 'DESC');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserAppIncidentsRepository::getUserAppIncidents');
+};

package/dist/repositories/userAppIncidents/index.js

@@ -0,0 +1,63 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { getUserAppIncidents } from './getUserAppIncidents';
+import { upsertUserAppIncident } from './upsertUserAppIncident';
+export class UserAppIncidentsRepository extends BaseRepository {
+    /**
+     * Get user app incidents
+     * @param {GetUserAppIncidentsParams} params containing information to get user app incidents
+     * Filters:
+     * filters.userId: user id, required
+     * filters.createdFrom: created from date, required
+     * filters.createdTo: created to date, required
+     * @returns {Promise<UserAppIncident[]>} user app incidents
+     */
+    async getUserAppIncidents(params) {
+        this.logger.trace(params, 'UserAppIncidentsRepository::getUserAppIncidents started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserAppIncidents(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserAppIncidentsRepository::getUserAppIncidents result');
+        return result;
+    }
+    /**
+     * Upsert user app incident
+     * @param {UpsertUserAppIncidentParams} params containing information to insert or update an user app incident
+     * If no user app incident exist with the same user id and error id, a new user app incident will be inserted.
+     * Otherwise, the existing user app incident will be updated.
+     * Filters:
+     * params.id: user app incident id, optional. If not provided, a new id will be generated.
+     * params.userId: user id, required
+     * params.deviceOs: device os, required
+     * params.stage: stage, required
+     * params.appVersion: app version, required
+     * params.errorId: error id, required
+     * params.userName: user name, optional
+     * params.userEmail: user email, optional
+     * params.deviceManufacturer: device manufacturer, optional
+     * params.deviceModel: device model, optional
+     * params.appVersion: app version, optional
+     * params.errorMessage: error message, optional
+     * params.errorFirstReceivedAt: when the error was first received, optional
+     * params.errorReceivedAt: when the error was received, optional
+     * params.deviceJailbroken: whether the device is jailbroken, optional
+     * params.deviceOsVersion: device os version, optional
+     * params.deviceFreeMemory: device free memory, optional
+     * params.deviceTotalMemory: device total memory, optional
+     * params.deviceCharging: whether the device is charging, optional
+     * params.deviceBatteryLevel: device battery level, optional
+     * params.deviceNetworkAccess: device network access, optional
+     * params.appActiveScreen: app active screen, optional
+     * params.appInForeground: whether the app is in foreground, optional
+     * params.appDurationInForeground: app duration in foreground, optional
+     * params.appBundleId: app bundle id, optional
+     * params.incidentUrl: incident url, optional
+     * @returns {Promise<boolean>} true if user app incident was upserted, false otherwise
+     */
+    async upsertUserAppIncident(params) {
+        this.logger.trace(params, 'UserAppIncidentsRepository::upsertUserAppIncident started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await upsertUserAppIncident(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserAppIncidentsRepository::upsertUserAppIncident result');
+        return result;
+    }
+}

package/dist/repositories/userAppIncidents/upsertUserAppIncident.js

@@ -0,0 +1,53 @@
+import { UserAppIncident } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const upsertUserAppIncident = async (novaDataSource, params, logger) => {
+    if (!params?.userId ||
+        !params.deviceOs ||
+        !params.stage ||
+        !params.appVersion ||
+        !params?.errorId) {
+        logger.warn({ params }, 'UserAppIncidentsRepository::upsertUserAppIncident - missing required parameters');
+        return false;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'UserAppIncidentsRepository::upsertUserAppIncident - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAppIncidentsRepository = dataSource.getRepository(UserAppIncident);
+        const now = new Date();
+        const userAppIncident = {
+            id: params.id,
+            userId: binaryBuffer,
+            userName: params.userName,
+            userEmail: params.userEmail,
+            deviceOs: params.deviceOs,
+            deviceManufacturer: params.deviceManufacturer,
+            deviceModel: params.deviceModel,
+            stage: params.stage,
+            appVersion: params.appVersion,
+            errorMessage: params.errorMessage,
+            errorFirstReceivedAt: params.errorFirstReceivedAt,
+            errorReceivedAt: params.errorReceivedAt,
+            deviceJailbroken: params.deviceJailbroken,
+            deviceOsVersion: params.deviceOsVersion,
+            deviceFreeMemory: params.deviceFreeMemory,
+            deviceTotalMemory: params.deviceTotalMemory,
+            deviceCharging: params.deviceCharging,
+            deviceBatteryLevel: params.deviceBatteryLevel,
+            deviceNetworkAccess: params.deviceNetworkAccess,
+            appActiveScreen: params.appActiveScreen,
+            appInForeground: params.appInForeground,
+            appDurationInForeground: params.appDurationInForeground,
+            appBundleId: params.appBundleId,
+            incidentUrl: params.incidentUrl,
+            errorId: params.errorId,
+            createdAt: now,
+        };
+        const result = await userAppIncidentsRepository.upsert(userAppIncident, {
+            conflictPaths: ['userId', 'errorId'],
+        });
+        return result?.raw?.affectedRows > 0;
+    }, 'UserAppIncidentsRepository::upsertUserAppIncident');
+};

package/dist/repositories/userConfigurations/bulkCreateUserAlertConfigurations.js

@@ -0,0 +1,46 @@
+import { UserAlertConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const bulkCreateUserAlertConfigurations = async (novaDataSource, params, logger) => {
+    if (!params?.alertConfigurations?.length) {
+        logger.warn({ params }, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAlertConfigurationsRepository = dataSource.getRepository(UserAlertConfiguration);
+        const userAlertConfigurationsToCreate = [];
+        for (const createUserAlertConfigurationParams of params.alertConfigurations) {
+            if (!createUserAlertConfigurationParams?.userId ||
+                !createUserAlertConfigurationParams?.alertTypeId) {
+                logger.warn(createUserAlertConfigurationParams, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations - User alert configuration could not be created: missing required parameters');
+                return false;
+            }
+            const userIdBinaryBuffer = uuidStringToBinaryBuffer(createUserAlertConfigurationParams?.userId);
+            if (!userIdBinaryBuffer?.length) {
+                logger.warn(createUserAlertConfigurationParams, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations - User alert configuration could not be created: user id should be a valid UUID');
+                return false;
+            }
+            const newUserAlertConfiguration = {
+                id: createUserAlertConfigurationParams?.id,
+                userId: userIdBinaryBuffer,
+                alertTypeId: createUserAlertConfigurationParams?.alertTypeId,
+                smsNotification: createUserAlertConfigurationParams?.smsNotification,
+                emailNotification: createUserAlertConfigurationParams?.emailNotification,
+                appNotification: createUserAlertConfigurationParams?.appNotification,
+                pushNotification: createUserAlertConfigurationParams?.pushNotification,
+                alertValue: createUserAlertConfigurationParams?.alertValue,
+                alertMetadata: createUserAlertConfigurationParams?.alertMetadata,
+            };
+            userAlertConfigurationsToCreate.push(newUserAlertConfiguration);
+        }
+        if (!userAlertConfigurationsToCreate.length) {
+            return false;
+        }
+        const result = await userAlertConfigurationsRepository
+            .createQueryBuilder()
+            .insert()
+            .into(UserAlertConfiguration)
+            .values(userAlertConfigurationsToCreate)
+            .execute();
+        return result.identifiers.length === userAlertConfigurationsToCreate.length;
+    }, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations');
+};

package/dist/repositories/userConfigurations/createDeviceAlertTimeWindows.js

@@ -0,0 +1,36 @@
+import { DeviceAlertConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createDeviceAlertTimeWindows = async (novaDataSource, params, logger) => {
+    if (!params?.userId ||
+        !params?.clientId ||
+        !params?.alertTypeId ||
+        !params?.daysOfTheWeek ||
+        !params.startTime ||
+        !params.endTime ||
+        !params.imei) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createDeviceAlertTimeWindows - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createDeviceAlertTimeWindows - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(DeviceAlertConfiguration);
+        const newAlertTimeWindowsConfig = {
+            id: params?.id ?? null,
+            alertTypeId: params?.alertTypeId,
+            clientId: params?.clientId,
+            userId: userIdBinaryBuffer,
+            daysOfTheWeek: params?.daysOfTheWeek,
+            startTime: params?.startTime,
+            endTime: params?.endTime,
+            alertConfigurationId: params?.alertConfigurationId ?? null,
+            filter: params?.filter ?? null,
+            imei: params?.imei,
+            label: params?.label ?? null,
+        };
+        return await userConfigurationsRepository.save(newAlertTimeWindowsConfig);
+    }, 'UserConfigurationsRepository::createDeviceAlertTimeWindows');
+};

package/dist/repositories/userConfigurations/createUserAlertTimeWindows.js

@@ -0,0 +1,33 @@
+import { AlertTimeWindowConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserAlertTimeWindows = async (novaDataSource, params, logger) => {
+    if (!params?.userId ||
+        !params?.clientId ||
+        !params?.alertTypeId ||
+        !params?.daysOfTheWeek ||
+        !params.startTime ||
+        !params.endTime) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createUserAlertTimeWindows - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createUserAlertTimeWindows - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(AlertTimeWindowConfiguration);
+        const newAlertTimeWindowsConfig = {
+            id: params?.id ?? null,
+            alertId: params?.alertTypeId,
+            clientId: params?.clientId,
+            userId: userIdBinaryBuffer,
+            daysOfTheWeek: params?.daysOfTheWeek,
+            startTime: params?.startTime,
+            endTime: params?.endTime,
+            alertConfigurationId: params?.alertConfigurationId ?? null,
+            label: params?.label ?? null,
+        };
+        return await userConfigurationsRepository.save(newAlertTimeWindowsConfig);
+    }, 'UserConfigurationsRepository::createUserAlertTimeWindows');
+};