@spytecgps/nova-orm 0.0.224 → 0.0.225

package/dist/utils/anyAttributeIsNull.js

@@ -0,0 +1,12 @@
+const findNestedValue = (params, attribute) => {
+    const keys = attribute.split('.');
+    let current = params;
+    for (const key of keys) {
+        if (current[key] == null) {
+            return null; // Property not found
+        }
+        current = current[key];
+    }
+    return current;
+};
+export const anyAttributeIsNull = (params, attributes) => !params || !attributes || attributes.some(attribute => findNestedValue(params, attribute) == null);

package/dist/utils/boolToNumberTransformer.js

@@ -0,0 +1,23 @@
+export class BoolToNumberTransformer {
+    // To db from typeorm
+    to(value) {
+        if (value === null) {
+            return null;
+        }
+        if (value === undefined) {
+            return undefined;
+        }
+        const res = value ? 1 : 0;
+        return res;
+    }
+    // From db to typeorm
+    from(value) {
+        if (value === null) {
+            return null;
+        }
+        if (value === undefined) {
+            return undefined;
+        }
+        return value == 1;
+    }
+}

package/dist/utils/consoleLogger.js

@@ -0,0 +1,42 @@
+import { LogLevel } from '../types/logger';
+export class ConsoleLogger {
+    fatal = (msgOrObj, msg, ...args) => {
+        this.log(LogLevel.FATAL, msgOrObj, msg, ...args);
+    };
+    error = (msgOrObj, msg, ...args) => {
+        this.log(LogLevel.FATAL, msgOrObj, msg, ...args);
+    };
+    warn = (msgOrObj, msg, ...args) => {
+        this.log(LogLevel.WARN, msgOrObj, msg, ...args);
+    };
+    info = (msgOrObj, msg, ...args) => {
+        this.log(LogLevel.INFO, msgOrObj, msg, ...args);
+    };
+    debug = (msgOrObj, msg, ...args) => {
+        this.log(LogLevel.DEBUG, msgOrObj, msg, ...args);
+    };
+    trace = (msgOrObj, msg, ...args) => {
+        this.log(LogLevel.TRACE, msgOrObj, msg, ...args);
+    };
+    log = (level, msgOrObj, msg, ...args) => {
+        switch (level) {
+            case LogLevel.FATAL:
+            case LogLevel.ERROR:
+                if (typeof msgOrObj === 'string') {
+                    console.error(msgOrObj, ...args);
+                }
+                else {
+                    console.error(msg, msgOrObj, ...args);
+                }
+                break;
+            default:
+                if (typeof msgOrObj === 'string') {
+                    console.log(msgOrObj, ...args);
+                }
+                else {
+                    console.log(msg, msgOrObj, ...args);
+                }
+                break;
+        }
+    };
+}

package/dist/utils/filterTools.js

