@hvedinich/db 1.0.0-beta.1 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hvedinich/db",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.1",
   "description": "db",
   "main": "index.js",
   "scripts": {
@@ -17,7 +17,7 @@
   },
   "homepage": "https://github.com/hvedinich/DB#readme",
   "dependencies": {
-    "mongoose": "^5.13.15"
+    "mongoose": "^7.6.3"
   },
   "devDependencies": {
     "eslint": "^7.32.0",

package/src/index.js

@@ -1,41 +1,60 @@
 const mongoose = require('mongoose');
 const migration = require('./migration');
 
-const init = config => {
+const init = ({ config, setStatus }) => {
   const db = mongoose.connection;
-  const retry = 0;
+
+  const maxCount = 30;
+  let retry = 0;
+  let timerId;
+
   const state = { connected: false };
   const opt = {
     useNewUrlParser: true,
-    auto_reconnect: true,
     dbName: config.serviceName,
-    useCreateIndex: true,
     useUnifiedTopology: true,
-    useFindAndModify: false,
   };
-  mongoose.connect(config.mongo.url, opt);
+  mongoose.connect(config.mongo.url, opt).catch(err => {
+    if (retry >= maxCount) {
+      setStatus(false);
+    }
+    console.log(`consction error: ${err}`);
+  });
+
   db.on('disconnected', async () => {
     state.connected = false;
-    if (retry < 10) {
-      await new Promise(res => setTimeout(res, 1000));
-      await mongoose.connect(config.mongo.url, opt);
-    }
-    console.log('Can not connect to mongo');
+    timerId = setInterval(() => {
+      retry += 1;
+      console.log(`Can not connect to mongo retry: ${retry}`);
+      if (retry >= maxCount) {
+        clearInterval(timerId);
+        timerId = undefined;
+        retry = 0;
+        setStatus(false);
+      }
+    }, 1000);
   });
 
   db.on('error', () => {
     console.log('connection error:');
     mongoose.disconnect();
   });
-  db.once('open', () => {
-    console.log(`Mongo conected to ${config.mongo.url}`);
+  db.on('open', () => {
+    console.log('Mongo is connected');
     state.connected = true;
+    if (timerId) {
+      clearInterval(timerId);
+      timerId = undefined;
+    }
+
+    setStatus(true);
+    retry = 0;
   });
 
   const createModel = ({ name, schema }) => mongoose.model(name, schema);
 
   const runMigrations = (migrations, log = console) =>
-    migration.run(createModel, config.serviceName, migrations, log, state);
+    migration.run(createModel, config.serviceName, migrations, log, state, setStatus);
 
   return {
     createModel,

package/src/migration/index.js

@@ -1,71 +1,71 @@
 /* eslint-disable no-await-in-loop */
 const schema = require('./schema');
 
+const run = async (createModel, serviceName, migrations = [], log, state, setStatus) => {
+  log.debug('Migration: waiting for connection');
+  let count = 0;
+  const maxCount = 60;
 
-const getOrWait = async (model, serviceName, log) => {
-  let waiting = true;
-  let result = { version: 0 };
-  while (waiting) {
-    log.debug('getOrWait: waiting for db');
-    const currentMigration = await model.findOne({ serviceName }).lean().exec();
-    if (currentMigration) {
-      if (!currentMigration.inProgress) {
-        const updated = await model.findOneAndUpdate(
-          { serviceName, inProgress: false },
-          { $set: { inProgress: true } },
-          { new: true },
-        );
-        if (updated) {
-          waiting = false;
-          result = currentMigration;
-        }
-      }
-      await new Promise(res => setTimeout(res, 1000));
-    } else {
-      waiting = false;
-    }
+  while (!state.connected) {
+    count += 1;
+    if (count >= maxCount) setStatus(false);
+
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise(res => setTimeout(res, 1000));
+    console.log(`while (!state.connected)${count}`);
   }
-  return result;
-};
 
-const run = async (createModel, serviceName, migrations = [], log, state) => {
-  log.debug('Migration: waiting for connection');
-  await new Promise(async (done) => {
-    while (!state.connected) {
-      // eslint-disable-next-line no-await-in-loop
-      await new Promise(res => setTimeout(res, 100));
-    }
-    done();
-  });
   log.debug('Migration: Start');
   const model = createModel({ name: 'Migration', schema });
-  try {
-    const currentMigration = await getOrWait(model, serviceName, log);
 
-    log.debug(`Migration: last version ${currentMigration.version}`);
-    const migrationToDo = migrations.filter(e => e.version > currentMigration.version);
+  const migrationList = await model.find({}).lean();
+  if (migrationList.length > 1) {
+    throw new Error('The migration fails due to an incorrect number of migration objects.');
+  }
+  const currentMigration =
+    migrationList[0] || (await model.create({ serviceName, startTime: Date.now() + 60000 * 10 }));
+  const isPrevMigrationStuck = currentMigration.inProgress && (currentMigration.startTime || 0) < Date.now();
+
+  if (isPrevMigrationStuck) {
+    log.error(`Previous migration stuck`);
+  }
 
-    for (let i = 0; i < migrationToDo.length; i += 1) {
-      log.debug(`Migration: update from ${currentMigration.version} to ${migrationToDo[i].version}`);
-      await migrationToDo[i].run();
+  if (!currentMigration.inProgress || isPrevMigrationStuck) {
+    try {
+      const currentVersion = currentMigration.version || 0;
+      log.debug(`Migration: last version ${currentVersion}`);
+      await model.updateOne({ serviceName }, { $set: { inProgress: true } }).lean();
 
-      await model.updateOne(
-        { serviceName },
-        {
-          $set: { version: migrationToDo[i].version },
-          $push: { history: { version: migrationToDo[i].version } },
-        },
-        { upsert: true },
-      ).lean();
+      const migrationToDo = migrations.filter(e => e.version > currentVersion);
+
+      for (let i = 0; i < migrationToDo.length; i += 1) {
+        log.debug(`Migration: update from ${currentVersion} to ${migrationToDo[i].version}`);
+        await migrationToDo[i].run();
+
+        await model
+          .updateOne(
+            { serviceName },
+            {
+              $set: { version: migrationToDo[i].version },
+              $push: { history: { version: migrationToDo[i].version } },
+            },
+            { upsert: true },
+          )
+          .lean();
+      }
+      log.debug('Migration: migrations are done');
+    } finally {
+      await model
+        .updateOne(
+          { serviceName },
+          {
+            $set: { inProgress: false },
+          },
+        )
+        .lean();
     }
-    log.debug('Migration: migrations are done');
-  } finally {
-    await model.updateOne(
-      { serviceName, inProgress: true },
-      {
-        $set: { inProgress: false },
-      },
-    ).lean();
+  } else if (!isPrevMigrationStuck) {
+    log.debug('Migration is being performed by another instance');
   }
 };