115 lines
4.4 KiB
TypeScript
115 lines
4.4 KiB
TypeScript
import mongoose from 'mongoose';
|
|
import cfenv from 'cfenv';
|
|
|
|
// mongoose.set('debug', true); // enable mongoose debug
|
|
|
|
// database urls, prod db url is retrieved automatically
|
|
const TESTING_URL = 'mongodb://localhost/dfopdb_test';
|
|
const DEV_URL = 'mongodb://localhost/dfopdb';
|
|
|
|
export default class db {
|
|
private static state = { // db object and current mode (test, dev, prod)
|
|
db: null,
|
|
mode: null,
|
|
};
|
|
|
|
static connect (mode = '', done: Function = () => {}) { // set mode to test for unit/integration tests, otherwise skip parameters. done is also only needed for testing
|
|
if (this.state.db) return done(); // db is already connected
|
|
|
|
// find right connection url
|
|
let connectionString: string = "";
|
|
if (mode === 'test') { // testing
|
|
connectionString = TESTING_URL;
|
|
this.state.mode = 'test';
|
|
}
|
|
else if(process.env.NODE_ENV === 'production') {
|
|
let services = cfenv.getAppEnv().getServices();
|
|
for (let service in services) {
|
|
if(services[service].tags.indexOf("mongodb") >= 0) {
|
|
connectionString = services[service]["credentials"].uri;
|
|
}
|
|
}
|
|
this.state.mode = 'prod';
|
|
}
|
|
else {
|
|
connectionString = DEV_URL;
|
|
this.state.mode = 'dev';
|
|
}
|
|
|
|
// connect to db
|
|
mongoose.connect(connectionString, {useNewUrlParser: true, useUnifiedTopology: true, useCreateIndex: true, connectTimeoutMS: 10000}, err => {
|
|
if (err) done(err);
|
|
});
|
|
mongoose.connection.on('error', console.error.bind(console, 'connection error:'));
|
|
mongoose.connection.on('disconnected', () => { // reset state on disconnect
|
|
console.info('Database disconnected');
|
|
this.state.db = 0;
|
|
done();
|
|
});
|
|
process.on('SIGINT', () => { // close connection when app is terminated
|
|
mongoose.connection.close(() => {
|
|
console.info('Mongoose default connection disconnected through app termination');
|
|
process.exit(0);
|
|
});
|
|
});
|
|
mongoose.connection.once('open', () => {
|
|
mongoose.set('useFindAndModify', false);
|
|
console.info(process.env.NODE_ENV === 'test' ? '' : `Connected to ${connectionString}`);
|
|
this.state.db = mongoose.connection;
|
|
done();
|
|
});
|
|
}
|
|
|
|
static getState () {
|
|
return this.state;
|
|
}
|
|
|
|
static drop (done: Function = () => {}) { // drop all collections of connected db (only dev and test for safety reasons ;)
|
|
if (!this.state.db || this.state.mode === 'prod') return done(); // no db connection or prod db
|
|
this.state.db.db.listCollections().toArray((err, collections) => { // get list of all collections
|
|
if (collections.length === 0) { // there are no collections to drop
|
|
return done();
|
|
}
|
|
else {
|
|
let dropCounter = 0; // count number of dropped collections to know when to return done()
|
|
collections.forEach(collection => { // drop each collection
|
|
this.state.db.dropCollection(collection.name, () => {
|
|
if (++ dropCounter >= collections.length) { // all collections dropped
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
static loadJson (json, done: Function = () => {}) { // insert given JSON data into db, uses core mongodb methods
|
|
if (!this.state.db || !json.hasOwnProperty('collections') || json.collections.length === 0) { // no db connection or nothing to load
|
|
return done();
|
|
}
|
|
|
|
let loadCounter = 0; // count number of loaded collections to know when to return done()
|
|
Object.keys(json.collections).forEach(collectionName => { // create each collection
|
|
json.collections[collectionName] = this.oidResolve(json.collections[collectionName]);
|
|
this.state.db.createCollection(collectionName, (err, collection) => {
|
|
collection.insertMany(json.collections[collectionName], () => { // insert JSON data
|
|
if (++ loadCounter >= Object.keys(json.collections).length) { // all collections loaded
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
private static oidResolve (object: any) { // resolve $oid fields to actual ObjectIds recursively
|
|
Object.keys(object).forEach(key => {
|
|
if (object[key] !== null && object[key].hasOwnProperty('$oid')) { // found oid, replace
|
|
object[key] = mongoose.Types.ObjectId(object[key].$oid);
|
|
}
|
|
else if (typeof object[key] === 'object' && object[key] !== null) { // deeper into recursion
|
|
object[key] = this.oidResolve(object[key]);
|
|
}
|
|
});
|
|
return object;
|
|
}
|
|
}; |