修改数据库加载

back/app.ts

@@ -11,6 +11,8 @@ async function startServer() {
 
   await require('./loaders/sentry').default({ expressApp: app });
 
+  await require('./loaders/db').default();
+
   await require('./loaders/app').default({ expressApp: app });
 
   const server = app

back/loaders/db.ts

@@ -0,0 +1,48 @@
+import DataStore from 'nedb';
+import config from '../config';
+import Logger from './logger';
+
+interface Dbs {
+  cronDb: DataStore;
+  dependenceDb: DataStore;
+  envDb: DataStore;
+  appDb: DataStore;
+  authDb: DataStore;
+}
+
+const db: Dbs = {} as any;
+
+export default () => {
+  db.cronDb = new DataStore({ filename: config.cronDbFile });
+  db.dependenceDb = new DataStore({ filename: config.dependenceDbFile });
+  db.envDb = new DataStore({ filename: config.envDbFile });
+  db.appDb = new DataStore({ filename: config.appDbFile });
+  db.authDb = new DataStore({ filename: config.authDbFile });
+
+  // compaction data file
+  db.cronDb.persistence.compactDatafile();
+  db.envDb.persistence.compactDatafile();
+  db.dependenceDb.persistence.compactDatafile();
+  db.appDb.persistence.compactDatafile();
+  db.authDb.persistence.compactDatafile();
+
+  db.cronDb.loadDatabase((err) => {
+    if (err) throw err;
+  });
+  db.envDb.loadDatabase((err) => {
+    if (err) throw err;
+  });
+  db.dependenceDb.loadDatabase((err) => {
+    if (err) throw err;
+  });
+  db.appDb.loadDatabase((err) => {
+    if (err) throw err;
+  });
+  db.authDb.loadDatabase((err) => {
+    if (err) throw err;
+  });
+
+  Logger.info('✌️ DB loaded');
+};
+
+export const dbs: Dbs = db;

back/loaders/initData.ts

@@ -5,19 +5,14 @@ import { Crontab, CrontabStatus } from '../data/cron';
 import CronService from '../services/cron';
 import EnvService from '../services/env';
 import _ from 'lodash';
+import { dbs } from '../loaders/db';
 
 export default async () => {
   const cronService = Container.get(CronService);
   const envService = Container.get(EnvService);
   const dependenceService = Container.get(DependenceService);
-  const cronDb = cronService.getDb();
+  const cronDb = dbs.cronDb;
-  const envDb = envService.getDb();
+  const dependenceDb = dbs.dependenceDb;
-  const dependenceDb = dependenceService.getDb();
-
-  // compaction data file
-  cronDb.persistence.compactDatafile();
-  envDb.persistence.compactDatafile();
-  dependenceDb.persistence.compactDatafile();
 
   // 初始化更新所有任务状态为空闲
   cronDb.update(

back/schedule.ts

@@ -2,16 +2,14 @@ import schedule from 'node-schedule';
 import express from 'express';
 import { exec } from 'child_process';
 import Logger from './loaders/logger';
-import { Container } from 'typedi';
-import CronService from './services/cron';
 import { CrontabStatus } from './data/cron';
 import config from './config';
+import { dbs } from './loaders/db';
 
 const app = express();
 
 const run = async () => {
-  const cronService = Container.get(CronService);
+  const cronDb = dbs.cronDb;
-  const cronDb = cronService.getDb();
 
   cronDb
     .find({})

back/services/cron.ts

@@ -10,24 +10,17 @@ import { getFileContentByName } from '../config/util';
 import PQueue from 'p-queue';
 import { promises, existsSync } from 'fs';
 import { promisify } from 'util';
+import { dbs } from '../loaders/db';
 
 @Service()
 export default class CronService {
-  private cronDb = new DataStore({ filename: config.cronDbFile });
+  private cronDb = dbs.cronDb;
 
   private queue = new PQueue({
     concurrency: parseInt(process.env.MaxConcurrentNum as string) || 5,
   });
 
-  constructor(@Inject('logger') private logger: winston.Logger) {
+  constructor(@Inject('logger') private logger: winston.Logger) {}
-    this.cronDb.loadDatabase((err) => {
-      if (err) throw err;
-    });
-  }
-
-  public getDb(): DataStore {
-    return this.cronDb;
-  }
 
   private isSixCron(cron: Crontab) {
     const { schedule } = cron;
@@ -427,10 +420,6 @@ export default class CronService {
     this.cronDb.update({}, { $set: { saved: true } }, { multi: true });
   }
 
-  private reload_db() {
-    this.cronDb.loadDatabase();
-  }
-
   public import_crontab() {
     exec('crontab -l', (error, stdout, stderr) => {
       var lines = stdout.split('\n');

back/services/dependence.ts

@@ -12,22 +12,16 @@ import {
 import _ from 'lodash';
 import { spawn } from 'child_process';
 import SockService from './sock';
+import { dbs } from '../loaders/db';
 
 @Service()
 export default class DependenceService {
-  private dependenceDb = new DataStore({ filename: config.dependenceDbFile });
+  private dependenceDb = dbs.dependenceDb;
+
   constructor(
     @Inject('logger') private logger: winston.Logger,
     private sockService: SockService,
-  ) {
+  ) {}
-    this.dependenceDb.loadDatabase((err) => {
-      if (err) throw err;
-    });
-  }
-
-  public getDb(): DataStore {
-    return this.dependenceDb;
-  }
 
   public async create(payloads: Dependence[]): Promise<Dependence[]> {
     const tabs = payloads.map((x) => {

back/services/env.ts

@@ -6,19 +6,13 @@ import * as fs from 'fs';
 import DataStore from 'nedb';
 import { Env, EnvStatus, initEnvPosition } from '../data/env';
 import _ from 'lodash';
+import { dbs } from '../loaders/db';
 
 @Service()
 export default class EnvService {
-  private envDb = new DataStore({ filename: config.envDbFile });
+  private envDb = dbs.envDb;
-  constructor(@Inject('logger') private logger: winston.Logger) {
-    this.envDb.loadDatabase((err) => {
-      if (err) throw err;
-    });
-  }
 
-  public getDb(): DataStore {
+  constructor(@Inject('logger') private logger: winston.Logger) {}
-    return this.envDb;
-  }
 
   public async create(payloads: Env[]): Promise<Env[]> {
     const envs = await this.envs();

back/services/open.ts

@@ -5,19 +5,13 @@ import config from '../config';
 import DataStore from 'nedb';
 import { App } from '../data/open';
 import { v4 as uuidV4 } from 'uuid';
+import { dbs } from '../loaders/db';
 
 @Service()
 export default class OpenService {
-  private appDb = new DataStore({ filename: config.appDbFile });
+  private appDb = dbs.appDb;
-  constructor(@Inject('logger') private logger: winston.Logger) {
-    this.appDb.loadDatabase((err) => {
-      if (err) throw err;
-    });
-  }
 
-  public getDb(): DataStore {
+  constructor(@Inject('logger') private logger: winston.Logger) {}
-    return this.appDb;
-  }
 
   public async findTokenByValue(token: string): Promise<App> {
     return new Promise((resolve) => {

back/services/user.ts

@@ -15,22 +15,19 @@ import ScheduleService from './schedule';
 import { spawn } from 'child_process';
 import SockService from './sock';
 import got from 'got';
+import { dbs } from '../loaders/db';
 
 @Service()
 export default class UserService {
   @Inject((type) => NotificationService)
   private notificationService!: NotificationService;
-  private authDb = new DataStore({ filename: config.authDbFile });
+  private authDb = dbs.authDb;
 
   constructor(
     @Inject('logger') private logger: winston.Logger,
     private scheduleService: ScheduleService,
     private sockService: SockService,
-  ) {
+  ) {}
-    this.authDb.loadDatabase((err) => {
-      if (err) throw err;
-    });
-  }
 
   public async login(
     payloads: {