@spytecgps/nova-orm 0.0.3 → 0.0.5

package/dist/repositories/devicesRepository.js

@@ -0,0 +1,122 @@
+// import { logger } from '@spytecgps/sdk'
+import { Device, DeviceType, ImeiIccidCarrier } from '../entities';
+import { NovaDataSource } from '../novaDataSource';
+import { DeviceStatus } from '../types/enums';
+import { BaseRepository } from './baseRepository';
+export class DevicesRepository extends BaseRepository {
+    /**
+     * Get device by imei
+     * @param  {string} imei The imei of the device
+     */
+    async getDeviceByImei(imei, options) {
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig);
+        try {
+            await novaDataSource.connect();
+            const devicesRepository = novaDataSource.getRepository(Device);
+            let device = null;
+            if (!options.withDeviceType && !options.withIccidCarrier) {
+                device = await devicesRepository.findOne({ where: { imei } });
+            }
+            else {
+                let queryBuilder = devicesRepository.createQueryBuilder('device');
+                if (options.withDeviceType) {
+                    queryBuilder = queryBuilder.leftJoinAndMapOne('device.deviceType', DeviceType, 'deviceType', 'device.deviceTypeId = deviceType.id');
+                }
+                if (options.withIccidCarrier) {
+                    queryBuilder = queryBuilder.leftJoinAndMapOne('device.iccidCarrier', ImeiIccidCarrier, 'iccidCarrier', 'device.imei = iccidCarrier.imei');
+                }
+                device = await queryBuilder.where('device.imei = :imei', { imei }).getOne();
+            }
+            return device;
+        }
+        catch (error) {
+            // TODO: Add logger
+            // logger.error({ error }, 'DevicesRepository::getDeviceByImei error')
+            throw error;
+        }
+        finally {
+            await novaDataSource.disconnect();
+        }
+    }
+    /**
+     * Get devices by type id
+     * @param  {number} deviceTypeId The device type id
+     * @param  {boolean} onlyActiveDevices Whether to get only active devices
+     */
+    async getDevicesByDeviceTypeId(deviceTypeId, onlyActiveDevices, options) {
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig);
+        try {
+            await novaDataSource.connect();
+            const devicesRepository = novaDataSource.getRepository(Device);
+            let devices = null;
+            if (!options.withDeviceType && !options.withIccidCarrier) {
+                const filterCondition = onlyActiveDevices
+                    ? { where: { deviceTypeId, status: DeviceStatus.Active } }
+                    : {
+                        where: { deviceTypeId },
+                    };
+                devices = await devicesRepository.find(filterCondition);
+            }
+            else {
+                let queryBuilder = devicesRepository.createQueryBuilder('device');
+                if (options.withDeviceType) {
+                    queryBuilder = queryBuilder.leftJoinAndMapOne('device.deviceType', DeviceType, 'deviceType', 'device.deviceTypeId = deviceType.id');
+                }
+                if (options.withIccidCarrier) {
+                    queryBuilder = queryBuilder.leftJoinAndMapOne('device.iccidCarrier', ImeiIccidCarrier, 'iccidCarrier', 'device.imei = iccidCarrier.imei');
+                }
+                queryBuilder = queryBuilder.where('device.deviceTypeId = :deviceTypeId', { deviceTypeId });
+                if (onlyActiveDevices) {
+                    queryBuilder = queryBuilder.andWhere('device.status = :status', {
+                        status: DeviceStatus.Active,
+                    });
+                }
+                devices = await queryBuilder.getMany();
+            }
+            return devices;
+        }
+        catch (error) {
+            // TODO: Add logger
+            // logger.error({ error }, 'DevicesRepository::getDeviceByImei error')
+            throw error;
+        }
+        finally {
+            await novaDataSource.disconnect();
+        }
+    }
+    /**
+     * Get device types
+     * @param  {boolean} onlyWithRelatedIccidCarrier Whether to get only device types with iccid carrier
+     */
+    async getDeviceTypes(onlyWithRelatedIccidCarrier) {
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig);
+        try {
+            await novaDataSource.connect();
+            const deviceTypesRepository = novaDataSource.getRepository(DeviceType);
+            let deviceTypes = null;
+            if (!onlyWithRelatedIccidCarrier) {
+                deviceTypes = await deviceTypesRepository
+                    .createQueryBuilder('deviceType')
+                    .orderBy('deviceType.id')
+                    .getMany();
+            }
+            else {
+                deviceTypes = await deviceTypesRepository
+                    .createQueryBuilder('deviceType')
+                    .innerJoin(ImeiIccidCarrier, 'iccidCarrier', 'deviceType.id = iccidCarrier.deviceTypeId')
+                    .groupBy('deviceType.id')
+                    .orderBy('deviceType.id')
+                    .getMany();
+            }
+            return deviceTypes;
+        }
+        catch (error) {
+            // TODO: Add logger
+            // logger.error({ error }, 'DevicesRepository::getDeviceTypes error')
+            throw error;
+        }
+        finally {
+            await novaDataSource.disconnect();
+        }
+    }
+}

