diff --git a/package.json b/package.json
index adc88a305..94d78c4a1 100644
--- a/package.json
+++ b/package.json
@@ -19,7 +19,7 @@
     "prepare": "node ./scripts/prepare.js",
     "lint": "eslint \"src/**/*.{js,jsx,ts,tsx,json}\" \"test/**/*.{js,jsx,ts,tsx,json}\"",
     "lint:fix": "eslint --fix \"src/**/*.{js,jsx,ts,tsx,json}\" \"test/**/*.{js,jsx,ts,tsx,json}\"",
-    "format": "prettier --write src/**/*.{js,jsx,ts,tsx,css,md,json,scss} test/**/*.{js,jsx,ts,tsx,json} --config ./.prettierrc",
+    "format": "prettier --write src/**/*.{js,jsx,ts,tsx,css,md,json,scss} test/**/*.{js,jsx,ts,tsx,json} packages/git-proxy-cli/test/**/*.{js,jsx,ts,tsx,json}  packages/git-proxy-cli/index.js --config ./.prettierrc",
     "gen-schema-doc": "node ./scripts/doc-schema.js",
     "cypress:run": "cypress run"
   },
diff --git a/packages/git-proxy-cli/test/testCli.proxy.config.json b/packages/git-proxy-cli/test/testCli.proxy.config.json
index 48073ef57..95b3266ec 100644
--- a/packages/git-proxy-cli/test/testCli.proxy.config.json
+++ b/packages/git-proxy-cli/test/testCli.proxy.config.json
@@ -1,8 +1,7 @@
 {
   "tempPassword": {
     "sendEmail": false,
-    "emailConfig": {
-    }
+    "emailConfig": {}
   },
   "authorisedList": [
     {
@@ -22,9 +21,9 @@
     {
       "type": "mongo",
       "connectionString": "mongodb://localhost:27017/gitproxy",
-      "options": {        
+      "options": {
         "useUnifiedTopology": true
-      },      
+      },
       "enabled": false
     }
   ],
diff --git a/src/config/env.ts b/src/config/env.ts
index 85b8475b5..9bb0bad55 100644
--- a/src/config/env.ts
+++ b/src/config/env.ts
@@ -9,12 +9,12 @@ const {
   GIT_PROXY_SERVER_PORT = 8000,
   GIT_PROXY_HTTPS_SERVER_PORT = 8443,
   GIT_PROXY_UI_HOST = 'http://localhost',
-  GIT_PROXY_UI_PORT = 8080
+  GIT_PROXY_UI_PORT = 8080,
 } = process.env;
 
 export const serverConfig: ServerConfig = {
   GIT_PROXY_SERVER_PORT,
   GIT_PROXY_HTTPS_SERVER_PORT,
   GIT_PROXY_UI_HOST,
-  GIT_PROXY_UI_PORT
+  GIT_PROXY_UI_PORT,
 };
diff --git a/src/db/file/pushes.ts b/src/db/file/pushes.ts
index 2a54314ea..2d8c41efb 100644
--- a/src/db/file/pushes.ts
+++ b/src/db/file/pushes.ts
@@ -6,10 +6,17 @@ import { toClass } from '../helper';
 import * as repo from './repo';
 import { PushQuery } from '../types';
 
+const COMPACTION_INTERVAL = 1000 * 60 * 60 * 24; // once per day
+
+// these don't get coverage in tests as they have already been run once before the test
+/* istanbul ignore if */
 if (!fs.existsSync('./.data')) fs.mkdirSync('./.data');
+/* istanbul ignore if */
 if (!fs.existsSync('./.data/db')) fs.mkdirSync('./.data/db');
 
 const db = new Datastore({ filename: './.data/db/pushes.db', autoload: true });
+db.ensureIndex({ fieldName: 'id', unique: true });
+db.setAutocompactionInterval(COMPACTION_INTERVAL);
 
 const defaultPushQuery: PushQuery = {
   error: false,
@@ -22,6 +29,8 @@ export const getPushes = (query: PushQuery) => {
   if (!query) query = defaultPushQuery;
   return new Promise((resolve, reject) => {
     db.find(query, (err: Error, docs: Action[]) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -38,6 +47,8 @@ export const getPushes = (query: PushQuery) => {
 export const getPush = async (id: string) => {
   return new Promise<Action | null>((resolve, reject) => {
     db.findOne({ id: id }, (err, doc) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -54,6 +65,8 @@ export const getPush = async (id: string) => {
 export const deletePush = async (id: string) => {
   return new Promise<void>((resolve, reject) => {
     db.remove({ id }, (err) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -67,6 +80,8 @@ export const writeAudit = async (action: Action) => {
   return new Promise((resolve, reject) => {
     const options = { multi: false, upsert: true };
     db.update({ id: action.id }, action, options, (err) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -115,7 +130,7 @@ export const cancel = async (id: string) => {
   return { message: `cancel ${id}` };
 };
 
-export const canUserCancelPush = async (id: string, user: any) => {
+export const canUserCancelPush = async (id: string, user: string) => {
   return new Promise<boolean>(async (resolve) => {
     const pushDetail = await getPush(id);
     if (!pushDetail) {
@@ -134,14 +149,14 @@ export const canUserCancelPush = async (id: string, user: any) => {
   });
 };
 
-export const canUserApproveRejectPush = async (id: string, user: any) => {
+export const canUserApproveRejectPush = async (id: string, user: string) => {
   return new Promise<boolean>(async (resolve) => {
     const action = await getPush(id);
     if (!action) {
       resolve(false);
       return;
     }
-    const repoName = action?.repoName.replace('.git', '');
+    const repoName = action.repoName.replace('.git', '');
     const isAllowed = await repo.canUserApproveRejectPushRepo(repoName, user);
 
     resolve(isAllowed);
diff --git a/src/db/file/repo.ts b/src/db/file/repo.ts
index 8686899f5..fd7218c15 100644
--- a/src/db/file/repo.ts
+++ b/src/db/file/repo.ts
@@ -1,15 +1,31 @@
 import fs from 'fs';
-import Datastore from '@seald-io/nedb'
+import Datastore from '@seald-io/nedb';
 import { Repo } from '../types';
 
+const COMPACTION_INTERVAL = 1000 * 60 * 60 * 24; // once per day
+
+// these don't get coverage in tests as they have already been run once before the test
+/* istanbul ignore if */
 if (!fs.existsSync('./.data')) fs.mkdirSync('./.data');
+/* istanbul ignore if */
 if (!fs.existsSync('./.data/db')) fs.mkdirSync('./.data/db');
 
 const db = new Datastore({ filename: './.data/db/repos.db', autoload: true });
+db.ensureIndex({ fieldName: 'name', unique: false });
+db.setAutocompactionInterval(COMPACTION_INTERVAL);
+
+const isBlank = (str: string) => {
+  return !str || /^\s*$/.test(str);
+};
 
 export const getRepos = async (query: any = {}) => {
+  if (query?.name) {
+    query.name = query.name.toLowerCase();
+  }
   return new Promise<Repo[]>((resolve, reject) => {
-    db.find({}, (err: Error, docs: Repo[]) => {
+    db.find(query, (err: Error, docs: Repo[]) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -21,7 +37,9 @@ export const getRepos = async (query: any = {}) => {
 
 export const getRepo = async (name: string) => {
   return new Promise<Repo | null>((resolve, reject) => {
-    db.findOne({ name }, (err: Error | null, doc: Repo) => {
+    db.findOne({ name: name.toLowerCase() }, (err: Error | null, doc: Repo) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -31,8 +49,19 @@ export const getRepo = async (name: string) => {
   });
 };
 
-
 export const createRepo = async (repo: Repo) => {
+  if (isBlank(repo.project)) {
+    throw new Error('Project name cannot be empty');
+  }
+  if (isBlank(repo.name)) {
+    throw new Error('Repository name cannot be empty');
+  } else {
+    repo.name = repo.name.toLowerCase();
+  }
+  if (isBlank(repo.url)) {
+    throw new Error('URL cannot be empty');
+  }
+
   repo.users = {
     canPush: [],
     canAuthorise: [],
@@ -40,6 +69,8 @@ export const createRepo = async (repo: Repo) => {
 
   return new Promise<Repo>((resolve, reject) => {
     db.insert(repo, (err, doc) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -50,6 +81,8 @@ export const createRepo = async (repo: Repo) => {
 };
 
 export const addUserCanPush = async (name: string, user: string) => {
+  name = name.toLowerCase();
+  user = user.toLowerCase();
   return new Promise(async (resolve, reject) => {
     const repo = await getRepo(name);
     if (!repo) {
@@ -65,6 +98,8 @@ export const addUserCanPush = async (name: string, user: string) => {
 
     const options = { multi: false, upsert: false };
     db.update({ name: name }, repo, options, (err) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -75,6 +110,8 @@ export const addUserCanPush = async (name: string, user: string) => {
 };
 
 export const addUserCanAuthorise = async (name: string, user: string) => {
+  name = name.toLowerCase();
+  user = user.toLowerCase();
   return new Promise(async (resolve, reject) => {
     const repo = await getRepo(name);
     if (!repo) {
@@ -91,6 +128,8 @@ export const addUserCanAuthorise = async (name: string, user: string) => {
 
     const options = { multi: false, upsert: false };
     db.update({ name: name }, repo, options, (err) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -101,6 +140,8 @@ export const addUserCanAuthorise = async (name: string, user: string) => {
 };
 
 export const removeUserCanAuthorise = async (name: string, user: string) => {
+  name = name.toLowerCase();
+  user = user.toLowerCase();
   return new Promise(async (resolve, reject) => {
     const repo = await getRepo(name);
     if (!repo) {
@@ -112,6 +153,8 @@ export const removeUserCanAuthorise = async (name: string, user: string) => {
 
     const options = { multi: false, upsert: false };
     db.update({ name: name }, repo, options, (err) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -122,6 +165,8 @@ export const removeUserCanAuthorise = async (name: string, user: string) => {
 };
 
 export const removeUserCanPush = async (name: string, user: string) => {
+  name = name.toLowerCase();
+  user = user.toLowerCase();
   return new Promise(async (resolve, reject) => {
     const repo = await getRepo(name);
     if (!repo) {
@@ -133,6 +178,8 @@ export const removeUserCanPush = async (name: string, user: string) => {
 
     const options = { multi: false, upsert: false };
     db.update({ name: name }, repo, options, (err) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -143,8 +190,11 @@ export const removeUserCanPush = async (name: string, user: string) => {
 };
 
 export const deleteRepo = async (name: string) => {
+  name = name.toLowerCase();
   return new Promise<void>((resolve, reject) => {
     db.remove({ name: name }, (err) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -156,6 +206,7 @@ export const deleteRepo = async (name: string) => {
 
 export const isUserPushAllowed = async (name: string, user: string) => {
   name = name.toLowerCase();
+  user = user.toLowerCase();
   return new Promise<boolean>(async (resolve) => {
     const repo = await getRepo(name);
     if (!repo) {
@@ -176,6 +227,7 @@ export const isUserPushAllowed = async (name: string, user: string) => {
 
 export const canUserApproveRejectPushRepo = async (name: string, user: string) => {
   name = name.toLowerCase();
+  user = user.toLowerCase();
   console.log(`checking if user ${user} can approve/reject for ${name}`);
   return new Promise<boolean>(async (resolve) => {
     const repo = await getRepo(name);
diff --git a/src/db/file/users.ts b/src/db/file/users.ts
index d72443c97..263c612f4 100644
--- a/src/db/file/users.ts
+++ b/src/db/file/users.ts
@@ -2,14 +2,26 @@ import fs from 'fs';
 import Datastore from '@seald-io/nedb';
 import { User } from '../types';
 
+const COMPACTION_INTERVAL = 1000 * 60 * 60 * 24; // once per day
+
+// these don't get coverage in tests as they have already been run once before the test
+/* istanbul ignore if */
 if (!fs.existsSync('./.data')) fs.mkdirSync('./.data');
+/* istanbul ignore if */
 if (!fs.existsSync('./.data/db')) fs.mkdirSync('./.data/db');
 
 const db = new Datastore({ filename: './.data/db/users.db', autoload: true });
 
+// Using a unique constraint with the index
+db.ensureIndex({ fieldName: 'username', unique: true });
+db.ensureIndex({ fieldName: 'email', unique: true });
+db.setAutocompactionInterval(COMPACTION_INTERVAL);
+
 export const findUser = (username: string) => {
   return new Promise<User | null>((resolve, reject) => {
-    db.findOne({ username: username }, (err: Error | null, doc: User) => {
+    db.findOne({ username: username.toLowerCase() }, (err: Error | null, doc: User) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -26,6 +38,8 @@ export const findUser = (username: string) => {
 export const findUserByOIDC = function (oidcId: string) {
   return new Promise((resolve, reject) => {
     db.findOne({ oidcId: oidcId }, (err, doc) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -40,8 +54,12 @@ export const findUserByOIDC = function (oidcId: string) {
 };
 
 export const createUser = function (user: User) {
+  user.username = user.username.toLowerCase();
+  user.email = user.email.toLowerCase();
   return new Promise((resolve, reject) => {
     db.insert(user, (err) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -53,7 +71,9 @@ export const createUser = function (user: User) {
 
 export const deleteUser = (username: string) => {
   return new Promise<void>((resolve, reject) => {
-    db.remove({ username: username }, (err) => {
+    db.remove({ username: username.toLowerCase() }, (err) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
@@ -64,21 +84,54 @@ export const deleteUser = (username: string) => {
 };
 
 export const updateUser = (user: User) => {
+  user.username = user.username.toLowerCase();
+  if (user.email) {
+    user.email = user.email.toLowerCase();
+  }
   return new Promise((resolve, reject) => {
-    const options = { multi: false, upsert: false };
-    db.update({ username: user.username }, user, options, (err) => {
+    // The mongo db adaptor adds fields to existing documents, where this adaptor replaces the document
+    //   hence, retrieve and merge documents to avoid dropping fields (such as the gitaccount)
+    let existingUser;
+    db.findOne({ username: user.username }, (err, doc) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
-        resolve(null);
+        if (!doc) {
+          existingUser = {};
+        } else {
+          existingUser = doc;
+        }
+
+        Object.assign(existingUser, user);
+
+        const options = { multi: false, upsert: true };
+        db.update({ username: user.username }, existingUser, options, (err) => {
+          // ignore for code coverage as neDB rarely returns errors even for an invalid query
+          /* istanbul ignore if */
+          if (err) {
+            reject(err);
+          } else {
+            resolve(null);
+          }
+        });
       }
     });
   });
 };
 
 export const getUsers = (query: any = {}) => {
+  if (query.username) {
+    query.username = query.username.toLowerCase();
+  }
+  if (query.email) {
+    query.email = query.email.toLowerCase();
+  }
   return new Promise<User[]>((resolve, reject) => {
     db.find(query, (err: Error, docs: User[]) => {
+      // ignore for code coverage as neDB rarely returns errors even for an invalid query
+      /* istanbul ignore if */
       if (err) {
         reject(err);
       } else {
diff --git a/src/db/mongo/helper.ts b/src/db/mongo/helper.ts
index 335434ebb..c4956de0f 100644
--- a/src/db/mongo/helper.ts
+++ b/src/db/mongo/helper.ts
@@ -25,7 +25,7 @@ export const connect = async (collectionName: string): Promise<Collection> => {
 export const findDocuments = async <T>(
   collectionName: string,
   filter: Filter<Document> = {},
-  options: FindOptions<Document> = {}
+  options: FindOptions<Document> = {},
 ): Promise<T[]> => {
   const collection = await connect(collectionName);
   return collection.find(filter, options).toArray() as Promise<T[]>;
@@ -34,7 +34,7 @@ export const findDocuments = async <T>(
 export const findOneDocument = async <T>(
   collectionName: string,
   filter: Filter<Document> = {},
-  options: FindOptions<Document> = {}
+  options: FindOptions<Document> = {},
 ): Promise<T | null> => {
   const collection = await connect(collectionName);
   return (await collection.findOne(filter, options)) as T | null;
diff --git a/src/db/mongo/repo.ts b/src/db/mongo/repo.ts
index 5e55d3d71..f299f907a 100644
--- a/src/db/mongo/repo.ts
+++ b/src/db/mongo/repo.ts
@@ -1,4 +1,4 @@
-import { Repo } from "../types";
+import { Repo } from '../types';
 
 const connect = require('./helper').connect;
 const collectionName = 'repos';
@@ -13,11 +13,13 @@ export const getRepos = async (query: any = {}) => {
 };
 
 export const getRepo = async (name: string) => {
+  name = name.toLowerCase();
   const collection = await connect(collectionName);
   return collection.findOne({ name: { $eq: name } });
 };
 
 export const createRepo = async (repo: Repo) => {
+  repo.name = repo.name.toLowerCase();
   console.log(`creating new repo ${JSON.stringify(repo)}`);
 
   if (isBlank(repo.project)) {
@@ -42,35 +44,41 @@ export const createRepo = async (repo: Repo) => {
 
 export const addUserCanPush = async (name: string, user: string) => {
   name = name.toLowerCase();
+  user = user.toLowerCase();
   const collection = await connect(collectionName);
   await collection.updateOne({ name: name }, { $push: { 'users.canPush': user } });
 };
 
 export const addUserCanAuthorise = async (name: string, user: string) => {
   name = name.toLowerCase();
+  user = user.toLowerCase();
   const collection = await connect(collectionName);
   await collection.updateOne({ name: name }, { $push: { 'users.canAuthorise': user } });
 };
 
 export const removeUserCanPush = async (name: string, user: string) => {
   name = name.toLowerCase();
+  user = user.toLowerCase();
   const collection = await connect(collectionName);
   await collection.updateOne({ name: name }, { $pull: { 'users.canPush': user } });
 };
 
 export const removeUserCanAuthorise = async (name: string, user: string) => {
   name = name.toLowerCase();
+  user = user.toLowerCase();
   const collection = await connect(collectionName);
   await collection.updateOne({ name: name }, { $pull: { 'users.canAuthorise': user } });
 };
 
 export const deleteRepo = async (name: string) => {
+  name = name.toLowerCase();
   const collection = await connect(collectionName);
   await collection.deleteMany({ name: name });
 };
 
 export const isUserPushAllowed = async (name: string, user: string) => {
   name = name.toLowerCase();
+  user = user.toLowerCase();
   return new Promise(async (resolve) => {
     const repo = await exports.getRepo(name);
     console.log(repo.users.canPush);
@@ -86,6 +94,7 @@ export const isUserPushAllowed = async (name: string, user: string) => {
 
 export const canUserApproveRejectPushRepo = async (name: string, user: string) => {
   name = name.toLowerCase();
+  user = user.toLowerCase();
   console.log(`checking if user ${user} can approve/reject for ${name}`);
   return new Promise(async (resolve) => {
     const repo = await exports.getRepo(name);
diff --git a/src/db/mongo/users.ts b/src/db/mongo/users.ts
index 0bfa1a941..5bacb245d 100644
--- a/src/db/mongo/users.ts
+++ b/src/db/mongo/users.ts
@@ -1,14 +1,20 @@
-import { User } from "../types";
+import { User } from '../types';
 
 const connect = require('./helper').connect;
 const collectionName = 'users';
 
 export const findUser = async function (username: string) {
   const collection = await connect(collectionName);
-  return collection.findOne({ username: { $eq: username } });
+  return collection.findOne({ username: { $eq: username.toLowerCase() } });
 };
 
 export const getUsers = async function (query: any = {}) {
+  if (query.username) {
+    query.username = query.username.toLowerCase();
+  }
+  if (query.email) {
+    query.email = query.email.toLowerCase();
+  }
   console.log(`Getting users for query= ${JSON.stringify(query)}`);
   const collection = await connect(collectionName);
   return collection.find(query, { password: 0 }).toArray();
@@ -16,17 +22,21 @@ export const getUsers = async function (query: any = {}) {
 
 export const deleteUser = async function (username: string) {
   const collection = await connect(collectionName);
-  return collection.deleteOne({ username: username });
+  return collection.deleteOne({ username: username.toLowerCase() });
 };
 
 export const createUser = async function (user: User) {
   user.username = user.username.toLowerCase();
+  user.email = user.email.toLowerCase();
   const collection = await connect(collectionName);
   return collection.insertOne(user);
 };
 
 export const updateUser = async (user: User) => {
   user.username = user.username.toLowerCase();
+  if (user.email) {
+    user.email = user.email.toLowerCase();
+  }
   const options = { upsert: true };
   const collection = await connect(collectionName);
   await collection.updateOne({ username: user.username }, { $set: user }, options);
diff --git a/src/db/types.ts b/src/db/types.ts
index dba9bdf3a..04951a699 100644
--- a/src/db/types.ts
+++ b/src/db/types.ts
@@ -1,8 +1,8 @@
 export type PushQuery = {
   error: boolean;
-  blocked: boolean,
-  allowPush: boolean,
-  authorised: boolean
+  blocked: boolean;
+  allowPush: boolean;
+  authorised: boolean;
 };
 
 export type UserRole = 'canPush' | 'canAuthorise';
diff --git a/src/plugin.ts b/src/plugin.ts
index f2bd8f26a..92fb9a99c 100644
--- a/src/plugin.ts
+++ b/src/plugin.ts
@@ -15,9 +15,11 @@ function isCompatiblePlugin(obj: any, propertyName: string = 'isGitProxyPlugin')
   // valid plugin objects will have the appropriate property set to true
   // if the prototype chain is exhausted, return false
   while (obj != null) {
-    if (Object.prototype.hasOwnProperty.call(obj, propertyName) &&
+    if (
+      Object.prototype.hasOwnProperty.call(obj, propertyName) &&
       obj.isGitProxyPlugin &&
-      Object.keys(obj).includes('exec')) {
+      Object.keys(obj).includes('exec')
+    ) {
       return true;
     }
     obj = Object.getPrototypeOf(obj);
@@ -55,25 +57,28 @@ class PluginLoader {
    */
   async load(): Promise<void> {
     try {
-      const modulePromises = this.targets.map(target =>
-        this._loadPluginModule(target).catch(error => {
+      const modulePromises = this.targets.map((target) =>
+        this._loadPluginModule(target).catch((error) => {
           console.error(`Failed to load plugin: ${error}`); // TODO: log.error()
           return Promise.reject(error); // Or return an error object to handle it later
-        })
+        }),
       );
 
       const moduleResults = await Promise.allSettled(modulePromises);
       const loadedModules = moduleResults
-        .filter((result): result is PromiseFulfilledResult<any> => result.status === 'fulfilled' && result.value !== null)
-        .map(result => result.value);
+        .filter(
+          (result): result is PromiseFulfilledResult<any> =>
+            result.status === 'fulfilled' && result.value !== null,
+        )
+        .map((result) => result.value);
 
       console.log(`Found ${loadedModules.length} plugin modules`); // TODO: log.debug()
 
-      const pluginTypeResultPromises = loadedModules.map(mod =>
-        this._getPluginObjects(mod).catch(error => {
+      const pluginTypeResultPromises = loadedModules.map((mod) =>
+        this._getPluginObjects(mod).catch((error) => {
           console.error(`Failed to cast plugin objects: ${error}`); // TODO: log.error()
           return Promise.reject(error); // Or return an error object to handle it later
-        })
+        }),
       );
 
       const settledPluginTypeResults = await Promise.allSettled(pluginTypeResultPromises);
@@ -81,16 +86,19 @@ class PluginLoader {
        * @type {PluginTypeResult[]} List of resolved PluginTypeResult objects
        */
       const pluginTypeResults = settledPluginTypeResults
-        .filter((result): result is PromiseFulfilledResult<any> => result.status === 'fulfilled' && result.value !== null)
-        .map(result => result.value);
+        .filter(
+          (result): result is PromiseFulfilledResult<any> =>
+            result.status === 'fulfilled' && result.value !== null,
+        )
+        .map((result) => result.value);
 
       for (const result of pluginTypeResults) {
-        this.pushPlugins.push(...result.pushAction)
-        this.pullPlugins.push(...result.pullAction)
+        this.pushPlugins.push(...result.pushAction);
+        this.pullPlugins.push(...result.pullAction);
       }
 
       const combinedPlugins = [...this.pushPlugins, ...this.pullPlugins];
-      combinedPlugins.forEach(plugin => {
+      combinedPlugins.forEach((plugin) => {
         console.log(`Loaded plugin: ${plugin.constructor.name}`);
       });
     } catch (error) {
@@ -128,7 +136,9 @@ class PluginLoader {
         console.log('found pull plugin', potentialModule.constructor.name);
         plugins.pullAction.push(potentialModule);
       } else {
-        console.error(`Error: Object ${potentialModule.constructor.name} does not seem to be a compatible plugin type`);
+        console.error(
+          `Error: Object ${potentialModule.constructor.name} does not seem to be a compatible plugin type`,
+        );
       }
     }
 
@@ -136,7 +146,7 @@ class PluginLoader {
     // `module.exports = new ProxyPlugin()` in CJS or `exports default new ProxyPlugin()` in ESM
     // the "module" is a single object that could be a plugin
     if (isCompatiblePlugin(pluginModule)) {
-      handlePlugin(pluginModule)
+      handlePlugin(pluginModule);
     } else {
       // handle the typical case of a module which exports multiple objects
       // module.exports = { x, y } (CJS) or multiple `export ...` statements (ESM)
@@ -173,11 +183,11 @@ class PushActionPlugin extends ProxyPlugin {
    * Wrapper class which contains at least one function executed as part of the action chain for git push operations.
    * The function must be called `exec` and take in two parameters: an Express Request (req) and the current Action
    * executed in the chain (action). This function should return a Promise that resolves to an Action.
-   * 
+   *
    * Optionally, child classes which extend this can simply define the `exec` function as their own property.
    * This is the preferred implementation when a custom plugin (subclass) has its own state or additional methods
    * that are required.
-   * 
+   *
    * @param {function} exec - A function that:
    *   - Takes in an Express Request object as the first parameter (`req`).
    *   - Takes in an Action object as the second parameter (`action`).
@@ -201,11 +211,11 @@ class PullActionPlugin extends ProxyPlugin {
    * Wrapper class which contains at least one function executed as part of the action chain for git pull operations.
    * The function must be called `exec` and take in two parameters: an Express Request (req) and the current Action
    * executed in the chain (action). This function should return a Promise that resolves to an Action.
-   * 
+   *
    * Optionally, child classes which extend this can simply define the `exec` function as their own property.
    * This is the preferred implementation when a custom plugin (subclass) has its own state or additional methods
    * that are required.
-   * 
+   *
    * @param {function} exec - A function that:
    *   - Takes in an Express Request object as the first parameter (`req`).
    *   - Takes in an Action object as the second parameter (`action`).
@@ -218,9 +228,4 @@ class PullActionPlugin extends ProxyPlugin {
   }
 }
 
-export {
-  PluginLoader,
-  PushActionPlugin,
-  PullActionPlugin,
-  isCompatiblePlugin,
-}
+export { PluginLoader, PushActionPlugin, PullActionPlugin, isCompatiblePlugin };
diff --git a/src/proxy/actions/Action.ts b/src/proxy/actions/Action.ts
index 78dbc2ef0..b15b7c24c 100644
--- a/src/proxy/actions/Action.ts
+++ b/src/proxy/actions/Action.ts
@@ -1,5 +1,5 @@
-import { getProxyUrl } from "../../config";
-import { Step } from "./Step";
+import { getProxyUrl } from '../../config';
+import { Step } from './Step';
 
 /**
  * Represents a commit.
@@ -62,15 +62,15 @@ class Action {
     this.type = type;
     this.method = method;
     this.timestamp = timestamp;
-    this.project = repo.split("/")[0];
-    this.repoName = repo.split("/")[1];
+    this.project = repo.split('/')[0];
+    this.repoName = repo.split('/')[1];
     this.url = `${getProxyUrl()}/${repo}`;
     this.repo = repo;
   }
 
   /**
    * Add a step to the action.
-   * @param {Step} step 
+   * @param {Step} step
    */
   addStep(step: Step): void {
     this.steps.push(step);
diff --git a/src/proxy/actions/Step.ts b/src/proxy/actions/Step.ts
index cdb07bf95..6eb114e9c 100644
--- a/src/proxy/actions/Step.ts
+++ b/src/proxy/actions/Step.ts
@@ -1,4 +1,4 @@
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid';
 
 /** Class representing a Push Step. */
 class Step {
@@ -17,7 +17,7 @@ class Step {
     errorMessage: string | null = null,
     blocked: boolean = false,
     blockedMessage: string | null = null,
-    content: any = null
+    content: any = null,
   ) {
     this.id = uuidv4();
     this.stepName = stepName;
@@ -35,12 +35,12 @@ class Step {
   }
 
   setContent(content: any): void {
-    this.log("setting content");
+    this.log('setting content');
     this.content = content;
   }
 
   setAsyncBlock(message: string): void {
-    this.log("setting blocked");
+    this.log('setting blocked');
     this.blocked = true;
     this.blockedMessage = message;
   }
diff --git a/src/proxy/actions/autoActions.ts b/src/proxy/actions/autoActions.ts
index 03ed0529a..450c97d80 100644
--- a/src/proxy/actions/autoActions.ts
+++ b/src/proxy/actions/autoActions.ts
@@ -33,7 +33,4 @@ const attemptAutoRejection = async (action: Action) => {
   }
 };
 
-export {
-  attemptAutoApproval,
-  attemptAutoRejection,
-};
+export { attemptAutoApproval, attemptAutoRejection };
diff --git a/src/proxy/actions/index.ts b/src/proxy/actions/index.ts
index 72aa2918a..13f35276c 100644
--- a/src/proxy/actions/index.ts
+++ b/src/proxy/actions/index.ts
@@ -1,7 +1,4 @@
 import { Action } from './Action';
 import { Step } from './Step';
 
-export {
-  Action,
-  Step
-}
+export { Action, Step };
diff --git a/src/proxy/processors/pre-processor/parseAction.ts b/src/proxy/processors/pre-processor/parseAction.ts
index ed610d9d1..a9c332fdc 100644
--- a/src/proxy/processors/pre-processor/parseAction.ts
+++ b/src/proxy/processors/pre-processor/parseAction.ts
@@ -1,6 +1,10 @@
 import { Action } from '../../actions';
 
-const exec = async (req: { originalUrl: string; method: string; headers: Record<string, string> }) => {
+const exec = async (req: {
+  originalUrl: string;
+  method: string;
+  headers: Record<string, string>;
+}) => {
   const id = Date.now();
   const timestamp = id;
   const repoName = getRepoNameFromUrl(req.originalUrl);
diff --git a/src/proxy/processors/push-action/checkAuthorEmails.ts b/src/proxy/processors/push-action/checkAuthorEmails.ts
index a25a0e6c9..367514e16 100644
--- a/src/proxy/processors/push-action/checkAuthorEmails.ts
+++ b/src/proxy/processors/push-action/checkAuthorEmails.ts
@@ -27,14 +27,16 @@ const isEmailAllowed = (email: string): boolean => {
   }
 
   return true;
-}
+};
 
 const exec = async (req: any, action: Action): Promise<Action> => {
   console.log({ req, action });
 
   const step = new Step('checkAuthorEmails');
 
-  const uniqueAuthorEmails = [...new Set(action.commitData?.map((commit: Commit) => commit.authorEmail))];
+  const uniqueAuthorEmails = [
+    ...new Set(action.commitData?.map((commit: Commit) => commit.authorEmail)),
+  ];
   console.log({ uniqueAuthorEmails });
 
   const illegalEmails = uniqueAuthorEmails.filter((email) => !isEmailAllowed(email));
diff --git a/src/proxy/processors/push-action/checkCommitMessages.ts b/src/proxy/processors/push-action/checkCommitMessages.ts
index 7a95f6c12..01517539d 100644
--- a/src/proxy/processors/push-action/checkCommitMessages.ts
+++ b/src/proxy/processors/push-action/checkCommitMessages.ts
@@ -47,7 +47,7 @@ const isMessageAllowed = (commitMessage: string): boolean => {
   }
 
   return true;
-}
+};
 
 // Execute if the repo is approved
 const exec = async (req: any, action: Action): Promise<Action> => {
diff --git a/src/proxy/processors/push-action/checkUserPushPermission.ts b/src/proxy/processors/push-action/checkUserPushPermission.ts
index c712693e5..5ed660b44 100644
--- a/src/proxy/processors/push-action/checkUserPushPermission.ts
+++ b/src/proxy/processors/push-action/checkUserPushPermission.ts
@@ -30,8 +30,8 @@ const exec = async (req: any, action: Action): Promise<Action> => {
 
     step.setError(
       `Rejecting push as user ${action.user} ` +
-      `is not allowed to push on repo ` +
-      `${action.repo}`,
+        `is not allowed to push on repo ` +
+        `${action.repo}`,
     );
     action.addStep(step);
     return action;
diff --git a/src/proxy/processors/push-action/preReceive.ts b/src/proxy/processors/push-action/preReceive.ts
index 1a8b23d89..1c3ad36b9 100644
--- a/src/proxy/processors/push-action/preReceive.ts
+++ b/src/proxy/processors/push-action/preReceive.ts
@@ -10,7 +10,7 @@ const sanitizeInput = (_req: any, action: Action): string => {
 const exec = async (
   req: any,
   action: Action,
-  hookFilePath: string = './hooks/pre-receive.sh'
+  hookFilePath: string = './hooks/pre-receive.sh',
 ): Promise<Action> => {
   const step = new Step('executeExternalPreReceiveHook');
   let stderrTrimmed = '';
diff --git a/src/proxy/processors/push-action/pullRemote.ts b/src/proxy/processors/push-action/pullRemote.ts
index c7559643f..2f7c808a2 100644
--- a/src/proxy/processors/push-action/pullRemote.ts
+++ b/src/proxy/processors/push-action/pullRemote.ts
@@ -1,5 +1,5 @@
 import { Action, Step } from '../../actions';
-import fs from 'fs'
+import fs from 'fs';
 import git from 'isomorphic-git';
 import gitHttpClient from 'isomorphic-git/http/node';
 
@@ -29,17 +29,16 @@ const exec = async (req: any, action: Action): Promise<Action> => {
       .toString()
       .split(':');
 
-    await git
-      .clone({
-        fs,
-        http: gitHttpClient,
-        url: action.url,
-        onAuth: () => ({
-          username,
-          password,
-        }),
-        dir: `${action.proxyGitPath}/${action.repoName}`,
-      });
+    await git.clone({
+      fs,
+      http: gitHttpClient,
+      url: action.url,
+      onAuth: () => ({
+        username,
+        password,
+      }),
+      dir: `${action.proxyGitPath}/${action.repoName}`,
+    });
 
     console.log('Clone Success: ', action.url);
 
diff --git a/src/proxy/processors/push-action/scanDiff.ts b/src/proxy/processors/push-action/scanDiff.ts
index 296c8b404..40b39627b 100644
--- a/src/proxy/processors/push-action/scanDiff.ts
+++ b/src/proxy/processors/push-action/scanDiff.ts
@@ -8,13 +8,13 @@ const privateOrganizations = getPrivateOrganizations();
 const BLOCK_TYPE = {
   LITERAL: 'Offending Literal',
   PATTERN: 'Offending Pattern',
-  PROVIDER: 'PROVIDER'
-}
+  PROVIDER: 'PROVIDER',
+};
 
 type CombinedMatch = {
   type: string;
   match: RegExp;
-}
+};
 
 type RawMatch = {
   type: string;
@@ -22,7 +22,7 @@ type RawMatch = {
   file?: string;
   lines: number[];
   content: string;
-}
+};
 
 type Match = {
   type: string;
@@ -30,7 +30,7 @@ type Match = {
   file?: string;
   lines: string;
   content: string;
-}
+};
 
 const getDiffViolations = (diff: string, organization: string): Match[] | string | null => {
   // Commit diff is empty, i.e. '', null or undefined
@@ -53,7 +53,7 @@ const getDiffViolations = (diff: string, organization: string): Match[] | string
   if (res.length > 0) {
     console.log('Diff is blocked via configured literals/patterns/providers...');
     // combining matches with file and line number
-    return res
+    return res;
   }
 
   return null;
@@ -67,66 +67,64 @@ const combineMatches = (organization: string) => {
   const blockedPatterns: string[] = commitConfig.diff.block.patterns;
 
   // Configured blocked providers
-  const blockedProviders: [string, string][] = organization && privateOrganizations.includes(organization) ? [] :
-    Object.entries(commitConfig.diff.block.providers);
+  const blockedProviders: [string, string][] =
+    organization && privateOrganizations.includes(organization)
+      ? []
+      : Object.entries(commitConfig.diff.block.providers);
 
   // Combine all matches (literals, paterns)
   const combinedMatches = [
-    ...blockedLiterals.map(literal => ({
+    ...blockedLiterals.map((literal) => ({
       type: BLOCK_TYPE.LITERAL,
-      match: new RegExp(literal, 'gi')
+      match: new RegExp(literal, 'gi'),
     })),
-    ...blockedPatterns.map(pattern => ({
+    ...blockedPatterns.map((pattern) => ({
       type: BLOCK_TYPE.PATTERN,
-      match: new RegExp(pattern, 'gi')
+      match: new RegExp(pattern, 'gi'),
     })),
     ...blockedProviders.map(([key, value]) => ({
       type: key,
-      match: new RegExp(value, 'gi')
+      match: new RegExp(value, 'gi'),
     })),
   ];
   return combinedMatches;
-}
+};
 
-const collectMatches = (
-  parsedDiff: File[],
-  combinedMatches: CombinedMatch[]
-): Match[] => {
+const collectMatches = (parsedDiff: File[], combinedMatches: CombinedMatch[]): Match[] => {
   const allMatches: Record<string, RawMatch> = {};
-  parsedDiff.forEach(file => {
+  parsedDiff.forEach((file) => {
     const fileName = file.to || file.from;
-    console.log("CHANGE", file.chunks)
+    console.log('CHANGE', file.chunks);
 
-    file.chunks.forEach(chunk => {
-      chunk.changes.forEach(change => {
-        console.log("CHANGE", change)
+    file.chunks.forEach((chunk) => {
+      chunk.changes.forEach((change) => {
+        console.log('CHANGE', change);
         if (change.type === 'add') {
           // store line number
           const lineNumber = change.ln;
           // Iterate through each match types - literal, patterns, providers
           combinedMatches.forEach(({ type, match }) => {
             // using Match all to find all occurences of the pattern in the line
-            const matches = [...change.content.matchAll(match)]
+            const matches = [...change.content.matchAll(match)];
 
-            matches.forEach(matchInstance => {
+            matches.forEach((matchInstance) => {
               const matchLiteral = matchInstance[0];
               const matchKey = `${type}_${matchLiteral}_${fileName}`; // unique key
 
-
               if (!allMatches[matchKey]) {
-                // match entry 
+                // match entry
                 allMatches[matchKey] = {
                   type,
                   literal: matchLiteral,
                   file: fileName,
                   lines: [],
-                  content: change.content.trim()
+                  content: change.content.trim(),
                 };
               }
 
               // apend line numbers to the list of lines
-              allMatches[matchKey].lines.push(lineNumber)
-            })
+              allMatches[matchKey].lines.push(lineNumber);
+            });
           });
         }
       });
@@ -134,13 +132,13 @@ const collectMatches = (
   });
 
   // convert matches into  a final result array, joining line numbers
-  const result = Object.values(allMatches).map(match => ({
+  const result = Object.values(allMatches).map((match) => ({
     ...match,
-    lines: match.lines.join(',') // join the line numbers into a comma-separated string
-  }))
+    lines: match.lines.join(','), // join the line numbers into a comma-separated string
+  }));
 
   return result;
-}
+};
 
 const formatMatches = (matches: Match[]) => {
   return matches.map((match, index) => {
@@ -148,9 +146,9 @@ const formatMatches = (matches: Match[]) => {
     Policy Exception Type: ${match.type}
     DETECTED: ${match.literal} 
     FILE(S) LOCATED: ${match.file}
-    Line(s) of code: ${match.lines}`
+    Line(s) of code: ${match.lines}`;
   });
-}
+};
 
 const exec = async (req: any, action: Action): Promise<Action> => {
   const step = new Step('scanDiff');
@@ -160,24 +158,24 @@ const exec = async (req: any, action: Action): Promise<Action> => {
 
   const diff = steps.find((s) => s.stepName === 'diff')?.content;
 
-  console.log(diff)
+  console.log(diff);
   const diffViolations = getDiffViolations(diff, action.project);
 
   if (diffViolations) {
-    const formattedMatches = Array.isArray(diffViolations) ? formatMatches(diffViolations).join('\n\n') : diffViolations;
+    const formattedMatches = Array.isArray(diffViolations)
+      ? formatMatches(diffViolations).join('\n\n')
+      : diffViolations;
     const errorMsg = [];
     errorMsg.push(`\n\n\n\nYour push has been blocked.\n`);
     errorMsg.push(`Please ensure your code does not contain sensitive information or URLs.\n\n`);
-    errorMsg.push(formattedMatches)
-    errorMsg.push('\n')
+    errorMsg.push(formattedMatches);
+    errorMsg.push('\n');
 
     console.log(`The following diff is illegal: ${commitFrom}:${commitTo}`);
 
     step.error = true;
     step.log(`The following diff is illegal: ${commitFrom}:${commitTo}`);
-    step.setError(
-      errorMsg.join('\n')
-    );
+    step.setError(errorMsg.join('\n'));
 
     action.addStep(step);
     return action;
diff --git a/src/proxy/processors/types.ts b/src/proxy/processors/types.ts
index bb267ce90..ae92ba48c 100644
--- a/src/proxy/processors/types.ts
+++ b/src/proxy/processors/types.ts
@@ -1,4 +1,4 @@
-import { Action } from "../actions";
+import { Action } from '../actions';
 
 export interface Processor {
   exec(req: any, action: Action): Promise<Action>;
@@ -17,4 +17,4 @@ export type CommitContent = {
   deflatedSize: number;
   objectRef: any;
   content: string;
-}
+};
diff --git a/src/proxy/routes/index.ts b/src/proxy/routes/index.ts
index c49853376..973608169 100644
--- a/src/proxy/routes/index.ts
+++ b/src/proxy/routes/index.ts
@@ -132,9 +132,4 @@ const handleMessage = (message: string): string => {
   return packetMessage;
 };
 
-export {
-  router,
-  handleMessage,
-  validGitRequest,
-  stripGitHubFromGitPath,
-};
+export { router, handleMessage, validGitRequest, stripGitHubFromGitPath };
diff --git a/src/service/passport/oidc.js b/src/service/passport/oidc.js
index 18fdf7de9..52928460b 100644
--- a/src/service/passport/oidc.js
+++ b/src/service/passport/oidc.js
@@ -7,11 +7,13 @@ const configure = async (passport) => {
   const { discovery, fetchUserInfo } = await import('openid-client');
   const { Strategy } = await import('openid-client/passport');
   const authMethods = require('../../config').getAuthMethods();
-  const oidcConfig = authMethods.find((method) => method.type.toLowerCase() === "openidconnect")?.oidcConfig;
+  const oidcConfig = authMethods.find(
+    (method) => method.type.toLowerCase() === 'openidconnect',
+  )?.oidcConfig;
   const { issuer, clientID, clientSecret, callbackURL, scope } = oidcConfig;
 
   if (!oidcConfig || !oidcConfig.issuer) {
-    throw new Error('Missing OIDC issuer in configuration')
+    throw new Error('Missing OIDC issuer in configuration');
   }
 
   const server = new URL(issuer);
@@ -26,7 +28,7 @@ const configure = async (passport) => {
       const userInfo = await fetchUserInfo(config, tokenSet.access_token, expectedSub);
       handleUserAuthentication(userInfo, done);
     });
-    
+
     // currentUrl must be overridden to match the callback URL
     strategy.currentUrl = function (request) {
       const callbackUrl = new URL(callbackURL);
@@ -41,7 +43,7 @@ const configure = async (passport) => {
 
     passport.serializeUser((user, done) => {
       done(null, user.oidcId || user.username);
-    })
+    });
 
     passport.deserializeUser(async (id, done) => {
       try {
@@ -50,18 +52,18 @@ const configure = async (passport) => {
       } catch (err) {
         done(err);
       }
-    })
+    });
 
     return passport;
   } catch (error) {
     console.error('OIDC configuration failed:', error);
     throw error;
   }
-}
+};
 
 /**
  * Handles user authentication with OIDC.
- * @param {Object} userInfo the OIDC user info object 
+ * @param {Object} userInfo the OIDC user info object
  * @param {Function} done the callback function
  * @return {Promise} a promise with the authenticated user or an error
  */
@@ -97,7 +99,9 @@ const handleUserAuthentication = async (userInfo, done) => {
  * @return {string | null} the email address
  */
 const safelyExtractEmail = (profile) => {
-  return profile.email || (profile.emails && profile.emails.length > 0 ? profile.emails[0].value : null);
+  return (
+    profile.email || (profile.emails && profile.emails.length > 0 ? profile.emails[0].value : null)
+  );
 };
 
 /**
diff --git a/src/service/routes/auth.js b/src/service/routes/auth.js
index aaf2efa26..9544931d9 100644
--- a/src/service/routes/auth.js
+++ b/src/service/routes/auth.js
@@ -3,7 +3,8 @@ const router = new express.Router();
 const passport = require('../passport').getPassport();
 const authStrategies = require('../passport').authStrategies;
 const db = require('../../db');
-const { GIT_PROXY_UI_HOST: uiHost = 'http://localhost', GIT_PROXY_UI_PORT: uiPort = 3000 } = process.env;
+const { GIT_PROXY_UI_HOST: uiHost = 'http://localhost', GIT_PROXY_UI_PORT: uiPort = 3000 } =
+  process.env;
 
 router.get('/', (req, res) => {
   res.status(200).json({
diff --git a/src/service/routes/repo.js b/src/service/routes/repo.js
index 1f6698e3b..f43181a00 100644
--- a/src/service/routes/repo.js
+++ b/src/service/routes/repo.js
@@ -5,9 +5,7 @@ const { getProxyURL } = require('../urls');
 
 router.get('/', async (req, res) => {
   const proxyURL = getProxyURL(req);
-  const query = {
-    type: 'push',
-  };
+  const query = {};
 
   for (const k in req.query) {
     if (!k) continue;
diff --git a/src/ui/components/Filtering/Filtering.css b/src/ui/components/Filtering/Filtering.css
index 84f9258e0..a83724cb2 100644
--- a/src/ui/components/Filtering/Filtering.css
+++ b/src/ui/components/Filtering/Filtering.css
@@ -52,4 +52,4 @@
 
 .dropdown-item:hover {
   background-color: #f0f0f0;
-}
\ No newline at end of file
+}
diff --git a/src/ui/components/Filtering/Filtering.jsx b/src/ui/components/Filtering/Filtering.jsx
index aa9d26c78..1c9e2fcc7 100644
--- a/src/ui/components/Filtering/Filtering.jsx
+++ b/src/ui/components/Filtering/Filtering.jsx
@@ -27,29 +27,34 @@ const Filtering = ({ onFilterChange }) => {
   };
 
   return (
-    <div className="filtering-container">
-      <div className="dropdown">
+    <div className='filtering-container'>
+      <div className='dropdown'>
         {/* Make the entire button clickable for toggling dropdown */}
-        <button onClick={toggleDropdown} className="dropdown-toggle">
+        <button onClick={toggleDropdown} className='dropdown-toggle'>
           {selectedOption}
           {/* Render the up/down arrow next to selected option */}
           {selectedOption !== 'Sort by' && (
-            <span onClick={(e) => { e.stopPropagation(); toggleSortOrder(); }}>
+            <span
+              onClick={(e) => {
+                e.stopPropagation();
+                toggleSortOrder();
+              }}
+            >
               {sortOrder === 'asc' ? ' ↑' : ' ↓'}
             </span>
           )}
-          <span className="dropdown-arrow">▼</span>
+          <span className='dropdown-arrow'>▼</span>
         </button>
 
         {isOpen && (
-          <div className="dropdown-menu">
-            <div onClick={() => handleOptionClick('Date Modified')} className="dropdown-item">
+          <div className='dropdown-menu'>
+            <div onClick={() => handleOptionClick('Date Modified')} className='dropdown-item'>
               Date Modified
             </div>
-            <div onClick={() => handleOptionClick('Date Created')} className="dropdown-item">
+            <div onClick={() => handleOptionClick('Date Created')} className='dropdown-item'>
               Date Created
             </div>
-            <div onClick={() => handleOptionClick('Alphabetical')} className="dropdown-item">
+            <div onClick={() => handleOptionClick('Alphabetical')} className='dropdown-item'>
               Alphabetical
             </div>
           </div>
@@ -60,7 +65,3 @@ const Filtering = ({ onFilterChange }) => {
 };
 
 export default Filtering;
-
-
-
-
diff --git a/src/ui/components/Pagination/Pagination.jsx b/src/ui/components/Pagination/Pagination.jsx
index e87e43c17..777807343 100644
--- a/src/ui/components/Pagination/Pagination.jsx
+++ b/src/ui/components/Pagination/Pagination.jsx
@@ -1,8 +1,7 @@
 import React from 'react';
-import './Pagination.css'; 
+import './Pagination.css';
 
 export default function Pagination({ currentPage, totalItems = 0, itemsPerPage, onPageChange }) {
-
   const totalPages = Math.ceil(totalItems / itemsPerPage);
 
   const handlePageClick = (page) => {
diff --git a/src/ui/components/Search/Search.css b/src/ui/components/Search/Search.css
index db87dc8c0..d4c650d13 100644
--- a/src/ui/components/Search/Search.css
+++ b/src/ui/components/Search/Search.css
@@ -1,7 +1,7 @@
 .search-bar {
   width: 100%;
-  max-width:100%; 
-  margin: 0 auto 20px auto; 
+  max-width: 100%;
+  margin: 0 auto 20px auto;
 }
 
 .search-input {
@@ -10,9 +10,9 @@
   font-size: 16px;
   border: 1px solid #ccc;
   border-radius: 4px;
-  box-sizing: border-box; 
+  box-sizing: border-box;
 }
 
 .search-input:focus {
-  border-color: #007bff; 
+  border-color: #007bff;
 }
diff --git a/src/ui/components/Search/Search.jsx b/src/ui/components/Search/Search.jsx
index 5e1cbf6b4..e774ea0f2 100644
--- a/src/ui/components/Search/Search.jsx
+++ b/src/ui/components/Search/Search.jsx
@@ -2,27 +2,26 @@ import React from 'react';
 import { TextField } from '@material-ui/core';
 import './Search.css';
 import InputAdornment from '@material-ui/core/InputAdornment';
-import SearchIcon from '@material-ui/icons/Search'; 
-
+import SearchIcon from '@material-ui/icons/Search';
 
 export default function Search({ onSearch }) {
   const handleSearchChange = (event) => {
     const query = event.target.value;
-    onSearch(query);  
+    onSearch(query);
   };
 
   return (
     <div style={{ margin: '20px 0' }}>
       <TextField
-        label="Search"
-        variant="outlined"
+        label='Search'
+        variant='outlined'
         fullWidth
-        margin="normal"
-        onChange={handleSearchChange}  
-        placeholder="Search..."
+        margin='normal'
+        onChange={handleSearchChange}
+        placeholder='Search...'
         InputProps={{
           startAdornment: (
-            <InputAdornment position="start">
+            <InputAdornment position='start'>
               <SearchIcon />
             </InputAdornment>
           ),
@@ -31,7 +30,3 @@ export default function Search({ onSearch }) {
     </div>
   );
 }
-
-
-
-
diff --git a/src/ui/views/RepoList/Components/Repositories.jsx b/src/ui/views/RepoList/Components/Repositories.jsx
index ac9663423..228190903 100644
--- a/src/ui/views/RepoList/Components/Repositories.jsx
+++ b/src/ui/views/RepoList/Components/Repositories.jsx
@@ -14,8 +14,7 @@ import { UserContext } from '../../../../context';
 import PropTypes from 'prop-types';
 import Search from '../../../components/Search/Search';
 import Pagination from '../../../components/Pagination/Pagination';
-import Filtering from '../../../components/Filtering/Filtering'; 
-
+import Filtering from '../../../components/Filtering/Filtering';
 
 export default function Repositories(props) {
   const useStyles = makeStyles(styles);
@@ -26,7 +25,7 @@ export default function Repositories(props) {
   const [isLoading, setIsLoading] = useState(false);
   const [isError, setIsError] = useState(false);
   const [currentPage, setCurrentPage] = useState(1);
-  const itemsPerPage = 5; 
+  const itemsPerPage = 5;
   const navigate = useNavigate();
   const { user } = useContext(UserContext);
   const openRepo = (repo) => navigate(`/dashboard/repo/${repo}`, { replace: true });
@@ -37,10 +36,16 @@ export default function Repositories(props) {
       if (!k) continue;
       query[k] = props[k];
     }
-    getRepos(setIsLoading, (data) => {
-      setData(data);
-      setFilteredData(data); 
-    }, setAuth, setIsError, query);
+    getRepos(
+      setIsLoading,
+      (data) => {
+        setData(data);
+        setFilteredData(data);
+      },
+      setAuth,
+      setIsError,
+      query,
+    );
   }, [props]);
 
   const refresh = async (repo) => {
@@ -50,16 +55,17 @@ export default function Repositories(props) {
   };
 
   const handleSearch = (query) => {
-    setCurrentPage(1); 
+    setCurrentPage(1);
     if (!query) {
       setFilteredData(data);
     } else {
       const lowercasedQuery = query.toLowerCase();
       setFilteredData(
-        data.filter(repo =>
-          repo.name.toLowerCase().includes(lowercasedQuery) ||
-          repo.project.toLowerCase().includes(lowercasedQuery)
-        )
+        data.filter(
+          (repo) =>
+            repo.name.toLowerCase().includes(lowercasedQuery) ||
+            repo.project.toLowerCase().includes(lowercasedQuery),
+        ),
       );
     }
   };
@@ -88,8 +94,7 @@ export default function Repositories(props) {
     setFilteredData(sortedData);
   };
 
-
-  const handlePageChange = (page) => setCurrentPage(page); 
+  const handlePageChange = (page) => setCurrentPage(page);
   const startIdx = (currentPage - 1) * itemsPerPage;
   const paginatedData = filteredData.slice(startIdx, startIdx + itemsPerPage);
 
@@ -109,14 +114,14 @@ export default function Repositories(props) {
       key='x'
       classes={classes}
       openRepo={openRepo}
-      data={paginatedData} 
+      data={paginatedData}
       repoButton={addrepoButton}
-      onSearch={handleSearch} 
-      currentPage={currentPage} 
-      totalItems={filteredData.length} 
-      itemsPerPage={itemsPerPage} 
-      onPageChange={handlePageChange} 
-      onFilterChange={handleFilterChange}  // Pass handleFilterChange as prop
+      onSearch={handleSearch}
+      currentPage={currentPage}
+      totalItems={filteredData.length}
+      itemsPerPage={itemsPerPage}
+      onPageChange={handlePageChange}
+      onFilterChange={handleFilterChange} // Pass handleFilterChange as prop
     />
   );
 }
@@ -138,9 +143,8 @@ function GetGridContainerLayOut(props) {
     <GridContainer>
       {props.repoButton}
       <GridItem xs={12} sm={12} md={12}>
-       
         <Search onSearch={props.onSearch} />
-        <Filtering onFilterChange={props.onFilterChange} />  {/* Include the Filtering component */}
+        <Filtering onFilterChange={props.onFilterChange} /> {/* Include the Filtering component */}
         <TableContainer
           style={{ background: 'transparent', borderRadius: '5px', border: '1px solid #d0d7de' }}
         >
@@ -166,4 +170,3 @@ function GetGridContainerLayOut(props) {
     </GridContainer>
   );
 }
-
diff --git a/src/ui/views/UserList/Components/UserList.jsx b/src/ui/views/UserList/Components/UserList.jsx
index ee6812485..36aef89e6 100644
--- a/src/ui/views/UserList/Components/UserList.jsx
+++ b/src/ui/views/UserList/Components/UserList.jsx
@@ -20,7 +20,6 @@ import Search from '../../../components/Search/Search';
 const useStyles = makeStyles(styles);
 
 export default function UserList(props) {
-  
   const classes = useStyles();
   const [data, setData] = useState([]);
   const [, setAuth] = useState(true);
@@ -28,12 +27,11 @@ export default function UserList(props) {
   const [isError, setIsError] = useState(false);
   const navigate = useNavigate();
   const [currentPage, setCurrentPage] = useState(1);
-  const itemsPerPage = 5; 
+  const itemsPerPage = 5;
   const [searchQuery, setSearchQuery] = useState('');
 
   const openUser = (username) => navigate(`/dashboard/admin/user/${username}`, { replace: true });
 
-
   useEffect(() => {
     const query = {};
 
@@ -47,32 +45,30 @@ export default function UserList(props) {
   if (isLoading) return <div>Loading...</div>;
   if (isError) return <div>Something went wrong...</div>;
 
-
-  const filteredUsers = data.filter(user =>
-  user.displayName && user.displayName.toLowerCase().includes(searchQuery.toLowerCase()) ||
-  user.username && user.username.toLowerCase().includes(searchQuery.toLowerCase())
-);
+  const filteredUsers = data.filter(
+    (user) =>
+      (user.displayName && user.displayName.toLowerCase().includes(searchQuery.toLowerCase())) ||
+      (user.username && user.username.toLowerCase().includes(searchQuery.toLowerCase())),
+  );
 
   const indexOfLastItem = currentPage * itemsPerPage;
   const indexOfFirstItem = indexOfLastItem - itemsPerPage;
   const currentItems = filteredUsers.slice(indexOfFirstItem, indexOfLastItem);
   const totalItems = filteredUsers.length;
 
-
   const handlePageChange = (page) => {
     setCurrentPage(page);
   };
 
-
   const handleSearch = (query) => {
     setSearchQuery(query);
-    setCurrentPage(1); 
+    setCurrentPage(1);
   };
 
   return (
     <GridContainer>
       <GridItem xs={12} sm={12} md={12}>
-        <Search onSearch={handleSearch} placeholder="Search users..." />
+        <Search onSearch={handleSearch} placeholder='Search users...' />
         <TableContainer component={Paper}>
           <Table className={classes.table} aria-label='simple table'>
             <TableHead>
@@ -94,12 +90,20 @@ export default function UserList(props) {
                     <a href={`mailto:${row.email}`}>{row.email}</a>
                   </TableCell>
                   <TableCell align='left'>
-                    <a href={`https://github.com/${row.gitAccount}`} target='_blank' rel='noreferrer'>
+                    <a
+                      href={`https://github.com/${row.gitAccount}`}
+                      target='_blank'
+                      rel='noreferrer'
+                    >
                       {row.gitAccount}
                     </a>
                   </TableCell>
                   <TableCell align='left'>
-                    {row.admin ? <Check fontSize='small' color='primary' /> : <CloseRounded color='error' />}
+                    {row.admin ? (
+                      <Check fontSize='small' color='primary' />
+                    ) : (
+                      <CloseRounded color='error' />
+                    )}
                   </TableCell>
                   <TableCell component='th' scope='row'>
                     <Button
@@ -125,4 +129,3 @@ export default function UserList(props) {
     </GridContainer>
   );
 }
-
diff --git a/test/addRepoTest.test.js b/test/addRepoTest.test.js
index 6df809a66..172074101 100644
--- a/test/addRepoTest.test.js
+++ b/test/addRepoTest.test.js
@@ -56,6 +56,18 @@ describe('add new repo', async () => {
     repo.users.canAuthorise.length.should.equal(0);
   });
 
+  it('filter repos', async function () {
+    const res = await chai
+      .request(app)
+      .get('/api/v1/repo')
+      .set('Cookie', `${cookie}`)
+      .query({ name: 'test-repo' });
+    res.should.have.status(200);
+    res.body[0].project.should.equal('finos');
+    res.body[0].name.should.equal('test-repo');
+    res.body[0].url.should.equal('https://github.com/finos/test-repo.git');
+  });
+
   it('add 1st can push user', async function () {
     const res = await chai
       .request(app)
diff --git a/test/fixtures/baz.js b/test/fixtures/baz.js
index 6829bdac3..a1c32ac78 100644
--- a/test/fixtures/baz.js
+++ b/test/fixtures/baz.js
@@ -1,4 +1,4 @@
 module.exports = {
   foo: 'bar',
   baz: {},
-}
\ No newline at end of file
+};
diff --git a/test/fixtures/proxy.config.invalid-1.json b/test/fixtures/proxy.config.invalid-1.json
index 541044abe..6a4d937c0 100644
--- a/test/fixtures/proxy.config.invalid-1.json
+++ b/test/fixtures/proxy.config.invalid-1.json
@@ -6,4 +6,4 @@
       "url": "https://www.github.com/finos/git-proxy.git"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/test/fixtures/proxy.config.invalid-2.json b/test/fixtures/proxy.config.invalid-2.json
index fa3e48bb8..ee1795a12 100644
--- a/test/fixtures/proxy.config.invalid-2.json
+++ b/test/fixtures/proxy.config.invalid-2.json
@@ -6,4 +6,4 @@
       "link": "https://www.github.com/finos/git-proxy"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/test/fixtures/proxy.config.valid-1.json b/test/fixtures/proxy.config.valid-1.json
index 9e26dfeeb..0967ef424 100644
--- a/test/fixtures/proxy.config.valid-1.json
+++ b/test/fixtures/proxy.config.valid-1.json
@@ -1 +1 @@
-{}
\ No newline at end of file
+{}
diff --git a/test/fixtures/proxy.config.valid-2.json b/test/fixtures/proxy.config.valid-2.json
index c18dc1ea4..6c2c92621 100644
--- a/test/fixtures/proxy.config.valid-2.json
+++ b/test/fixtures/proxy.config.valid-2.json
@@ -11,4 +11,4 @@
       "url": "git@github.com:finos/git-proxy-test.git"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/test/fixtures/test-package/multiple-export.js b/test/fixtures/test-package/multiple-export.js
index eeb65caa0..3b0a56f5a 100644
--- a/test/fixtures/test-package/multiple-export.js
+++ b/test/fixtures/test-package/multiple-export.js
@@ -1,6 +1,5 @@
 const { PushActionPlugin, PullActionPlugin } = require('@finos/git-proxy/src/plugin');
 
-
 module.exports = {
   foo: new PushActionPlugin(async (req, action) => {
     console.log('PushActionPlugin: ', action);
@@ -10,4 +9,4 @@ module.exports = {
     console.log('PullActionPlugin: ', action);
     return action;
   }),
-}
+};
diff --git a/test/plugin/plugin.test.js b/test/plugin/plugin.test.js
index ee1f74626..1180ba9bb 100644
--- a/test/plugin/plugin.test.js
+++ b/test/plugin/plugin.test.js
@@ -27,9 +27,8 @@ describe('loading plugins from packages', function () {
     const loader = new PluginLoader([join(testPackagePath, 'default-export.js')]);
     await loader.load();
     expect(loader.pushPlugins.length).to.equal(1);
-    expect(loader.pushPlugins.every(p => isCompatiblePlugin(p))).to.be.true;
-    expect(loader.pushPlugins[0])
-      .to.be.an.instanceOf(PushActionPlugin);
+    expect(loader.pushPlugins.every((p) => isCompatiblePlugin(p))).to.be.true;
+    expect(loader.pushPlugins[0]).to.be.an.instanceOf(PushActionPlugin);
   }).timeout(10000);
 
   it('should load multiple plugins from a module that match the plugin class (module.exports = { pluginFoo, pluginBar })', async function () {
@@ -37,9 +36,11 @@ describe('loading plugins from packages', function () {
     await loader.load();
     expect(loader.pushPlugins.length).to.equal(1);
     expect(loader.pullPlugins.length).to.equal(1);
-    expect(loader.pushPlugins.every(p => isCompatiblePlugin(p))).to.be.true;
-    expect(loader.pushPlugins.every(p => isCompatiblePlugin(p, 'isGitProxyPushActionPlugin'))).to.be.true;
-    expect(loader.pullPlugins.every(p => isCompatiblePlugin(p, 'isGitProxyPullActionPlugin'))).to.be.true;
+    expect(loader.pushPlugins.every((p) => isCompatiblePlugin(p))).to.be.true;
+    expect(loader.pushPlugins.every((p) => isCompatiblePlugin(p, 'isGitProxyPushActionPlugin'))).to
+      .be.true;
+    expect(loader.pullPlugins.every((p) => isCompatiblePlugin(p, 'isGitProxyPullActionPlugin'))).to
+      .be.true;
     expect(loader.pushPlugins[0]).to.be.instanceOf(PushActionPlugin);
     expect(loader.pullPlugins[0]).to.be.instanceOf(PullActionPlugin);
   }).timeout(10000);
@@ -48,8 +49,9 @@ describe('loading plugins from packages', function () {
     const loader = new PluginLoader([join(testPackagePath, 'subclass.js')]);
     await loader.load();
     expect(loader.pushPlugins.length).to.equal(1);
-    expect(loader.pushPlugins.every(p => isCompatiblePlugin(p))).to.be.true;
-    expect(loader.pushPlugins.every(p => isCompatiblePlugin(p, 'isGitProxyPushActionPlugin'))).to.be.true;
+    expect(loader.pushPlugins.every((p) => isCompatiblePlugin(p))).to.be.true;
+    expect(loader.pushPlugins.every((p) => isCompatiblePlugin(p, 'isGitProxyPushActionPlugin'))).to
+      .be.true;
     expect(loader.pushPlugins[0]).to.be.instanceOf(PushActionPlugin);
   }).timeout(10000);
 
diff --git a/test/scanDiff.test.js b/test/scanDiff.test.js
index b32875e91..09fdb9d38 100644
--- a/test/scanDiff.test.js
+++ b/test/scanDiff.test.js
@@ -56,23 +56,22 @@ index 8b97e49..de18d43 100644
 `;
 };
 describe('Scan commit diff...', async () => {
-  privateOrganizations[0] = "private-org-test"
+  privateOrganizations[0] = 'private-org-test';
   commitConfig.diff = {
-      
-    "block": {
-      "literals": ["blockedTestLiteral"],
-      "patterns": [],
-      "providers": {
-        "AWS (Amazon Web Services) Access Key ID": "A(AG|CC|GP|ID|IP|KI|NP|NV|PK|RO|SC|SI)A[A-Z0-9]{16}",
-        "Google Cloud Platform API Key": "AIza[0-9A-Za-z-_]{35}",
-        "GitHub Personal Access Token": "ghp_[a-zA-Z0-9]{36}",
-        "GitHub Fine Grained Personal Access Token": "github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}",
-        "GitHub Actions Token": "ghs_[a-zA-Z0-9]{36}",
-        "JSON Web Token (JWT)": "ey[A-Za-z0-9-_=]{18,}.ey[A-Za-z0-9-_=]{18,}.[A-Za-z0-9-_.]{18,}"
-      }
-    }
-  
-}
+    block: {
+      literals: ['blockedTestLiteral'],
+      patterns: [],
+      providers: {
+        'AWS (Amazon Web Services) Access Key ID':
+          'A(AG|CC|GP|ID|IP|KI|NP|NV|PK|RO|SC|SI)A[A-Z0-9]{16}',
+        'Google Cloud Platform API Key': 'AIza[0-9A-Za-z-_]{35}',
+        'GitHub Personal Access Token': 'ghp_[a-zA-Z0-9]{36}',
+        'GitHub Fine Grained Personal Access Token': 'github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}',
+        'GitHub Actions Token': 'ghs_[a-zA-Z0-9]{36}',
+        'JSON Web Token (JWT)': 'ey[A-Za-z0-9-_=]{18,}.ey[A-Za-z0-9-_=]{18,}.[A-Za-z0-9-_.]{18,}',
+      },
+    },
+  };
   it('A diff including an AWS (Amazon Web Services) Access Key ID blocks the proxy...', async () => {
     const action = new Action('1', 'type', 'method', 1, 'project/name');
     action.steps = [
@@ -126,7 +125,6 @@ describe('Scan commit diff...', async () => {
     expect(errorMessage).to.contains('#1 AWS (Amazon Web Services) Access Key ID'); // type of error
     expect(errorMessage).to.contains('#2 AWS (Amazon Web Services) Access Key ID'); // type of error
     expect(errorMessage).to.contains('#3 Offending Literal');
-
   });
 
   it('A diff including a Google Cloud Platform API Key blocks the proxy...', async () => {
@@ -164,7 +162,9 @@ describe('Scan commit diff...', async () => {
     action.steps = [
       {
         stepName: 'diff',
-        content: generateDiff(`github_pat_1SMAGDFOYZZK3P9ndFemen_${crypto.randomBytes(59).toString('hex')}`),
+        content: generateDiff(
+          `github_pat_1SMAGDFOYZZK3P9ndFemen_${crypto.randomBytes(59).toString('hex')}`,
+        ),
       },
     ];
 
@@ -194,7 +194,9 @@ describe('Scan commit diff...', async () => {
     action.steps = [
       {
         stepName: 'diff',
-        content: generateDiff(`eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ1cm46Z21haWwuY29tOmNsaWVudElkOjEyMyIsInN1YiI6IkphbmUgRG9lIiwiaWF0IjoxNTIzOTAxMjM0LCJleHAiOjE1MjM5ODc2MzR9.s5_hA8hyIT5jXfU9PlXJ-R74m5F_aPcVEFJSV-g-_kX`),
+        content: generateDiff(
+          `eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ1cm46Z21haWwuY29tOmNsaWVudElkOjEyMyIsInN1YiI6IkphbmUgRG9lIiwiaWF0IjoxNTIzOTAxMjM0LCJleHAiOjE1MjM5ODc2MzR9.s5_hA8hyIT5jXfU9PlXJ-R74m5F_aPcVEFJSV-g-_kX`,
+        ),
       },
     ];
 
@@ -220,7 +222,7 @@ describe('Scan commit diff...', async () => {
       expect(errorMessage).to.contains('Your push has been blocked');
     }
   });
-    it('When no diff is present, the proxy is blocked...', async () => {
+  it('When no diff is present, the proxy is blocked...', async () => {
     const action = new Action('1', 'type', 'method', 1, 'project/name');
     action.steps = [
       {
@@ -276,5 +278,3 @@ describe('Scan commit diff...', async () => {
     expect(error).to.be.false;
   });
 });
-
-   
diff --git a/test/testClearBareClone.test.js b/test/testClearBareClone.test.js
index ea3384062..ce31f8a93 100644
--- a/test/testClearBareClone.test.js
+++ b/test/testClearBareClone.test.js
@@ -38,5 +38,5 @@ describe('clear bare and local clones', async () => {
     if (fs.existsSync(`./.remote`)) {
       fs.rmdirSync(`./.remote`, { recursive: true });
     }
-  })
+  });
 });
diff --git a/test/testDb.test.js b/test/testDb.test.js
index 896be0362..45f329e77 100644
--- a/test/testDb.test.js
+++ b/test/testDb.test.js
@@ -50,22 +50,33 @@ const TEST_PUSH = {
  * Clean up response data from the DB by removing an extraneous properties,
  * allowing comparison with expect.
  * @param {object} example Example element from which columns to retain are extracted
- * @param {array} responses Array of responses to clean.
+ * @param {array | object} responses Array of responses to clean.
  * @return {array}  Array of cleaned up responses.
  */
 const cleanResponseData = (example, responses) => {
   const columns = Object.keys(example);
-  return responses.map((response) => {
+
+  if (Array.isArray(responses)) {
+    return responses.map((response) => {
+      const cleanResponse = {};
+      columns.forEach((col) => {
+        cleanResponse[col] = response[col];
+      });
+      return cleanResponse;
+    });
+  } else if (typeof responses === 'object') {
     const cleanResponse = {};
     columns.forEach((col) => {
-      cleanResponse[col] = response[col];
+      cleanResponse[col] = responses[col];
     });
     return cleanResponse;
-  });
+  } else {
+    throw new Error(`Can only clean arrays or objects, but a ${typeof responses}  was passed`);
+  }
 };
 
 // Use this test as a template
-describe('Database client', async () => {
+describe('Database clients', async () => {
   before(async function () {});
 
   it('should be able to create a repo', async function () {
@@ -75,13 +86,106 @@ describe('Database client', async () => {
     expect(cleanRepos).to.deep.include(TEST_REPO);
   });
 
+  it('should be able to filter repos', async function () {
+    // uppercase the filter value to confirm db client is lowercasing inputs
+    const repos = await db.getRepos({ name: TEST_REPO.name.toUpperCase() });
+    const cleanRepos = cleanResponseData(TEST_REPO, repos);
+    expect(cleanRepos[0]).to.eql(TEST_REPO);
+
+    const repos2 = await db.getRepos({ url: TEST_REPO.url });
+    const cleanRepos2 = cleanResponseData(TEST_REPO, repos2);
+    expect(cleanRepos2[0]).to.eql(TEST_REPO);
+
+    // passing an empty query should produce same results as no query
+    const repos3 = await db.getRepos();
+    const repos4 = await db.getRepos({});
+    expect(repos3).to.have.same.deep.members(repos4);
+  });
+
+  it('should be able to retrieve a repo by name', async function () {
+    // uppercase the filter value to confirm db client is lowercasing inputs
+    const repo = await db.getRepo(TEST_REPO.name);
+    const cleanRepo = cleanResponseData(TEST_REPO, repo);
+    expect(cleanRepo).to.eql(TEST_REPO);
+  });
+
   it('should be able to delete a repo', async function () {
     await db.deleteRepo(TEST_REPO.name);
     const repos = await db.getRepos();
+
     const cleanRepos = cleanResponseData(TEST_REPO, repos);
     expect(cleanRepos).to.not.deep.include(TEST_REPO);
   });
 
+  it('should NOT be able to create a repo with blank project, name or url', async function () {
+    // test with a null value
+    let threwError = false;
+    let testRepo = {
+      project: null,
+      name: TEST_REPO.name,
+      url: TEST_REPO.url,
+    };
+    try {
+      await db.createRepo(testRepo);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+
+    // test with an empty string
+    threwError = false;
+    testRepo = {
+      project: '',
+      name: TEST_REPO.name,
+      url: TEST_REPO.url,
+    };
+    try {
+      await db.createRepo(testRepo);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+
+    // test with an undefined property
+    threwError = false;
+    testRepo = {
+      name: TEST_REPO.name,
+      url: TEST_REPO.url,
+    };
+    try {
+      await db.createRepo(testRepo);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+
+    // repeat tests for other fields, but don't both with all variations as they go through same fn
+    threwError = false;
+    testRepo = {
+      project: TEST_REPO.project,
+      name: null,
+      url: TEST_REPO.url,
+    };
+    try {
+      await db.createRepo(testRepo);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+
+    testRepo = {
+      project: TEST_REPO.project,
+      name: TEST_REPO.name,
+      url: null,
+    };
+    try {
+      await db.createRepo(testRepo);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+  });
+
   it('should be able to create a user', async function () {
     await db.createUser(
       TEST_USER.username,
@@ -91,16 +195,36 @@ describe('Database client', async () => {
       TEST_USER.admin,
     );
     const users = await db.getUsers();
-    console.log('TEST USER:', JSON.stringify(TEST_USER, null, 2));
-    console.log('USERS:', JSON.stringify(users, null, 2));
     // remove password as it will have been hashed
     // eslint-disable-next-line no-unused-vars
     const { password: _, ...TEST_USER_CLEAN } = TEST_USER;
     const cleanUsers = cleanResponseData(TEST_USER_CLEAN, users);
-    console.log('CLEAN USERS:', JSON.stringify(cleanUsers, null, 2));
     expect(cleanUsers).to.deep.include(TEST_USER_CLEAN);
   });
 
+  it('should be able to find a user', async function () {
+    const user = await db.findUser(TEST_USER.username);
+    // eslint-disable-next-line no-unused-vars
+    const { password: _, ...TEST_USER_CLEAN } = TEST_USER;
+    // eslint-disable-next-line no-unused-vars
+    const { password: _2, _id: _3, ...DB_USER_CLEAN } = user;
+
+    expect(DB_USER_CLEAN).to.eql(TEST_USER_CLEAN);
+  });
+
+  it('should be able to filter getUsers', async function () {
+    // uppercase the filter value to confirm db client is lowercasing inputs
+    const users = await db.getUsers({ username: TEST_USER.username.toUpperCase() });
+    // eslint-disable-next-line no-unused-vars
+    const { password: _, ...TEST_USER_CLEAN } = TEST_USER;
+    const cleanUsers = cleanResponseData(TEST_USER_CLEAN, users);
+    expect(cleanUsers[0]).to.eql(TEST_USER_CLEAN);
+
+    const users2 = await db.getUsers({ email: TEST_USER.email.toUpperCase() });
+    const cleanUsers2 = cleanResponseData(TEST_USER_CLEAN, users2);
+    expect(cleanUsers2[0]).to.eql(TEST_USER_CLEAN);
+  });
+
   it('should be able to delete a user', async function () {
     await db.deleteUser(TEST_USER.username);
     const users = await db.getUsers();
@@ -108,6 +232,245 @@ describe('Database client', async () => {
     expect(cleanUsers).to.not.deep.include(TEST_USER);
   });
 
+  it('should be able to update a user', async function () {
+    await db.createUser(
+      TEST_USER.username,
+      TEST_USER.password,
+      TEST_USER.email,
+      TEST_USER.gitAccount,
+      TEST_USER.admin,
+    );
+
+    // has less properties to prove that records are merged
+    const updateToApply = {
+      username: TEST_USER.username,
+      gitAccount: 'updatedGitAccount',
+      admin: false,
+    };
+
+    const updatedUser = {
+      // remove password as it will have been hashed
+      username: TEST_USER.username,
+      email: TEST_USER.email,
+      gitAccount: 'updatedGitAccount',
+      admin: false,
+    };
+    await db.updateUser(updateToApply);
+
+    const users = await db.getUsers();
+    const cleanUsers = cleanResponseData(updatedUser, users);
+    expect(cleanUsers).to.deep.include(updatedUser);
+    await db.deleteUser(TEST_USER.username);
+  });
+
+  it('should be able to create a user via updateUser', async function () {
+    await db.updateUser(TEST_USER);
+
+    const users = await db.getUsers();
+    // remove password as it will have been hashed
+    // eslint-disable-next-line no-unused-vars
+    const { password: _, ...TEST_USER_CLEAN } = TEST_USER;
+    const cleanUsers = cleanResponseData(TEST_USER_CLEAN, users);
+    expect(cleanUsers).to.deep.include(TEST_USER_CLEAN);
+    // leave user in place for next test(s)
+  });
+
+  it('should throw an error when authorising a user to push on non-existent repo', async function () {
+    let threwError = false;
+    try {
+      // uppercase the filter value to confirm db client is lowercasing inputs
+      await db.addUserCanPush('non-existent-repo', TEST_USER.username);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+  });
+
+  it('should be able to authorise a user to push and confirm that they can', async function () {
+    let threwError = false;
+    try {
+      // first create the repo and check that user is not allowed to push
+      await db.createRepo(TEST_REPO);
+      let allowed = await db.isUserPushAllowed(TEST_REPO.name, TEST_USER.username);
+      expect(allowed).to.be.false;
+
+      // uppercase the filter value to confirm db client is lowercasing inputs
+      await db.addUserCanPush(TEST_REPO.name.toUpperCase(), TEST_USER.username.toUpperCase());
+
+      // repeat, should not throw an error if already set
+      await db.addUserCanPush(TEST_REPO.name.toUpperCase(), TEST_USER.username.toUpperCase());
+
+      // confirm the setting exists
+      allowed = await db.isUserPushAllowed(TEST_REPO.name, TEST_USER.username);
+      expect(allowed).to.be.true;
+
+      // confirm that casing doesn't matter
+      allowed = await db.isUserPushAllowed(
+        TEST_REPO.name.toUpperCase(),
+        TEST_USER.username.toUpperCase(),
+      );
+      expect(allowed).to.be.true;
+    } catch (e) {
+      console.error('Error thrown ', e);
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+  });
+
+  it('should throw an error when de-authorising a user to push on non-existent repo', async function () {
+    let threwError = false;
+    try {
+      await db.removeUserCanPush('non-existent-repo', TEST_USER.username);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+  });
+
+  it("should be able to de-authorise a user to push and confirm that they can't", async function () {
+    let threwError = false;
+    try {
+      // repo should already exist with user able to push after previous test
+      let allowed = await db.isUserPushAllowed(TEST_REPO.name, TEST_USER.username);
+      expect(allowed).to.be.true;
+
+      // uppercase the filter value to confirm db client is lowercasing inputs
+      await db.removeUserCanPush(TEST_REPO.name.toUpperCase(), TEST_USER.username.toUpperCase());
+
+      // repeat, should not throw an error if already unset
+      await db.removeUserCanPush(TEST_REPO.name.toUpperCase(), TEST_USER.username.toUpperCase());
+
+      // confirm the setting exists
+      allowed = await db.isUserPushAllowed(TEST_REPO.name, TEST_USER.username);
+      expect(allowed).to.be.false;
+
+      // confirm that casing doesn't matter
+      allowed = await db.isUserPushAllowed(
+        TEST_REPO.name.toUpperCase(),
+        TEST_USER.username.toUpperCase(),
+      );
+      expect(allowed).to.be.false;
+    } catch (e) {
+      console.error('Error thrown ', e);
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+  });
+
+  it('should throw an error when authorising a user to authorise on non-existent repo', async function () {
+    let threwError = false;
+    try {
+      await db.addUserCanAuthorise('non-existent-repo', TEST_USER.username);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+  });
+
+  it('should be able to authorise a user to authorise and confirm that they can', async function () {
+    let threwError = false;
+    try {
+      // repo should already exist after a previous test
+      let allowed = await db.canUserApproveRejectPushRepo(TEST_REPO.name, TEST_USER.username);
+      expect(allowed).to.be.false;
+
+      // uppercase the filter value to confirm db client is lowercasing inputs
+      await db.addUserCanAuthorise(TEST_REPO.name.toUpperCase(), TEST_USER.username.toUpperCase());
+
+      // repeat, should not throw an error if already set
+      await db.addUserCanAuthorise(TEST_REPO.name.toUpperCase(), TEST_USER.username.toUpperCase());
+
+      // confirm the setting exists
+      allowed = await db.canUserApproveRejectPushRepo(TEST_REPO.name, TEST_USER.username);
+      expect(allowed).to.be.true;
+
+      // confirm that casing doesn't matter
+      allowed = await db.canUserApproveRejectPushRepo(
+        TEST_REPO.name.toUpperCase(),
+        TEST_USER.username.toUpperCase(),
+      );
+      expect(allowed).to.be.true;
+    } catch (e) {
+      console.error('Error thrown ', e);
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+  });
+
+  it('should throw an error when de-authorising a user to push on non-existent repo', async function () {
+    let threwError = false;
+    try {
+      // uppercase the filter value to confirm db client is lowercasing inputs
+      await db.removeUserCanAuthorise('non-existent-repo', TEST_USER.username);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+  });
+
+  it("should be able to de-authorise a user to authorise and confirm that they can't", async function () {
+    let threwError = false;
+    try {
+      // repo should already exist after a previous test and user should be an authoriser
+      let allowed = await db.canUserApproveRejectPushRepo(TEST_REPO.name, TEST_USER.username);
+      expect(allowed).to.be.true;
+
+      // uppercase the filter value to confirm db client is lowercasing inputs
+      await db.removeUserCanAuthorise(
+        TEST_REPO.name.toUpperCase(),
+        TEST_USER.username.toUpperCase(),
+      );
+
+      // repeat, should not throw an error if already set
+      await db.removeUserCanAuthorise(
+        TEST_REPO.name.toUpperCase(),
+        TEST_USER.username.toUpperCase(),
+      );
+
+      // confirm the setting was removed
+      allowed = await db.canUserApproveRejectPushRepo(TEST_REPO.name, TEST_USER.username);
+      expect(allowed).to.be.false;
+
+      // confirm that casing doesn't matter
+      allowed = await db.canUserApproveRejectPushRepo(
+        TEST_REPO.name.toUpperCase(),
+        TEST_USER.username.toUpperCase(),
+      );
+      expect(allowed).to.be.false;
+    } catch (e) {
+      console.error('Error thrown ', e);
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+  });
+
+  it('should NOT throw an error when checking whether a user can push on non-existent repo', async function () {
+    let threwError = false;
+    try {
+      // uppercase the filter value to confirm db client is lowercasing inputs
+      const allowed = await db.isUserPushAllowed('non-existent-repo', TEST_USER.username);
+      expect(allowed).to.be.false;
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+  });
+
+  it('should NOT throw an error when checking whether a user can authorise on non-existent repo', async function () {
+    let threwError = false;
+    try {
+      // uppercase the filter value to confirm db client is lowercasing inputs
+      const allowed = await db.canUserApproveRejectPushRepo(
+        'non-existent-repo',
+        TEST_USER.username,
+      );
+      expect(allowed).to.be.false;
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+  });
+
   it('should be able to create a push', async function () {
     await db.writeAudit(TEST_PUSH);
     const pushes = await db.getPushes();
@@ -122,5 +485,137 @@ describe('Database client', async () => {
     expect(cleanPushes).to.not.deep.include(TEST_PUSH);
   });
 
-  after(async function () {});
+  it('should be able to authorise a push', async function () {
+    // first create the push
+    await db.writeAudit(TEST_PUSH);
+    let threwError = false;
+    try {
+      const msg = await db.authorise(TEST_PUSH.id);
+      expect(msg).to.have.property('message');
+    } catch (e) {
+      console.error('Error: ', e);
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+    // clean up
+    await db.deletePush(TEST_PUSH.id);
+  });
+
+  it('should throw an error when authorising a non-existent a push', async function () {
+    let threwError = false;
+    try {
+      await db.authorise(TEST_PUSH.id);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+  });
+
+  it('should be able to reject a push', async function () {
+    // first create the push
+    await db.writeAudit(TEST_PUSH);
+    let threwError = false;
+    try {
+      const msg = await db.reject(TEST_PUSH.id);
+      expect(msg).to.have.property('message');
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+    // clean up
+    await db.deletePush(TEST_PUSH.id);
+  });
+
+  it('should throw an error when rejecting a non-existent a push', async function () {
+    let threwError = false;
+    try {
+      await db.reject(TEST_PUSH.id);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+  });
+
+  it('should be able to cancel a push', async function () {
+    // first create the push
+    await db.writeAudit(TEST_PUSH);
+    let threwError = false;
+    try {
+      const msg = await db.cancel(TEST_PUSH.id);
+      expect(msg).to.have.property('message');
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+    // clean up
+    await db.deletePush(TEST_PUSH.id);
+  });
+
+  it('should throw an error when cancelling a non-existent a push', async function () {
+    let threwError = false;
+    try {
+      await db.cancel(TEST_PUSH.id);
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.true;
+  });
+
+  it('should be able to check if a user can cancel push', async function () {
+    let threwError = false;
+    const repoName = TEST_PUSH.repoName.replace('.git', '');
+    try {
+      // push does not exist yet, should return false
+      let allowed = await db.canUserCancelPush(TEST_PUSH.id, TEST_USER.username);
+      expect(allowed).to.be.false;
+
+      // create the push - user should already exist and not authorised to push
+      await db.writeAudit(TEST_PUSH);
+      allowed = await db.canUserCancelPush(TEST_PUSH.id, TEST_USER.username);
+      expect(allowed).to.be.false;
+
+      // authorise user and recheck
+      await db.addUserCanPush(repoName, TEST_USER.username);
+      allowed = await db.canUserCancelPush(TEST_PUSH.id, TEST_USER.username);
+      expect(allowed).to.be.true;
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+    // clean up
+    await db.deletePush(TEST_PUSH.id);
+    await db.removeUserCanPush(repoName, TEST_USER.username);
+  });
+
+  it('should be able to check if a user can approve/reject push', async function () {
+    let threwError = false;
+    const repoName = TEST_PUSH.repoName.replace('.git', '');
+    try {
+      // push does not exist yet, should return false
+      let allowed = await db.canUserApproveRejectPush(TEST_PUSH.id, TEST_USER.username);
+      expect(allowed).to.be.false;
+
+      // create the push - user should already exist and not authorised to push
+      await db.writeAudit(TEST_PUSH);
+      allowed = await db.canUserApproveRejectPush(TEST_PUSH.id, TEST_USER.username);
+      expect(allowed).to.be.false;
+
+      // authorise user and recheck
+      await db.addUserCanAuthorise(repoName, TEST_USER.username);
+      allowed = await db.canUserApproveRejectPush(TEST_PUSH.id, TEST_USER.username);
+      expect(allowed).to.be.true;
+    } catch (e) {
+      threwError = true;
+    }
+    expect(threwError).to.be.false;
+    // clean up
+    await db.deletePush(TEST_PUSH.id);
+    await db.removeUserCanAuthorise(repoName, TEST_USER.username);
+  });
+
+  after(async function () {
+    await db.deleteRepo(TEST_REPO.name);
+    await db.deleteUser(TEST_USER.username);
+    await db.deletePush(TEST_PUSH.id);
+  });
 });
diff --git a/test/testRouteFilter.js b/test/testRouteFilter.js
index 8a0262d13..e9ec026b8 100644
--- a/test/testRouteFilter.js
+++ b/test/testRouteFilter.js
@@ -1,8 +1,7 @@
 /* eslint-disable max-len */
 const chai = require('chai');
 const validGitRequest = require('../src/proxy/routes').validGitRequest;
-const stripGitHubFromGitPath =
-  require('../src/proxy/routes').stripGitHubFromGitPath;
+const stripGitHubFromGitPath = require('../src/proxy/routes').stripGitHubFromGitPath;
 
 chai.should();
 
@@ -10,11 +9,9 @@ const expect = chai.expect;
 
 describe('url filters for proxying ', function () {
   it('stripGitHubFromGitPath should return the sanitized URL with owner & repo removed', function () {
-    expect(
-      stripGitHubFromGitPath(
-        '/octocat/hello-world.git/info/refs?service=git-upload-pack',
-      ),
-    ).eq('/info/refs?service=git-upload-pack');
+    expect(stripGitHubFromGitPath('/octocat/hello-world.git/info/refs?service=git-upload-pack')).eq(
+      '/info/refs?service=git-upload-pack',
+    );
   });
 
   it('stripGitHubFromGitPath should return undefined if the url', function () {