lowgoose v0.0.3
Lowgoose
lowdb mongoose-like wrapper
Install
npm install lowgoose
Usage
const lowgoose = require('lowgoose')
lowgoose.open('db.json')
const Schema = new lowgoose.sch({
name: {
first: {
type: String,
required: true
},
last: {
type: String,
required: true
}
},
age: {
type: Number
},
email: {
type: String,
unique: true
}
})
Schema.methods.fullName = function() {
let self = this
return `${self.name.first} ${self.name.last}`
}
const Collection = lowgoose.col('people', Schema)
let Document = new lowgoose.col.people({
name: {
first: 'Rick',
last: 'Taylor'
},
age: 24,
email: 'rick@google.com'
})
Document.fullName() // Rick Taylor
Why
Although lowdb is a champ all by itself, I really missed having schema's and other things I'd get from mongoose.
If you know anything about lowdb, you'll know that I haven't included almost any of the cool stuff it provides, I'm slowly adding features but also trying to keep it very mongoose-like.
Overview
Generally speaking, lowgoose tries to emulate the mongoose odm wrapper for lowdb.
Lowgoose is not production ready.
Most things will return a Document
or an Error
, unlike mongoose or lowdb there's currently no callbacks, chaining or promises. This isn't by design, I couldn't figure out a nice way to tie in the validator with chains or promises, feel free to make a PR to add this.
If something doesn't work the same way as it does in mongoose and isn't documented here, don't worry, it's probably just an undocumented feature.
Also, incase the names are confusing you:
sch === Schema
col === Collection
doc === Document
Open
lowgoose.open(filename)
The lowgoose.open()
function will set lowgoose.database
as a lowdb
database instance and also return that instance.
const lowgoose = require('lowgoose')
const database = lowgoose.open('db.json')
// database === low('db.json')
You can use that reference or lowgoose.database
to do all the things you normally would with lowdb
.
Schema
lowgoose.sch(Schema)
Similar to mongoose, schemas are defined with objects.
Define
const Schema = new lowgoose.sch({
name: {
type: String,
required: true
},
...
})
Validation
Similar to mongoose, performing validation will return Error
objects, not throw
them.
Custom validation is not implemented, the validation process will need to be cleaned up before this is added.
type
Supports: [String, Number, Boolean, Object, Array, [String], [Number] ...]
Error: [prop].constructor.name !== type
Example: { type: Number }
unique
Supports: [true, false]
Error: [col].find({ prop: value }).length > 0
Example: { unique: true }
required
Supports: [true, false]
Error: value === undefined
Example: { required: true }
enum
Supports: [[String], [Number], [Boolean(ಠ_ಠ)]]
Error: enum.indexOf(value) < 0
Example: { enum: ['left', 'right', 'up', 'down'] }
min
Supports: [1, 2, 3, ...]
Error: value < min
Example: { min: 10 }
max
Supports: [1, 2, 3, ...]
Errors: value > max
Example: { max: 20 }
minlength
Supports: [1, 2, 3, ...]
Error: value.length < minlength
Example: { minlength: 4 }
maxlength
Supports: [1, 2, 3, ...]
Error: value.length > maxlength
Example: { maxlength: 16 }
ref
Supports: [String]
Error: [prop].constructor.name !== type
Example: { ref: 'people' }
References to other collections are tricky, there isn't any validation to check if the ref
collection exists.. References support both single and array type
values.
Statics
Similar to mongoose, statics are stored at lowgoose.col.myCol.prototype[static]
or any reference to a lowgoose.col()
function.
const Schema = new lowgoose.sch({ ... })
Schema.statics.myStatic = function() { ... }
const Collection = lowgoose.col('myCol', Schema)
Collection.myStatic()
// or
lowgoose.col.myCol.myStatic()
Methods
Similar to mongoose, methods are available at Document.prototype[method]
const Schema = new lowgoose.sch({ ... })
Schema.methods.myMethod = function() { ... }
const Collection = lowgoose.col('myCol', Schema)
let Document = new lowgoose.col.myCol({ ... })
Document.myMethod()
Collection
lowgoose.col(name, Schema)
Sort of similar to a mongoose model
, use collections to group documents.
To create a collection, first define a Schema
and then pass it into the lowgoose.col()
function along with a name.
const Schema = new lowgoose.sch({ ... })
const Collection = lowgoose.col('myCol', Schema)
The collection above can be referenced via the Collection
constant or lowgoose.col.myCol
, from here you can access all of the custom and default Schema
statics.
When you execute logoose.col()
it sets a new default on lowdb with the collection name.
Default Statics
find(query)
Returns an array of Document
objects.
Uses the lowdb filter()
function.
lowgoose.col.myCol.find({ name: 'Jason' })
update(query, changes)
Returns an array of updated Document
objects.
Uses the lowdb filter()
function, then iterates over each Document
, applies the changes
and finally performs a save()
.
lowgoose.col.myCol.update({ age: 20 }, { teenager: false })
remove(query)
Returns an array of removed Document
objects.
Uses the lowdb remove()
function.
lowgoose.col.myCol.remove({ age: 20 })
Document
#####lowgoose.col[col]({ ... })
Similar to mongoose, documents are provided as objects constructed from the Schema.
Documents are not undef safe, assign properties with care.
ID
By default, a uuid
will be set at Document.id
, you can override the id
value at any time - just make sure it's unique. You can use a Number
if you want but I don't test for it so your milage may vary.
Internally this ID
value is used a lot to reference documents for things like removing, updating and finding, so if you muck it up - you'll know.
Default Methods
save()
Returns the Document
object.
Uses the lowdb filter()
function to find and update an existing document using the Document.id
or the lowdb push()
function for a new document.
let Document = new lowgoose.col.myCol({ ... })
// or
let Document = lowgoose.col.myCol.find({ ... })[0]
Document.save()
remove()
Returns the removed Document
object.
Uses the lowdb remove()
function based on the Document.id
.
let Document = new lowgoose.col.myCol({ ... })
// or
let Document = lowgoose.col.myCol.find({ ... })[0]
Document.remove()
validate()
Returns the validation result of a Document
object.
Uses the internal Document.validator()
function.
let Document = new lowgoose.col.myCol({ ... })
Document.validate() // Error or Document
toObject()
Returns a plain old javascript object of the Document
.
Uses the recursiveDeepCopy()
function from jsperf.
let Document = new lowgoose.col.myCol({ ... })
let pojo = Document.toObject()
pojo.save() // TypeError: pojo.save is not a function
populate(path || [path1, path2])
Returns the Document
with populated references.
Accepts a String
or [String]
of paths to populate.
Uses lowdb find()
based on the Schema ref
value and Document.id
value.
let Document = new lowgoose.col.myCol({ ... })
let Populated = Document.populate('friends')
// or
let Populated = Document.populate(['friends', 'enemies']])