package/dist/repositories/index.d.ts

@@ -0,0 +1,3 @@
+import { DevicesRepository } from './devicesRepository';
+import { SecurityRepository } from './securityRepository';
+export { SecurityRepository, DevicesRepository };

package/dist/repositories/index.js

@@ -0,0 +1,3 @@
+import { DevicesRepository } from './devicesRepository';
+import { SecurityRepository } from './securityRepository';
+export { SecurityRepository, DevicesRepository };

package/dist/repositories/securityRepository.d.ts

@@ -0,0 +1,21 @@
+import { SecurityRole, UserSecurityRole } from '../entities';
+import { HapnSecurityRole } from '../types/enums';
+import { BaseRepository } from './baseRepository';
+export declare class SecurityRepository extends BaseRepository {
+    /**
+     * Get all security roles
+     */
+    getAllRoles(): Promise<SecurityRole[]>;
+    /**
+     * Get roles of the user
+     */
+    getUserRoles(userId: string): Promise<UserSecurityRole[]>;
+    /**
+     * Get user roles by clientId
+     */
+    getUserRolesByClientId(clientId: number, filterRole?: HapnSecurityRole): Promise<UserSecurityRole[]>;
+    /**
+     * Whether the user is in role
+     */
+    isInRole(userId: string, role: HapnSecurityRole): Promise<boolean>;
+}

package/dist/repositories/securityRepository.js

@@ -0,0 +1,99 @@
+// import { logger } from '@spytecgps/sdk'
+import { SecurityRole, UserSecurityRole } from '../entities';
+import { NovaDataSource } from '../novaDataSource';
+import { uuidStringToBinaryBuffer } from '../utils/uuidHelpers';
+import { BaseRepository } from './baseRepository';
+export class SecurityRepository extends BaseRepository {
+    /**
+     * Get all security roles
+     */
+    async getAllRoles() {
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig);
+        try {
+            await novaDataSource.connect();
+            const rolesRepository = novaDataSource.getRepository(SecurityRole);
+            const roles = await rolesRepository.find();
+            return roles;
+        }
+        catch (error) {
+            // TODO: Add logger
+            // logger.error({ error }, 'SecurityRepository::getAllRoles error')
+            throw error;
+        }
+        finally {
+            await novaDataSource.disconnect();
+        }
+    }
+    /**
+     * Get roles of the user
+     */
+    async getUserRoles(userId) {
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig);
+        try {
+            await novaDataSource.connect();
+            const userSecurityRolesRepository = novaDataSource.getRepository(UserSecurityRole);
+            const userRoles = await userSecurityRolesRepository.find({
+                where: { userId: uuidStringToBinaryBuffer(userId) },
+            });
+            return userRoles;
+        }
+        catch (error) {
+            // TODO: Add logger
+            // logger.error({ error }, 'SecurityRepository::getUserRoles error')
+            throw error;
+        }
+        finally {
+            await novaDataSource.disconnect();
+        }
+    }
+    /**
+     * Get user roles by clientId
+     */
+    async getUserRolesByClientId(clientId, filterRole = null) {
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig);
+        try {
+            await novaDataSource.connect();
+            const userSecurityRolesRepository = novaDataSource.getRepository(UserSecurityRole);
+            const filterCondition = filterRole
+                ? { where: { clientId, securityRoleId: filterRole } }
+                : {
+                    where: { clientId },
+                };
+            const userRoles = await userSecurityRolesRepository.find(filterCondition);
+            return userRoles;
+        }
+        catch (error) {
+            // TODO: Add logger
+            // logger.error({ error }, 'SecurityRepository::getUserRolesByClientId error')
+            throw error;
+        }
+        finally {
+            await novaDataSource.disconnect();
+        }
+    }
+    /**
+     * Whether the user is in role
+     */
+    async isInRole(userId, role) {
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig);
+        try {
+            await novaDataSource.connect();
+            const userSecurityRolesRepository = novaDataSource.getRepository(UserSecurityRole);
+            const userRole = await userSecurityRolesRepository.findOne({
+                where: {
+                    userId: uuidStringToBinaryBuffer(userId),
+                    securityRoleId: role,
+                },
+            });
+            return userRole !== null;
+        }
+        catch (error) {
+            // TODO: Add logger
+            // logger.error({ error }, 'SecurityRepository::isAdmin error')
+            throw error;
+        }
+        finally {
+            await novaDataSource.disconnect();
+        }
+    }
+}

