multiple.db/index.js

multiple database mongodb and json

const mongoose = require('mongoose');
const fs = require('fs');
const path = require('path');
const colors = require('colors');

let storageType = 'json';
let dataPath;
let data = {};
let dataChanged = false;

function initializeJsonFile() {
  dataPath = path.resolve('data.json');
  if (!fs.existsSync(dataPath) && storageType === 'json') {
    fs.writeFileSync(dataPath, "{}");
  }
}

function readData() {
  try {
    data = JSON.parse(fs.readFileSync(dataPath).toString());
  } catch (error) {
    data = {};
  }
}

function writeData() {
  fs.writeFileSync(dataPath, JSON.stringify(data));
}

const dataSchema = new mongoose.Schema({
  key: String,
  value: mongoose.Mixed,
});

const Data = mongoose.model('Data', dataSchema);

async function connect(uri) {
  mongoose.set('strictQuery', true);
  await mongoose.connect(uri).then(() => {
    console.log('Connected to MongoDB'.green);
    storageType = 'mongoose';
    initializeJsonFile(); // Move the initialization here
  }).catch((err) => {
    throw new Error("MongoDB connection error: " + err);
  });
}

async function add(key, value) {
  if (storageType === 'json') {
    data[key] = (data[key] || 0) + value;
    dataChanged = true;
  } else {
    const doc = await Data.findOneAndUpdate({ key }, { $inc: { value } }, { upsert: true, new: true }).exec();
    return doc ? doc.value : value;
  }
}

async function subtract(key, value) {
  return add(key, -value);
}

async function set(key, value) {
  if (storageType === 'json') {
    if (!dataPath) {
      initializeJsonFile(); // Make sure dataPath is initialized
    }
    data[key] = value;
    dataChanged = true;
  } else {
    const doc = await Data.findOneAndUpdate({ key }, { value }, { upsert: true, new: true }).exec();
    return doc ? doc.value : value;
  }
}

async function get(key) {
  if (storageType === 'json') {
    return data[key];
  } else {
    const doc = await Data.findOne({ key }).exec();
    return doc ? doc.value : undefined;
  }
}

async function deleteKey(key) {
  if (storageType === 'json') {
    const value = data[key];
    delete data[key];
    dataChanged = true;
    return value;
  } else {
    const doc = await Data.findOneAndDelete({ key }).exec();
    return doc ? doc.value : undefined;
  }
}

async function has(key) {
  if (storageType === 'json') {
    return data.hasOwnProperty(key);
  } else {
    const doc = await Data.findOne({ key }).exec();
    return !!doc;
  }
}

async function all() {
  if (storageType === 'json') {
    return Object.entries(data).map(([key, value]) => ({ key, value }));
  } else {
    const docs = await Data.find().exec();
    return docs.map(doc => ({ key: doc.key, value: doc.value }));
  }
}

async function fetch(key) {
  return get(key);
}

async function reset() {
  if (storageType === 'json') {
    data = {};
    dataChanged = true;
  } else {
    await Data.deleteMany({});
  }
}

function save() {
  if (dataChanged && storageType === 'json') {
    writeData();
    dataChanged = false;
  }
}

setInterval(save, 1000);
readData();

module.exports = {
  connect,
  add,
  subtract,
  set,
  get,
  delete: deleteKey,
  has,
  all,
  fetch,
  reset,
};