implement SqliteAdapter.logger (#110)

* implement SqliteAdapter.logger

* use setLogLevel function

* 2.10.0

Author: kbarbounakis

jest.setup.js

@@ -1,6 +1,21 @@
 require('dotenv').config();
 const { JsonLogger } = require('@themost/json-logger');
 const { TraceUtils } = require('@themost/common');
+
+if (typeof JsonLogger.prototype.setLogLevel !== 'function') {
+    Object.assign(JsonLogger.prototype, {
+        /**
+         * @param {string} level
+         */
+        setLogLevel(level) {
+            const logLevel = [ 'error', 'warn', 'info', 'verbose', 'debug' ].indexOf(level);
+            if (logLevel > -1) {
+                this.level = logLevel;
+            }
+        }
+    })
+}
+
 process.env.NODE_ENV = 'development';
 TraceUtils.useLogger(new JsonLogger({
     format: 'raw'

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@themost/sqlite",
-  "version": "2.9.3",
+  "version": "2.10.0",
   "description": "MOST Web Framework SQLite Adapter",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package.json

@@ -3,7 +3,8 @@ import {DataApplication, DataConfigurationStrategy, DataCacheStrategy, DataConte
 import { createInstance } from '../src';
 
 const testConnectionOptions = {
-    'database': 'spec/db/local.db'
+    'database': 'spec/db/local.db',
+    'logLevel': 'debug'
 };
 
 

spec/TestApplication.js

@@ -1,14 +1,16 @@
 
 // MOST Web Framework Codename Zero Gravity Copyright (c) 2017-2022, THEMOST LP
-import { DataAdapterBase, DataAdapterIndexes, DataAdapterMigration, DataAdapterTable, DataAdapterView } from '@themost/common';
+import { DataAdapterBase, DataAdapterIndexes, DataAdapterMigration, DataAdapterTable, DataAdapterView, TraceLogger } from '@themost/common';
 import { QueryExpression, SqlFormatter } from '@themost/query';
 import {AsyncSeriesEventEmitter} from '@themost/events';
 
 export declare class SqliteAdapter implements DataAdapterBase {
     executing: AsyncSeriesEventEmitter<{target: SqliteAdapter, query: (string|QueryExpression), params?: unknown[]}>;
     executed: AsyncSeriesEventEmitter<{target: SqliteAdapter, query: (string|QueryExpression), params?: unknown[], results: uknown[]}>;
 
-    constructor(options: { database: string, extensions?: { [key: string]: string }, retry?: number, retryInterval?: number });
+    logger: TraceLogger;
+
+    constructor(options: { database: string, extensions?: { [key: string]: string }, retry?: number, retryInterval?: number, logLevel?: 'error' | 'warn' | 'info' |  'verbose' | 'debug' });
     rawConnection?: any;
     options?: { database: string, extensions?: { [key: string]: string }, retry?: number, retryInterval?: number };
     selectIdentityAsync(entity: string, attribute: string): Promise<any>;

src/SqliteAdapter.d.ts

@@ -63,14 +63,29 @@ function onReceivingJsonObject(event) {
     }
 }
 
+/**
+ * 
+ * @returns {import('@themost/common').TraceLogger}
+ */
+function createLogger() {
+    if (typeof TraceUtils.newLogger === 'function') {
+        return TraceUtils.newLogger();
+    }
+    const [loggerProperty] = Object.getOwnPropertySymbols(TraceUtils);
+    const logger = TraceUtils[loggerProperty];
+    const newLogger = Object.create(TraceUtils[loggerProperty]);
+    newLogger.options = Object.assign({}, logger.options);
+    return newLogger;
+}
+
 
 class SqliteAdapter {
     /**
      * @param {*} options
      */
     constructor(options) {
         /**
-         * @type {{database: string,retry: number=,retryInterval: number=}}
+         * @type {{database: string,retry: number=,retryInterval: number=,logLevel:string=}}
          */
         this.options = options || { database: ':memory:' };
         // set defaults
@@ -88,7 +103,22 @@ class SqliteAdapter {
         this.executed = new AsyncSeriesEventEmitter();
 
         this.executed.subscribe(onReceivingJsonObject);
-
+        /**
+         * create a new instance of logger
+         * @type {import('@themost/common').TraceLogger}
+         */
+        this.logger = createLogger();
+        // use log level from connection options, if any
+        if (typeof this.options.logLevel === 'string' && this.options.logLevel.length) {
+            // if the logger has level(string) function
+            if (typeof this.logger.level === 'function') {
+                // try to set log level
+                this.logger.level(this.options.logLevel);
+            // otherwise, check if logger has setLogLevel(string) function
+            } else if (typeof this.logger.setLogLevel === 'function') {
+                this.logger.setLogLevel(this.options.logLevel);
+            }
+        }
     }
     open(callback) {
         const self = this;
@@ -147,8 +177,8 @@ class SqliteAdapter {
             }
         }
         catch (err) {
-            TraceUtils.log('An error occurred while closing database.');
-            TraceUtils.log(err);
+            this.logger.warn('An error occurred while closing database.');
+            this.logger.warn(err);
             //call callback without error
             callback();
         }
@@ -1153,8 +1183,7 @@ class SqliteAdapter {
                 }
                 else {
                     //log statement (optional)
-                    if (process.env.NODE_ENV === 'development')
-                        TraceUtils.log(sprintf('SQL:%s, Parameters:%s', sql, JSON.stringify(values)));
+                    self.logger.debug(`SQL:${sql}, Parameters:${JSON.stringify(values)}`);
                     //prepare statement - the traditional way
                     const prepared = self.prepare(sql, values);
                     let fn;
@@ -1173,7 +1202,7 @@ class SqliteAdapter {
                             if (err.code === 'SQLITE_BUSY') {
                                 const shouldRetry = typeof self.options.retry === 'number' && self.options.retry > 0;
                                 if (shouldRetry === false) {
-                                    TraceUtils.error(`SQL Error: ${prepared}`);
+                                    self.logger.error(`SQL Error: ${prepared}`);
                                     return callback(err);
                                 }
                                 const retry = self.options.retry;
@@ -1196,7 +1225,7 @@ class SqliteAdapter {
                                 }
                                 // retry
                                 callback.retry += retryInterval;
-                                TraceUtils.warn(`'SQL Error:${prepared}. Retrying in ${callback.retry} ms.'`);
+                                self.logger.warn(`'SQL Error:${prepared}. Retrying in ${callback.retry} ms.'`);
                                 return setTimeout(function () {
                                     self.execute(query, values, callback);
                                 }, callback.retry);
@@ -1205,7 +1234,7 @@ class SqliteAdapter {
                             if (Object.prototype.hasOwnProperty.call(callback, 'retry')) {
                                 delete callback.retry;
                             }
-                            TraceUtils.error(`SQL Error: ${prepared}`);
+                            self.logger.error(`SQL Error: ${prepared}`);
                             callback(err);
                         }
                         else {