package/dist/types/enums.d.ts

@@ -0,0 +1,9 @@
+export declare enum HapnSecurityRole {
+    Admin = 1,
+    Collaborator = 2,
+    Owner = 3
+}
+export declare enum DeviceStatus {
+    Active = "A",
+    Deleted = "D"
+}

package/dist/types/enums.js

@@ -0,0 +1,11 @@
+export var HapnSecurityRole;
+(function (HapnSecurityRole) {
+    HapnSecurityRole[HapnSecurityRole["Admin"] = 1] = "Admin";
+    HapnSecurityRole[HapnSecurityRole["Collaborator"] = 2] = "Collaborator";
+    HapnSecurityRole[HapnSecurityRole["Owner"] = 3] = "Owner";
+})(HapnSecurityRole || (HapnSecurityRole = {}));
+export var DeviceStatus;
+(function (DeviceStatus) {
+    DeviceStatus["Active"] = "A";
+    DeviceStatus["Deleted"] = "D";
+})(DeviceStatus || (DeviceStatus = {}));

package/dist/utils/uuidHelpers.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare const uuidStringToBinaryBuffer: (uuidString: string) => Buffer;

package/dist/utils/uuidHelpers.js

@@ -0,0 +1,6 @@
+export const uuidStringToBinaryBuffer = (uuidString) => {
+    if (!uuidString) {
+        return null;
+    }
+    return Buffer.from(uuidString.replace(/-/g, ''), 'hex');
+};

package/package.json

@@ -1,44 +1,44 @@
 {
   "name": "@spytecgps/nova-orm",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "ORM with PlanetScale",
-  "main": "dist/index.js",
+  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "devDependencies": {
     "@types/jest": "^29.5.1",
-    "@types/node": "^18.15.11",
+    "@types/node": "^14.18.36",
     "@typescript-eslint/eslint-plugin": "^5.59.0",
     "@typescript-eslint/parser": "^5.59.0",
     "aws-sdk": "^2.877.0",
+    "axios": "^1.4.0",
     "eslint": "^8.38.0",
     "eslint-config-prettier": "^6.15.0",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-prettier": "^3.4.1",
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "jest": "^29.3.1",
-    "jest-junit": "^14.0.1",
+    "jest-junit": "^12.0.0",
     "prettier": "^1.19.1",
     "ts-jest": "^29.0.5",
     "ts-loader": "^9.4.1",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4",
-    "webpack-cli": "^5.0.2",
-    "webpack": "^5.80.0"
+    "typescript": "^4.9.5",
+    "webpack": "^5.72.0",
+    "webpack-cli": "^4.9.2"
   },
   "dependencies": {
-    "@spytecgps/sdk": "^0.5.97",
     "mysql2": "^3.2.3",
     "reflect-metadata": "^0.1.13",
     "typeorm": "0.3.15"
   },
   "scripts": {
-    "test": "jest --ci --runInBand --reporters=default --reporters=jest-junit --collectCoverage=true",
-    "start": "ts-node src/index.ts",
+    "prepare": "npm run build",
+    "test": "yarn jest --ci --runInBand --reporters=default --reporters=jest-junit --collectCoverage=true",
     "typeorm": "typeorm-ts-node-commonjs",
     "lint": "eslint \"./src/**\"",
     "lint-fix": "eslint \"./src/**\" --fix",
     "build-dev": "webpack --mode=development",
-    "build": "webpack --mode=production",
+    "build": "tsc",
     "schema-sync": "yarn typeorm schema:drop --dataSource ./data-source.ts & yarn typeorm schema:sync --dataSource ./data-source.ts"
   },
   "author": "Spytec",