fix: neDB implementation issues

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"
   },

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
     }
   ],

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,
 };

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);

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,15 +49,28 @@ 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: [],
   };
 
   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);