@@ -0,0 +1,299 @@
+export const addFilters = (queryBuilder, filters, filterMapping, entityName) => {
+    if (!queryBuilder || !filters) {
+        return queryBuilder;
+    }
+    for (const filterMap of filterMapping) {
+        const filterField = filters[filterMap.filterName];
+        const targetFieldName = filterMap.targetFieldName;
+        if (filterField === undefined || !targetFieldName || !filterMap.comparisonOperator) {
+            continue;
+        }
+        if (filterField === null) {
+            queryBuilder = queryBuilder.andWhere(`${entityName}.${targetFieldName} IS NULL`);
+            continue;
+        }
+        switch (filterMap.comparisonOperator) {
+            case 'RANGE':
+                const minValue = filterField['minValue'];
+                const maxValue = filterField['maxValue'];
+                if (minValue != null) {
+                    queryBuilder = queryBuilder.andWhere(`${entityName}.${targetFieldName} >= :${targetFieldName}MinValue`, {
+                        [`${targetFieldName}MinValue`]: minValue,
+                    });
+                }
+                if (maxValue != null) {
+                    queryBuilder = queryBuilder.andWhere(`${entityName}.${targetFieldName} <= :${targetFieldName}MaxValue`, {
+                        [`${targetFieldName}MaxValue`]: maxValue,
+                    });
+                }
+                break;
+            case 'LIKE':
+                queryBuilder = queryBuilder.andWhere(`LOWER(${entityName}.${targetFieldName}) LIKE LOWER(:${targetFieldName})`, {
+                    [targetFieldName]: `%${filterField}%`,
+                });
+                break;
+            case '=':
+                queryBuilder = queryBuilder.andWhere(`${entityName}.${targetFieldName} = :${targetFieldName}`, {
+                    [targetFieldName]: filterField,
+                });
+                break;
+            case 'IN':
+                queryBuilder = queryBuilder.andWhere(`${entityName}.${targetFieldName} IN (:...${targetFieldName})`, {
+                    [targetFieldName]: filterField,
+                });
+                break;
+            default:
+                throw new Error(`Unknown comparison operator: ${filterMap.comparisonOperator}`);
+        }
+    }
+    return queryBuilder;
+};
+// This is a list of range filters that can be applied to the query
+// filterName should correspond to a field in the GetTaskSchedulesFilters
+// targetFieldName should correspond to a field in the TaskSchedule entity
+// fielad with comparisonOperator = 'range' should correspond with a field of type RangeFilter<number> or RangeFilter<Date>
+export const getTaskSchedulesFilterMapping = [
+    {
+        targetFieldName: 'clientId',
+        filterName: 'clientId',
+        comparisonOperator: '=',
+    },
+    {
+        targetFieldName: 'repeats',
+        filterName: 'repeats',
+        comparisonOperator: '=',
+    },
+    {
+        targetFieldName: 'createdBy',
+        filterName: 'createdBy',
+        comparisonOperator: '=',
+    },
+    {
+        targetFieldName: 'modifiedBy',
+        filterName: 'modifiedBy',
+        comparisonOperator: '=',
+    },
+    {
+        targetFieldName: 'deletedBy',
+        filterName: 'deletedBy',
+        comparisonOperator: '=',
+    },
+    {
+        targetFieldName: 'status',
+        filterName: 'statusList',
+        comparisonOperator: 'IN',
+    },
+    {
+        targetFieldName: 'title',
+        filterName: 'title',
+        comparisonOperator: 'LIKE',
+    },
+    {
+        targetFieldName: 'description',
+        filterName: 'description',
+        comparisonOperator: 'LIKE',
+    },
+    {
+        targetFieldName: 'notes',
+        filterName: 'notes',
+        comparisonOperator: 'LIKE',
+    },
+    {
+        targetFieldName: 'dueDate',
+        filterName: 'dueDateFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'dueOdometer',
+        filterName: 'dueOdometerFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'dueActiveHours',
+        filterName: 'dueActiveHoursFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'intervalDays',
+        filterName: 'intervalDaysFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'intervalStartDate',
+        filterName: 'intervalStartDateFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'intervalOdometer',
+        filterName: 'intervalOdometerFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'intervalStartingOdometer',
+        filterName: 'intervalStartingOdometerFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'intervalActiveHours',
+        filterName: 'intervalActiveHoursFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'intervalStartingActiveHours',
+        filterName: 'intervalStartingActiveHoursFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'createdAt',
+        filterName: 'createdAtFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'modifiedAt',
+        filterName: 'modifiedAtFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'deletedAt',
+        filterName: 'deletedAtFilter',
+        comparisonOperator: 'RANGE',
+    },
+];
+// This is a list of range filters that can be applied to the query
+// filterName should correspond to a field in the GetTasksFilters
+// targetFieldName should correspond to a field in the Task entity
+// fielad with comparisonOperator = 'range' should correspond with a field of type RangeFilter<number> or RangeFilter<Date>
+export const tasksFilterMapping = [
+    {
+        targetFieldName: 'id',
+        filterName: 'taskId',
+        comparisonOperator: '=',
+    },
+    {
+        targetFieldName: 'taskScheduleId',
+        filterName: 'taskScheduleId',
+        comparisonOperator: '=',
+    },
+    {
+        targetFieldName: 'imei',
+        filterName: 'imeiList',
+        comparisonOperator: 'IN',
+    },
+    {
+        targetFieldName: 'clientId',
+        filterName: 'clientId',
+        comparisonOperator: '=',
+    },
+    {
+        targetFieldName: 'dueDate',
+        filterName: 'dueDateFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'dueOdometer',
+        filterName: 'dueOdometerFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'dueActiveHours',
+        filterName: 'dueActiveHoursFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'startDate',
+        filterName: 'startDateFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'startingOdometer',
+        filterName: 'startingOdometerFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'startingActiveHours',
+        filterName: 'startingActiveHoursFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'status',
+        filterName: 'statusList',
+        comparisonOperator: 'IN',
+    },
+    {
+        targetFieldName: 'createdAt',
+        filterName: 'createdAtFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'pastDueAt',
+        filterName: 'pastDueAtFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'completedAt',
+        filterName: 'completedAtFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'completionNotes',
+        filterName: 'completionNotes',
+        comparisonOperator: 'LIKE',
+    },
+    {
+        targetFieldName: 'completionOdometer',
+        filterName: 'completionOdometerFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'completionActiveHours',
+        filterName: 'completionActiveHoursFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'completedBy',
+        filterName: 'completedBy',
+        comparisonOperator: 'LIKE',
+    },
+    {
+        targetFieldName: 'modifiedAt',
+        filterName: 'modifiedAtFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'modifiedBy',
+        filterName: 'modifiedBy',
+        comparisonOperator: 'LIKE',
+    },
+    {
+        targetFieldName: 'queuedAt',
+        filterName: 'queuedAtFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'predictedDueDate',
+        filterName: 'predictedDueDateFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'deletedAt',
+        filterName: 'deletedAtFilter',
+        comparisonOperator: 'RANGE',
+    },
+    {
+        targetFieldName: 'deletedBy',
+        filterName: 'deletedBy',
+        comparisonOperator: 'LIKE',
+    },
+];
+export const tasksFilterMappingWithSchedule = [
+    {
+        targetFieldName: 'title',
+        filterName: 'title',
+        comparisonOperator: 'LIKE',
+    },
+    {
+        targetFieldName: 'description',
+        filterName: 'description',
+        comparisonOperator: 'LIKE',
+    },
+];

