improve error handling and output to the sysadmin

Author: bchanudet

src/index.ts

@@ -16,107 +16,127 @@ export default class MysqlAuth  implements IPluginAuth<MysqlAuthConfig> {
 
     private config : mysql.ConnectionConfig;
     private queries : IMysqlQueries;
-
     private logger: Logger;
-    private connOK: boolean;
+
+    private authQueryEmptyWarned: boolean;
+    private addQueryEmptyWarned: boolean;
+    private passwordQueryEmptyWarned: boolean;
 
     constructor(configuration : MysqlAuthConfig, stuff: { logger: Logger}){
 
         this.config = configuration.connection;
         this.queries = new MysqlQueries(configuration.queries);
         this.logger = stuff.logger;
 
-        this.connOK = false;
+        this.authQueryEmptyWarned = false;
+        this.addQueryEmptyWarned = false;
+        this.passwordQueryEmptyWarned = false;
 
-        // Calling initialization at the constructor check connection to the database.
-        this.test()
-            .then((success : boolean) => {
-                if(success) {
-                    this.connOK = true;
-                }
-            })
-            .catch((reason) => {
-                this.connOK = false;
-            });
+        this.test();
     }
 
     authenticate(user: string, password: string, cb: Callback){
-        const connection = mysql.createConnection(this.config);
-
-        if(this.queries.auth_user.length == 0){
-            this.logger.info('MySQL - Can\'t authenticate: authenticate query is empty');
-            cb(null, false)
-            return;
+        if(this.queries.auth_user.length == 0 && !this.authQueryEmptyWarned){
+            this.logger.warn('MySQL - Can\'t authenticate: authenticate query is empty');
+            this.authQueryEmptyWarned = true;
+            return cb(null, false);
         }
 
-        connection.query(this.queries.auth_user,[user, password], (error, result) => {
-            if(error || result.length !== 1 || result[0].usergroups === null){
-                cb(null, false);
+        this.runQuery(this.queries.auth_user,[user, password], (error, result) => {
+            if(error){
+                return cb(null, false);
+            }
+            else if(!Array.isArray(result)){
+                this.logger.error({}, 'MySQL - Result is not an rowset');
+                return cb(null, false);
+            }
+            else if(result[0] === null){
+                this.logger.error({}, 'MySQL - The query returned an invalid result');
+                return cb(null, false);
+            }
+            else if(result.length === 0){
+                // Usual case where everything is valid but we got a bad password.
+                return cb(null, false);
+            }
+            else if(result.length > 1){
+                this.logger.error({"rows": result.length}, "MySQL - The query returned @{rows} rows. Only one row must be returned.");
+                return cb(null, false);
             }
             else { 
-                cb(null, result[0].usergroups.split(','));
+                let groups: string = "";
+                if(result[0].usergroups === undefined){
+                    this.logger.warn({},"MySQL - The query didn't contain a `usergroups` column. Group feature will likely not be functionnal.");
+                }
+                else if(result[0].usergroups !== null){
+                    groups = result[0].usergroups;
+                }
+                
+                return cb(null, groups.split(','));
             }
-
-            connection.end();
         });
     }
 
     adduser(user: string, password: string, cb: Callback){
-        const connection = mysql.createConnection(this.config);
 
-        if(this.queries.add_user.length == 0){
-            this.logger.info('MySQL - Can\'t add user: add_user query is empty');
-            cb(null, false)
-            return;
+        if(this.queries.add_user.length == 0 && !this.addQueryEmptyWarned){
+            this.logger.warn({}, 'MySQL - Can\'t add user: add_user query is empty');
+            this.addQueryEmptyWarned = true;
+            return cb(null, false);
         }
 
-        connection.query(this.queries.add_user,[user, password], (error, result) => {
+        this.runQuery(this.queries.add_user,[user, password], (error, result) => {
             if(error){
-                cb(null, false);
+                this.logger.error({error}, "MySQL - Error: @{error.message}");
+                return cb(null, false);
             }
             else { 
-                cb(null, result[0].usergroups.split(','));
+                return cb(null, true);
             }
-
-            connection.end();
         });
     }
 
     changePassword(user: string, password: string, newPassword: string, cb: Callback){
-        const connection = mysql.createConnection(this.config);
-
-        if(this.queries.update_user.length == 0){
-            this.logger.info('MySQL - Can\'t change password: update_user query is empty');
-            cb(null, false)
-            return;
+        if(this.queries.update_user.length == 0 && !this.passwordQueryEmptyWarned){
+            this.logger.warn({}, 'MySQL - Can\'t change password: update_user query is empty');
+            this.passwordQueryEmptyWarned = true;
+            return cb(null, false);
         }
 
-        connection.query(this.queries.update_user,[newPassword, user, password], (error, result) => {
+        this.runQuery(this.queries.update_user,[newPassword, user, password], (error, result) => {
             if(error){
+                this.logger.error({error}, "MySQL - Error: @{error.message}");
                 cb(null, false);
             }
             else { 
-                cb(null, result[0].usergroups.split(','));
+                cb(null, true);
             }
-
-            connection.end();
         });
     }
 
     private async test() : Promise<boolean> {
         return new Promise<boolean>((resolve, reject) => {
-            const connection = mysql.createConnection(this.config);
 
-            connection.query('SELECT 1', (err, res) => {
+            this.runQuery('SELECT 1', [], (err, res) => {
                 if(err){
-                    this.logger.error('MySQL - Test connection did not work');
-                    this.logger.error('MySQL - Error: '+ err.message);
+                    this.logger.error({}, 'MySQL - Test connection did not work');
+                    this.logger.error({err}, 'MySQL - Error: @{err.message}');
                     reject();
                 }
-                connection.destroy();
-                resolve();
+                resolve(true);
                 return;
-            })
+            });
+        });
+    }
+
+    private runQuery(query: string, parameters: string[], callback: mysql.queryCallback): void{
+        const connection = mysql.createConnection(this.config);
+
+        this.logger.debug({query, parameters}, 'MySQL - Running @{query} with @{parameters}');
+        connection.query(query, parameters, (error, result) => {
+            if(error){
+                this.logger.error({error}, 'MySQL - Error: @{err.message}');
+            }
+            return callback(error, result);
         });
     }
 }