/
make-knex.js
127 lines (98 loc) · 2.92 KB
/
make-knex.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
124
125
126
127
import { EventEmitter } from 'events';
import Migrator from '../migrate';
import Seeder from '../seed';
import FunctionHelper from '../functionhelper';
import QueryInterface from '../query/methods';
import * as helpers from '../helpers';
import { assign } from 'lodash'
import BatchInsert from './batchInsert';
export default function makeKnex(client) {
// The object we're potentially using to kick off an initial chain.
function knex(tableName) {
const qb = knex.queryBuilder()
if (!tableName) helpers.warn(
'calling knex without a tableName is deprecated. Use knex.queryBuilder() instead.'
);
return tableName ? qb.table(tableName) : qb
}
assign(knex, {
Promise: require('../promise'),
// A new query builder instance.
queryBuilder() {
return client.queryBuilder()
},
raw() {
return client.raw.apply(client, arguments)
},
batchInsert(table, batch, chunkSize = 1000) {
return new BatchInsert(this, table, batch, chunkSize);
},
// Runs a new transaction, taking a container and returning a promise
// for when the transaction is resolved.
transaction(container, config) {
return client.transaction(container, config)
},
// Typically never needed, initializes the pool for a knex client.
initialize(config) {
return client.initialize(config)
},
// Convenience method for tearing down the pool.
destroy(callback) {
return client.destroy(callback)
}
})
// The `__knex__` is used if you need to duck-type check whether this
// is a knex builder, without a full on `instanceof` check.
knex.VERSION = knex.__knex__ = require('../../package.json').version;
// Hook up the "knex" object as an EventEmitter.
const ee = new EventEmitter()
for (const key in ee) {
knex[key] = ee[key]
}
// Allow chaining methods from the root object, before
// any other information is specified.
QueryInterface.forEach(function(method) {
knex[method] = function() {
const builder = knex.queryBuilder()
return builder[method].apply(builder, arguments)
}
})
knex.client = client
Object.defineProperties(knex, {
schema: {
get() {
return client.schemaBuilder()
}
},
migrate: {
get() {
return new Migrator(knex)
}
},
seed: {
get() {
return new Seeder(knex)
}
},
fn: {
get() {
return new FunctionHelper(client)
}
}
})
// Passthrough all "start" and "query" events to the knex object.
client.on('start', function(obj) {
knex.emit('start', obj)
})
client.on('query', function(obj) {
knex.emit('query', obj)
})
client.on('query-error', function(err, obj) {
knex.emit('query-error', err, obj)
})
client.on('query-response', function(response, obj, builder) {
knex.emit('query-response', response, obj, builder)
})
client.makeKnex = makeKnex
return knex
}