package/dist/utils/mapRawEntityToEntity.js

@@ -0,0 +1,12 @@
+export const mapRawEntityToEntity = (rawEntity, columnsPrefix = '') => {
+    if (!rawEntity) {
+        return null;
+    }
+    const result = {};
+    Object.keys(rawEntity).forEach(property => {
+        const regex = new RegExp(`^${columnsPrefix}`);
+        const propertyName = property.replace(regex, ''); // Remove the prefix from the property name
+        result[propertyName] = rawEntity[property];
+    });
+    return result;
+};

package/dist/utils/queryLogger.js

@@ -0,0 +1,48 @@
+const queriesToIgnore = ['commit', 'start transaction', 'select version()'];
+export class QueryLogger {
+    logger;
+    logging;
+    constructor(logger, logging) {
+        this.logger = logger;
+        this.logging = logging != null ? logging : false;
+    }
+    logQuery(query, parameters, _queryRunner) {
+        try {
+            if (!this.logging || (this.logging instanceof Array && !this.logging.includes('query'))) {
+                return;
+            }
+            const lowerCaseQuery = query.toLowerCase();
+            for (const queryToIgnore of queriesToIgnore) {
+                if (lowerCaseQuery.includes(queryToIgnore)) {
+                    return;
+                }
+            }
+            this.logger?.trace({ query, parameters }, `SQL QUERY`);
+        }
+        catch { } // do nothing if logging fails
+    }
+    logQueryError(_error, _query, _parameters, _queryRunner) {
+        // no need to log errors, they are already logged by the repository
+        //this.logger?.error({ query, parameters, error }, `SQL QUERY WITH ERROR`)
+    }
+    logQuerySlow(time, query, parameters, _queryRunner) {
+        this.logger?.warn({ query, parameters, time: time }, `SQL QUERY SLOW`);
+    }
+    logSchemaBuild(message, _queryRunner) {
+        this.logger?.trace({ message }, `SQL SCHEMA BUILD`);
+    }
+    logMigration(message, _queryRunner) {
+        this.logger?.trace({ message }, `SQL MIGRATION: `);
+    }
+    log(level, message, _queryRunner) {
+        if (level === 'warn') {
+            this.logger?.warn({ message }, `SQL LOG:`);
+        }
+        else if (level === 'info') {
+            this.logger?.info({ message }, `SQL LOG:`);
+        }
+        else {
+            this.logger?.trace({ message }, `SQL LOG:`);
+        }
+    }
+}

package/dist/utils/randomizer.js

@@ -0,0 +1,39 @@
+export const getRandomBoolean = () => {
+    return Math.random() < 0.5;
+};
+export const getRandomInteger = (max) => {
+    return Math.floor(Math.random() * max) + 1;
+};
+export const getRandomString = (length) => {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        const randomIndex = Math.floor(Math.random() * charactersLength);
+        result += characters.charAt(randomIndex);
+    }
+    return result;
+};
+export const getRandomImei = (length = 15) => {
+    const characters = '0123456789';
+    let result = '';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        const randomIndex = Math.floor(Math.random() * charactersLength);
+        result += characters.charAt(randomIndex);
+    }
+    return result;
+};
+export const getRandomDateInRange = (rangeInDays) => {
+    // Get the current date
+    const currentDate = new Date();
+    // Calculate the minimum and maximum date
+    const minDate = new Date(currentDate);
+    minDate.setDate(currentDate.getDate() - rangeInDays);
+    const maxDate = new Date(currentDate);
+    maxDate.setDate(currentDate.getDate() + rangeInDays);
+    // Generate a random date within the specified range
+    const randomTimestamp = minDate.getTime() + Math.random() * (maxDate.getTime() - minDate.getTime());
+    const randomDate = new Date(randomTimestamp);
+    return randomDate;
+};

package/dist/utils/stringToDateTransformer.js

@@ -0,0 +1,16 @@
+export class StringToDateTransformer {
+    // To db from typeorm
+    to(value) {
+        if (!value) {
+            return null;
+        }
+        return value;
+    }
+    // From db to typeorm
+    from(value) {
+        if (!value) {
+            return null;
+        }
+        return new Date(value);
+    }
+}

