refactor(ts): change file db module to TS and ESM

Author: jescalada

src/db/file/index.js

@@ -0,0 +1,35 @@
+import * as users from './users';
+import * as repo from './repo';
+import * as pushes from './pushes';
+
+export const {
+  getPushes,
+  writeAudit,
+  getPush,
+  authorise,
+  cancel,
+  reject,
+  canUserCancelPush,
+  canUserApproveRejectPush,
+} = pushes;
+
+export const {
+  getRepos,
+  getRepo,
+  createRepo,
+  addUserCanPush,
+  addUserCanAuthorise,
+  removeUserCanPush,
+  removeUserCanAuthorise,
+  deleteRepo,
+  isUserPushAllowed,
+  canUserApproveRejectPushRepo,
+} = repo;
+
+export const {
+  findUser,
+  getUsers,
+  createUser,
+  deleteUser,
+  updateUser,
+} = users;

src/db/file/index.ts

@@ -1,26 +1,27 @@
-const fs = require('fs');
-const _ = require('lodash');
-const Datastore = require('@seald-io/nedb');
-const Action = require('../../proxy/actions/Action').Action;
-const toClass = require('../helper').toClass;
-const repo = require('./repo');
+import fs from 'fs';
+import _ from 'lodash';
+import Datastore from '@seald-io/nedb';
+import { Action } from '../../proxy/actions/Action';
+import { toClass } from '../helper';
+import * as repo from './repo';
+import { PushQuery } from '../types'
 
 if (!fs.existsSync('./.data')) fs.mkdirSync('./.data');
 if (!fs.existsSync('./.data/db')) fs.mkdirSync('./.data/db');
 
 const db = new Datastore({ filename: './.data/db/pushes.db', autoload: true });
 
