@spytecgps/nova-orm 1.3.11-rc4 → 1.3.11

package/dist/logger-7bbP0aeT.js

@@ -1,11 +0,0 @@
-'use strict';
-
-exports.LogLevel = void 0;
-(function (LogLevel) {
-    LogLevel["FATAL"] = "fatal";
-    LogLevel["ERROR"] = "error";
-    LogLevel["WARN"] = "warn";
-    LogLevel["INFO"] = "info";
-    LogLevel["DEBUG"] = "debug";
-    LogLevel["TRACE"] = "trace";
-})(exports.LogLevel || (exports.LogLevel = {}));

package/dist/novaDataSource.js

@@ -1,293 +0,0 @@
-'use strict';
-
-var typeorm = require('typeorm');
-var index = require('./index-BHDlCHC_.js');
-require('./enums-vPEcKjNp.js');
-require('uuid');
-require('./logger-7bbP0aeT.js');
-
-const entitiesToLogErrorOnDelete = ['Device', 'Billing'];
-let AllEntitiesSubscriber = class AllEntitiesSubscriber {
-    // TODO: We need to put back these logs but using the logger instead of the console log
-    /**
-     * Called after entity insertion.
-     */
-    // afterInsert(event: InsertEvent<any>) {
-    //   console.debug(`AFTER ENTITY INSERTED: `, event.entity)
-    // }
-    /**
-     * Called after entity update.
-     */
-    // afterUpdate(event: UpdateEvent<any>) {
-    //   console.debug(`AFTER ENTITY UPDATED: `, {
-    //     entity: event.entity,
-    //     databaseEntity: event.databaseEntity,
-    //   })
-    // }
-    /**
-     * Called after entity removal.
-     */
-    afterRemove(event) {
-        const entityType = event.metadata.name;
-        const logError = entitiesToLogErrorOnDelete.includes(entityType);
-        const message = `ENTITY OF TYPE ${entityType} REMOVED`;
-        if (logError) {
-            console.error(message, {
-                entityId: event.entityId,
-                entity: event.entity,
-                databaseEntity: event.databaseEntity,
-            });
-        }
-        // else {
-        //   console.warn(message, {
-        //     entityId: event.entityId,
-        //     entity: event.entity,
-        //     databaseEntity: event.databaseEntity,
-        //   })
-        // }
-    }
-};
-AllEntitiesSubscriber = index.__decorate([
-    typeorm.EventSubscriber()
-], AllEntitiesSubscriber);
-
-var Subscribers = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get AllEntitiesSubscriber () { return AllEntitiesSubscriber; }
-});
-
-const queriesToIgnore = ['commit', 'start transaction', 'select version()'];
-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:`);
-        }
-    }
-}
-
-class NovaDataSource {
-    dataSource;
-    logger;
-    constructor(config, logger, replicaConfig) {
-        this.logger = logger;
-        const entities = [];
-        for (const key in index.Entities) {
-            const entity = index.Entities[key];
-            entities.push(entity);
-        }
-        const subscribers = [];
-        for (const key in Subscribers) {
-            const subscriber = Subscribers[key];
-            subscribers.push(subscriber);
-        }
-        const baseConfig = {
-            host: 'aws.connect.psdb.cloud',
-            port: 3306,
-            database: 'nova',
-            ssl: {
-                rejectUnauthorized: true,
-            },
-        };
-        this.dataSource = new typeorm.DataSource({
-            type: 'mysql',
-            connectorPackage: 'mysql2',
-            synchronize: false,
-            logging: true,
-            logger: new QueryLogger(this.logger, config.logging),
-            entities,
-            subscribers,
-            supportBigNumbers: true,
-            bigNumberStrings: false,
-            extra: {
-                decimalNumbers: true,
-            },
-            ...baseConfig,
-            ...config,
-            replication: {
-                master: {
-                    ...baseConfig,
-                    ...config,
-                },
-                slaves: replicaConfig
-                    ? [
-                        {
-                            ...baseConfig,
-                            ...replicaConfig,
-                        },
-                    ]
-                    : [
-                        {
-                            ...baseConfig,
-                            ...config,
-                        },
-                    ],
-                defaultMode: config.replicationMode ?? 'master',
-            },
-        });
-    }
-    /**
-     * Performs connection to the database.
-     */
-    async connect() {
-        if (!this.dataSource.isInitialized) {
-            await this.dataSource.initialize();
-        }
-    }
-    /**
-     * Closes connection with the database.
-     * Once connection is closed, you cannot use repositories or perform any operations except opening connection again.
-     */
-    async disconnect() {
-        try {
-            if (this.dataSource.isInitialized) {
-                await this.dataSource.destroy();
-            }
-        }
-        catch (error) {
-            this.logger.error({ error }, 'Failed to close connection to database');
-        }
-    }
-    /**
-     * Gets repository for the given entity.
-     */
-    getRepository(target) {
-        return this.dataSource.getRepository(target);
-    }
-    /**
-     * Executes raw SQL query and returns raw database results.
-     */
-    async query(query, parameters) {
-        return this.dataSource.query(query, parameters, null);
-    }
-    /**
-     * Creates a new query builder that can be used to build a SQL query.
-     */
-    async createQueryBuilder(entityClass, alias) {
-        return this.dataSource.createQueryBuilder(entityClass, alias, null);
-    }
-    /**
-     * Creates a query runner used for perform queries on a single database connection.
-     * Using query runners you can control your queries to execute using single database connection and
-     * manually control your database transaction.
-     *
-     * Mode is used in replication mode and indicates whatever you want to connect
-     * to master database or any of slave databases.
-     * If you perform writes you must use master database,
-     * if you perform reads you can use slave databases.
-     */
-    createQueryRunner(mode) {
-        return this.dataSource.createQueryRunner(mode);
-    }
-    createQueryRunnerFromParams(params) {
-        const replicationMode = params?.queryOptions?.forceUseReplica ? 'slave' : 'master';
-        this.logger.trace({ replicationMode }, 'Creating query runner with replication mode');
-        return this.dataSource.createQueryRunner(replicationMode);
-    }
-    async safeQuery(queryBuilderHandler, tag, queryRunner) {
-        try {
-            await this.connect();
-            const result = await queryBuilderHandler(this, queryRunner);
-            return result;
-        }
-        catch (error) {
-            this.logger.error({ error }, tag ? tag + ' ' : '' + 'Error while executing query');
-            throw error;
-        }
-        finally {
-            if (queryRunner) {
-                await queryRunner.release();
-            }
-            await this.disconnect();
-        }
-    }
-    async safeQuery2(queryBuilderHandler, tag, queryRunner) {
-        try {
-            if (!this.dataSource.isInitialized) {
-                this.logger.info('nova-orm new connection');
-                await this.connect();
-            }
-            else {
-                this.logger.info('nova-orm reusing connection');
-            }
-            const result = await queryBuilderHandler(this, queryRunner);
-            return result;
-        }
-        catch (error) {
-            this.logger.error({ error }, tag ? tag + ' ' : '' + 'Error while executing query');
-            throw error;
-        }
-        finally {
-            if (queryRunner) {
-                await queryRunner.release();
-            }
-        }
-    }
-    async safeQuery3(target, alias, 
-    // eslint-disable-next-line no-unused-vars
-    callback, { replicationMode = 'slave', tag } = {}) {
-        let queryRunner;
-        try {
-            await this.connect();
-            queryRunner = this.dataSource.createQueryRunner(replicationMode);
-            const queryBuilder = this.dataSource.createQueryBuilder(target, alias, queryRunner);
-            const result = await callback(queryBuilder);
-            return result;
-        }
-        catch (error) {
-            this.logger.error({ error }, tag ? tag + ' ' : '' + 'Error while executing query');
-            throw error;
-        }
-        finally {
-            if (queryRunner) {
-                await queryRunner.release();
-            }
-        }
-    }
-    async syncSchema(dropBeforeSync = true) {
-        this.logger.warn('Initiating schema sync');
-        await this.connect();
-        await this.dataSource.synchronize(dropBeforeSync);
-    }
-}
-
-exports.NovaDataSource = NovaDataSource;

package/dist/repos.d.ts

@@ -1,2 +0,0 @@
-import * as Repositories from './repositories';
-export { Repositories };