package/dist/utils/uuidHelpers.js

@@ -0,0 +1,30 @@
+export const uuidStringToBinaryBuffer = (uuidString) => {
+    if (!uuidString) {
+        return null;
+    }
+    const guidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+    const match = guidRegex.test(uuidString);
+    if (!match) {
+        return null;
+    }
+    try {
+        return Buffer.from(uuidString.replace(/-/g, ''), 'hex');
+    }
+    catch (error) {
+        return null;
+    }
+};
+export const binaryBufferToUuidString = (buffer) => {
+    if (!buffer) {
+        return null;
+    }
+    const guidStringWithoutDashes = buffer.toString('hex');
+    const guidRegex = /^(\w{8})(\w{4})(\w{4})(\w{4})(\w{12})$/;
+    const match = guidRegex.exec(guidStringWithoutDashes);
+    if (match) {
+        return `${match[1]}-${match[2]}-${match[3]}-${match[4]}-${match[5]}`;
+    }
+    else {
+        return null;
+    }
+};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@spytecgps/nova-orm",
-  "version": "0.0.224",
+  "version": "0.0.225",
   "description": "ORM with PlanetScale",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "devDependencies": {
     "@types/jest": "^29.5.1",
-    "@types/node": "^14.18.36",
+    "@types/node": "^16",
     "@types/uuid": "^9.0.2",
     "@typescript-eslint/eslint-plugin": "^5.59.0",
     "@typescript-eslint/parser": "^5.59.0",
@@ -21,21 +21,22 @@
     "jest-junit": "^12.0.0",
     "prettier": "^1.19.1",
     "ts-jest": "^29.0.5",
-    "ts-loader": "^9.4.1",
+    "ts-loader": "^9.5.1",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.5",
     "webpack": "^5.72.0",
-    "webpack-cli": "^4.9.2"
+    "webpack-cli": "^4.9.2",
+    "webpack-node-externals": "^3.0.0",
+    "yarn": "^1.22.19"
   },
   "dependencies": {
     "mysql2": "^3.2.3",
     "reflect-metadata": "^0.1.13",
-    "typeorm": "0.3.11",
-    "yarn": "^1.22.19"
+    "typeorm": "0.3.19"
   },
   "scripts": {
     "prepare": "npm run build",
-    "test": "git update-index --skip-worktree test/utils/setEnvVars.ts && yarn jest --ci --runInBand --reporters=default --reporters=jest-junit --collectCoverage=true",
+    "test": "git update-index --skip-worktree test/utils/setEnvVars.ts && yarn jest --clearCache && yarn jest --ci --logHeapUsage --runInBand --reporters=default --reporters=jest-junit --collectCoverage=true",
     "typeorm": "typeorm-ts-node-commonjs",
     "lint": "eslint \"./src/**\"",
     "lint-fix": "eslint \"./src/**\" --fix",
@@ -43,7 +44,8 @@
     "build-dev": "webpack --mode=development",
     "build": "webpack --mode=production",
     "copydistfolder": "./scripts/copyDistFolder.sh",
-    "schema-sync": "git update-index --skip-worktree test/utils/setEnvVars.ts && yarn typeorm schema:drop --dataSource ./data-source.ts && yarn typeorm schema:sync --dataSource ./data-source.ts && yarn typeorm migration:run --dataSource ./data-source.ts"
+    "schema-sync": "git update-index --skip-worktree test/utils/setEnvVars.ts && yarn typeorm schema:drop --dataSource ./data-source.ts && yarn typeorm schema:sync --dataSource ./data-source.ts && yarn typeorm migration:run --dataSource ./data-source.ts",
+    "package-locally": "rimraf dist && tsc -p tsconfig.json && npm pack"
   },
   "author": "Spytec",
   "license": "ISC",

package/dist/index.js.LICENSE.txt

@@ -1,41 +0,0 @@
-/*!
- */
-
-/*! *****************************************************************************
-Copyright (C) Microsoft. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
-
-/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
-
-/**
-   * @license
-   * Copyright 2009 The Closure Library Authors
-   * Copyright 2020 Daniel Wirtz / The long.js Authors.
-   *
-   * Licensed under the Apache License, Version 2.0 (the "License");
-   * you may not use this file except in compliance with the License.
-   * You may obtain a copy of the License at
-   *
-   *     http://www.apache.org/licenses/LICENSE-2.0
-   *
-   * Unless required by applicable law or agreed to in writing, software
-   * distributed under the License is distributed on an "AS IS" BASIS,
-   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   * See the License for the specific language governing permissions and
-   * limitations under the License.
-   *
-   * SPDX-License-Identifier: Apache-2.0
-   */