forked from bookshelf/bookshelf
-
Notifications
You must be signed in to change notification settings - Fork 0
/
bookshelf.js
123 lines (100 loc) · 4.38 KB
/
bookshelf.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
// Bookshelf.js 0.5.7
// ---------------
// (c) 2013 Tim Griesser
// Bookshelf may be freely distributed under the MIT license.
// For all details and documentation:
// http://bookshelfjs.org
(function(define) {
"use strict";
define(function(require, exports, module) {
// All external libraries needed in this scope.
var _ = require('underscore');
var Knex = require('knex');
// All local dependencies... These are the main objects that
// need to be augmented in the constructor to work properly.
var SqlModel = require('./dialects/sql/model').Model;
var SqlCollection = require('./dialects/sql/collection').Collection;
var SqlRelation = require('./dialects/sql/relation').Relation;
// Finally, the `Events`, which we've supplemented with a `triggerThen`
// method to allow for asynchronous event handling via promises. We also
// mix this into the prototypes of the main objects in the library.
var Events = require('./dialects/base/events').Events;
// Constructor for a new `Bookshelf` object, it accepts
// an active `knex` instance and initializes the appropriate
// `Model` and `Collection` constructors for use in the current instance.
var Bookshelf = function(knex) {
// Allows you to construct the library with either `Bookshelf(opts)`
// or `new Bookshelf(opts)`.
if (!(this instanceof Bookshelf)) {
return new Bookshelf(knex);
}
// If the knex isn't a `Knex` instance, we'll assume it's
// a compatible config object and pass it through to create a new instance.
if (!knex.client || !(knex.client instanceof Knex.ClientBase)) {
knex = new Knex(knex);
}
// The `Model` constructor is referenced as a property on the `Bookshelf` instance,
// mixing in the correct `builder` method, as well as the `relation` method,
// passing in the correct `Model` & `Collection` constructors for later reference.
var ModelCtor = this.Model = SqlModel.extend({
_builder: function(tableName) {
return knex(tableName);
},
_relation: function(type, Target, options) {
return new Relation(type, Target, options);
}
});
// The collection also references the correct `Model`, specified above, for creating
// new `Model` instances in the collection. We also extend with the correct builder /
// `knex` combo.
var CollectionCtor = this.Collection = SqlCollection.extend({
model: ModelCtor,
_builder: function(tableName) {
return knex(tableName);
}
});
// Used internally, the `Relation` helps in simplifying the relationship building,
// centralizing all logic dealing with type & option handling.
var Relation = Bookshelf.Relation = SqlRelation.extend({
Model: ModelCtor,
Collection: CollectionCtor
});
// Grab a reference to the `knex` instance passed (or created) in this constructor,
// for convenience.
this.knex = knex;
};
// A `Bookshelf` instance may be used as a top-level pub-sub bus, as it mixes in the
// `Events` object. It also contains the version number, and a `Transaction` method
// referencing the correct version of `knex` passed into the object.
_.extend(Bookshelf.prototype, Events, {
// Keep in sync with `package.json`.
VERSION: '0.5.7',
// Helper method to wrap a series of Bookshelf actions in a `knex` transaction block;
transaction: function() {
return this.knex.transaction.apply(this, arguments);
},
// Provides a nice, tested, standardized way of adding plugins to a `Bookshelf` instance,
// injecting the current instance into the plugin, which should be a module.exports.
plugin: function(plugin) {
plugin(this);
return this;
}
});
// Alias to `new Bookshelf(opts)`.
Bookshelf.initialize = function(knex) {
return new this(knex);
};
// The `forge` function properly instantiates a new Model or Collection
// without needing the `new` operator... to make object creation cleaner
// and more chainable.
SqlModel.forge = SqlCollection.forge = function() {
var inst = Object.create(this.prototype);
var obj = this.apply(inst, arguments);
return (Object(obj) === obj ? obj : inst);
};
// Finally, export `Bookshelf` to the world.
module.exports = Bookshelf;
});
})(
typeof define === 'function' && define.amd ? define : function (factory) { factory(require, exports, module); }
);