-const defaultPushQuery = {
+const defaultPushQuery: PushQuery = {
   error: false,
   blocked: true,
   allowPush: false,
   authorised: false,
 };
 
-const getPushes = (query, logger) => {
+export const getPushes = (query: PushQuery) => {
   if (!query) query = defaultPushQuery;
   return new Promise((resolve, reject) => {
-    db.find(query, (err, docs) => {
+    db.find(query, (err: Error, docs: Action[]) => {
       if (err) {
         reject(err);
       } else {
@@ -34,8 +35,8 @@ const getPushes = (query, logger) => {
   });
 };
 
-const getPush = async (id, logger) => {
-  return new Promise((resolve, reject) => {
+export const getPush = async (id: string) => {
+  return new Promise<Action | null>((resolve, reject) => {
     db.findOne({ id: id }, (err, doc) => {
       if (err) {
         reject(err);
@@ -50,7 +51,7 @@ const getPush = async (id, logger) => {
   });
 };
 
-const writeAudit = async (action, logger) => {
+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) => {
@@ -63,8 +64,12 @@ const writeAudit = async (action, logger) => {
   });
 };
 
-const authorise = async (id, attestation) => {
+export const authorise = async (id: string, attestation: any) => {
   const action = await getPush(id);
+  if (!action) {
+    throw new Error(`push ${id} not found`);
+  }
+
   action.authorised = true;
   action.canceled = false;
   action.rejected = false;
@@ -73,28 +78,39 @@ const authorise = async (id, attestation) => {
   return { message: `authorised ${id}` };
 };
 
-const reject = async (id, logger) => {
-  const action = await getPush(id, logger);
+export const reject = async (id: string) => {
+  const action = await getPush(id);
+  if (!action) {
+    throw new Error(`push ${id} not found`);
+  }
+
   action.authorised = false;
   action.canceled = false;
   action.rejected = true;
   await writeAudit(action);
   return { message: `reject ${id}` };
 };
 
-const cancel = async (id, logger) => {
-  const action = await getPush(id, logger);
+export const cancel = async (id: string) => {
+  const action = await getPush(id);
+  if (!action) {
+    throw new Error(`push ${id} not found`);
+  }
   action.authorised = false;
   action.canceled = true;
   action.rejected = false;
   await writeAudit(action);
   return { message: `cancel ${id}` };
 };
 
-const canUserCancelPush = async (id, user) => {
-  return new Promise(async (resolve) => {
+export const canUserCancelPush = async (id: string, user: any) => {
+  return new Promise<boolean>(async (resolve) => {
     const pushDetail = await getPush(id);
-    const repoName = pushDetail.repoName.replace('.git', '');
+    if (!pushDetail) {
+      resolve(false);
+    }
+
+    const repoName = pushDetail?.repoName.replace('.git', '');
     const isAllowed = await repo.isUserPushAllowed(repoName, user);
 
     if (isAllowed) {
@@ -105,21 +121,15 @@ const canUserCancelPush = async (id, user) => {
   });
 };
 
-const canUserApproveRejectPush = async (id, user) => {
-  return new Promise(async (resolve) => {
+export const canUserApproveRejectPush = async (id: string, user: any) => {
+  return new Promise<boolean>(async (resolve) => {
     const action = await getPush(id);
-    const repoName = action.repoName.replace('.git', '');
+    if (!action) {
+      resolve(false);
+    }
+    const repoName = action?.repoName.replace('.git', '');
     const isAllowed = await repo.canUserApproveRejectPushRepo(repoName, user);
 
     resolve(isAllowed);
   });
 };
-
-module.exports.getPushes = getPushes;
-module.exports.writeAudit = writeAudit;
-module.exports.getPush = getPush;
-module.exports.authorise = authorise;
-module.exports.reject = reject;
-module.exports.cancel = cancel;
-module.exports.canUserCancelPush = canUserCancelPush;
-module.exports.canUserApproveRejectPush = canUserApproveRejectPush;

src/db/file/pushes.js renamed to src/db/file/pushes.ts

@@ -1,14 +1,16 @@
-const fs = require('fs');
-const Datastore = require('@seald-io/nedb');
+import fs from 'fs';
+import Datastore from '@seald-io/nedb'
+import { Action } from '../../proxy/actions/Action';
+import { Repo } from '../types';
 
 if (!fs.existsSync('./.data')) fs.mkdirSync('./.data');
 if (!fs.existsSync('./.data/db')) fs.mkdirSync('./.data/db');
 
 const db = new Datastore({ filename: './.data/db/repos.db', autoload: true });
 
-exports.getRepos = async (query = {}) => {
-  return new Promise((resolve, reject) => {
-    db.find({}, (err, docs) => {
+export const getRepos = async (query = {}) => {
+  return new Promise<Repo[]>((resolve, reject) => {
+    db.find({}, (err: Error, docs: Repo[]) => {
       if (err) {
         reject(err);
       } else {
@@ -18,29 +20,26 @@ exports.getRepos = async (query = {}) => {
   });
 };
 
-exports.getRepo = async (name) => {
-  return new Promise((resolve, reject) => {
-    db.findOne({ name: name }, (err, doc) => {
+export const getRepo = async (name: string) => {
+  return new Promise<Repo | null>((resolve, reject) => {
+    db.findOne({ name }, (err: Error | null, doc: Repo) => {
       if (err) {
         reject(err);
       } else {
-        if (!doc) {
-          resolve(null);
-        } else {
-          resolve(doc);
-        }
+        resolve(doc);
       }
     });
   });
 };
 
-exports.createRepo = async (repo) => {
+
+export const createRepo = async (repo: Repo) => {
   repo.users = {
     canPush: [],
     canAuthorise: [],
   };
 
-  return new Promise((resolve, reject) => {
+  return new Promise<Repo>((resolve, reject) => {
     db.insert(repo, (err, doc) => {
       if (err) {
         reject(err);
@@ -51,9 +50,13 @@ exports.createRepo = async (repo) => {
   });
 };
 
-exports.addUserCanPush = async (name, user) => {
+export const addUserCanPush = async (name: string, user: string) => {
   return new Promise(async (resolve, reject) => {
-    const repo = await exports.getRepo(name);
+    const repo = await getRepo(name);
+    if (!repo) {
+      reject(new Error('Repo not found'));
+      return;
+    }
 
     if (repo.users.canPush.includes(user)) {
       resolve(null);
@@ -72,9 +75,13 @@ exports.addUserCanPush = async (name, user) => {
   });
 };
 
-exports.addUserCanAuthorise = async (name, user) => {
+export const addUserCanAuthorise = async (name: string, user: string) => {
   return new Promise(async (resolve, reject) => {
-    const repo = await exports.getRepo(name);
+    const repo = await getRepo(name);
+    if (!repo) {
+      reject(new Error('Repo not found'));
+      return;
+    }
 
     if (repo.users.canAuthorise.includes(user)) {
       resolve(null);
@@ -94,11 +101,15 @@ exports.addUserCanAuthorise = async (name, user) => {
   });
 };
 
-exports.removeUserCanAuthorise = async (name, user) => {
+export const removeUserCanAuthorise = async (name: string, user: string) => {
   return new Promise(async (resolve, reject) => {
-    const repo = await exports.getRepo(name);
+    const repo = await getRepo(name);
+    if (!repo) {
+      reject(new Error('Repo not found'));
+      return;
+    }
 
-    repo.users.canAuthorise = repo.users.canAuthorise.filter((x) => x != user);
+    repo.users.canAuthorise = repo.users.canAuthorise.filter((x: string) => x != user);
 
     const options = { multi: false, upsert: false };
     db.update({ name: name }, repo, options, (err) => {
@@ -111,9 +122,13 @@ exports.removeUserCanAuthorise = async (name, user) => {
   });
 };
 
-exports.removeUserCanPush = async (name, user) => {
+export const removeUserCanPush = async (name: string, user: string) => {
   return new Promise(async (resolve, reject) => {
-    const repo = await exports.getRepo(name);
+    const repo = await getRepo(name);
+    if (!repo) {
+      reject(new Error('Repo not found'));
+      return;
+    }
 
     repo.users.canPush = repo.users.canPush.filter((x) => x != user);
 
@@ -128,8 +143,8 @@ exports.removeUserCanPush = async (name, user) => {
   });
 };
 
-exports.deleteRepo = async (name) => {
-  return new Promise((resolve, reject) => {
+export const deleteRepo = async (name: string) => {
+  return new Promise<void>((resolve, reject) => {
     db.remove({ name: name }, (err) => {
       if (err) {
         reject(err);
@@ -140,9 +155,9 @@ exports.deleteRepo = async (name) => {
   });
 };
 
-exports.isUserPushAllowed = async (name, user) => {
+export const isUserPushAllowed = async (name: string, user: string) => {
   name = name.toLowerCase();
-  return new Promise(async (resolve, reject) => {
+  return new Promise<boolean>(async (resolve, reject) => {
     const repo = await exports.getRepo(name);
     console.log(repo.users.canPush);
     console.log(repo.users.canAuthorise);
@@ -155,10 +170,10 @@ exports.isUserPushAllowed = async (name, user) => {
   });
 };
 
-exports.canUserApproveRejectPushRepo = async (name, user) => {
+export const canUserApproveRejectPushRepo = async (name: string, user: string) => {
   name = name.toLowerCase();
   console.log(`checking if user ${user} can approve/reject for ${name}`);
-  return new Promise(async (resolve, reject) => {
+  return new Promise<boolean>(async (resolve, reject) => {
     const repo = await exports.getRepo(name);
     if (repo.users.canAuthorise.includes(user)) {
       console.log(`user ${user} can approve/reject to repo ${name}`);