tspace-mysql 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (26) hide show
  1. package/License +19 -0
  2. package/README.md +375 -0
  3. package/dist/cli/index.js +37 -0
  4. package/dist/cli/migrate/make.js +62 -0
  5. package/dist/cli/models/make.js +52 -0
  6. package/dist/cli/models/model.js +6 -0
  7. package/dist/cli/tables/make.js +32 -0
  8. package/dist/cli/tables/table.js +6 -0
  9. package/dist/lib/config/env.js +21 -0
  10. package/dist/lib/connections/index.js +42 -0
  11. package/dist/lib/connections/options.js +32 -0
  12. package/dist/lib/index.js +32 -0
  13. package/dist/lib/tspace/AbstractDB.js +29 -0
  14. package/dist/lib/tspace/AbstractDatabase.js +44 -0
  15. package/dist/lib/tspace/AbstractModel.js +29 -0
  16. package/dist/lib/tspace/DB.js +247 -0
  17. package/dist/lib/tspace/Database.js +1450 -0
  18. package/dist/lib/tspace/Interface.js +2 -0
  19. package/dist/lib/tspace/Logger.js +31 -0
  20. package/dist/lib/tspace/Model.js +2066 -0
  21. package/dist/lib/tspace/ProxyHandler.js +39 -0
  22. package/dist/lib/tspace/Schema.js +250 -0
  23. package/dist/lib/tspace/index.js +19 -0
  24. package/dist/lib/utils/constant.js +71 -0
  25. package/dist/lib/utils/index.js +297 -0
  26. package/package.json +52 -0
package/dist/lib/tspace/Database.js ADDED
@@ -0,0 +1,1450 @@
1
+ "use strict";
2
+ var __extends = (this && this.__extends) || (function () {
3
+ var extendStatics = function (d, b) {
4
+ extendStatics = Object.setPrototypeOf ||
5
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
6
+ function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
7
+ return extendStatics(d, b);
8
+ };
9
+ return function (d, b) {
10
+ if (typeof b !== "function" && b !== null)
11
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
12
+ extendStatics(d, b);
13
+ function __() { this.constructor = d; }
14
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
15
+ };
16
+ })();
17
+ var __assign = (this && this.__assign) || function () {
18
+ __assign = Object.assign || function(t) {
19
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
20
+ s = arguments[i];
21
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
22
+ t[p] = s[p];
23
+ }
24
+ return t;
25
+ };
26
+ return __assign.apply(this, arguments);
27
+ };
28
+ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
29
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
30
+ return new (P || (P = Promise))(function (resolve, reject) {
31
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
32
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
33
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
34
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
35
+ });
36
+ };
37
+ var __generator = (this && this.__generator) || function (thisArg, body) {
38
+ var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
39
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
40
+ function verb(n) { return function (v) { return step([n, v]); }; }
41
+ function step(op) {
42
+ if (f) throw new TypeError("Generator is already executing.");
43
+ while (_) try {
44
+ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
45
+ if (y = 0, t) op = [op[0] & 2, t.value];
46
+ switch (op[0]) {
47
+ case 0: case 1: t = op; break;
48
+ case 4: _.label++; return { value: op[1], done: false };
49
+ case 5: _.label++; y = op[1]; op = [0]; continue;
50
+ case 7: op = _.ops.pop(); _.trys.pop(); continue;
51
+ default:
52
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
53
+ if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
54
+ if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
55
+ if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
56
+ if (t[2]) _.ops.pop();
57
+ _.trys.pop(); continue;
58
+ }
59
+ op = body.call(thisArg, _);
60
+ } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
61
+ if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
62
+ }
63
+ };
64
+ var __read = (this && this.__read) || function (o, n) {
65
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
66
+ if (!m) return o;
67
+ var i = m.call(o), r, ar = [], e;
68
+ try {
69
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
70
+ }
71
+ catch (error) { e = { error: error }; }
72
+ finally {
73
+ try {
74
+ if (r && !r.done && (m = i["return"])) m.call(i);
75
+ }
76
+ finally { if (e) throw e.error; }
77
+ }
78
+ return ar;
79
+ };
80
+ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
81
+ if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
82
+ if (ar || !(i in from)) {
83
+ if (!ar) ar = Array.prototype.slice.call(from, 0, i);
84
+ ar[i] = from[i];
85
+ }
86
+ }
87
+ return to.concat(ar || Array.prototype.slice.call(from));
88
+ };
89
+ var __values = (this && this.__values) || function(o) {
90
+ var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
91
+ if (m) return m.call(o);
92
+ if (o && typeof o.length === "number") return {
93
+ next: function () {
94
+ if (o && i >= o.length) o = void 0;
95
+ return { value: o && o[i++], done: !o };
96
+ }
97
+ };
98
+ throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
99
+ };
100
+ var __importDefault = (this && this.__importDefault) || function (mod) {
101
+ return (mod && mod.__esModule) ? mod : { "default": mod };
102
+ };
103
+ Object.defineProperty(exports, "__esModule", { value: true });
104
+ var AbstractDatabase_1 = __importDefault(require("./AbstractDatabase"));
105
+ var Database = /** @class */ (function (_super) {
106
+ __extends(Database, _super);
107
+ function Database() {
108
+ return _super !== null && _super.apply(this, arguments) || this;
109
+ }
110
+ Database.prototype.except = function () {
111
+ var params = [];
112
+ for (var _i = 0; _i < arguments.length; _i++) {
113
+ params[_i] = arguments[_i];
114
+ }
115
+ this.$db.set('EXCEPT', params.length ? params : ['id']);
116
+ return this;
117
+ };
118
+ Database.prototype.only = function () {
119
+ var params = [];
120
+ for (var _i = 0; _i < arguments.length; _i++) {
121
+ params[_i] = arguments[_i];
122
+ }
123
+ this.$db.set('ONLY', params);
124
+ return this;
125
+ };
126
+ Database.prototype.distinct = function (column) {
127
+ if (column === void 0) { column = 'id'; }
128
+ this.$db.set('SELECT', this.$utils().constants('SELECT') + " " + this.$utils().constants('DISTINCT') + " " + column);
129
+ return this;
130
+ };
131
+ Database.prototype.select = function () {
132
+ var params = [];
133
+ for (var _i = 0; _i < arguments.length; _i++) {
134
+ params[_i] = arguments[_i];
135
+ }
136
+ var select = '*';
137
+ if (params === null || params === void 0 ? void 0 : params.length)
138
+ select = params.join(',');
139
+ this.$db.set('SELECT', this.$utils().constants('SELECT') + " " + select);
140
+ return this;
141
+ };
142
+ Database.prototype.where = function (column, operator, value) {
143
+ var _a;
144
+ _a = __read(this._valueAndOperator(value, operator, arguments.length === 2), 2), value = _a[0], operator = _a[1];
145
+ value = this.$utils().escape(value);
146
+ value = this._valueTrueFalse(value);
147
+ if (operator === this.$utils().constants('LIKE'))
148
+ value = "%" + value + "%";
149
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
150
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + operator + " '" + value + "'");
151
+ else
152
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + operator + " '" + value + "'");
153
+ return this;
154
+ };
155
+ Database.prototype.whereId = function (id) {
156
+ var column = 'id';
157
+ var operator = '=';
158
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
159
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + operator + " '" + id + "'");
160
+ else
161
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + operator + " '" + id + "'");
162
+ return this;
163
+ };
164
+ Database.prototype.whereEmail = function (email) {
165
+ var column = 'email';
166
+ var operator = '=';
167
+ email = this.$utils().escape(email);
168
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
169
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + operator + " '" + email + "'");
170
+ else
171
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + operator + " '" + email + "'");
172
+ return this;
173
+ };
174
+ Database.prototype.whereUser = function (id) {
175
+ var column = 'user_id';
176
+ var operator = '=';
177
+ id = this.$utils().escape(id);
178
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
179
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + operator + " '" + id + "'");
180
+ else
181
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + operator + " '" + id + "'");
182
+ return this;
183
+ };
184
+ Database.prototype.orWhere = function (column, operator, value) {
185
+ var _a;
186
+ _a = __read(this._valueAndOperator(value, operator, arguments.length === 2), 2), value = _a[0], operator = _a[1];
187
+ value = this.$utils().escape(value);
188
+ if (operator === this.$utils().constants('LIKE'))
189
+ value = "%" + value + "%";
190
+ if (this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
191
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('OR') + " " + column + " " + operator + " '" + value + "'");
192
+ else
193
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + operator + " '" + value + "'");
194
+ return this;
195
+ };
196
+ Database.prototype.whereIn = function (column, arrayValues) {
197
+ var sql = this.$db.get('WHERE');
198
+ if (!Array.isArray(arrayValues))
199
+ throw new Error("[" + arrayValues + "] is't array");
200
+ if (!arrayValues.length)
201
+ arrayValues = ['0'];
202
+ var values = "" + arrayValues.map(function (value) { return "'" + value + "'"; }).join(',');
203
+ if (!sql.includes(this.$utils().constants('WHERE'))) {
204
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + this.$utils().constants('IN') + " (" + values + ")");
205
+ return this;
206
+ }
207
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + this.$utils().constants('IN') + " (" + values + ")");
208
+ return this;
209
+ };
210
+ Database.prototype.orWhereIn = function (column, arrayValues) {
211
+ var sql = this.$db.get('WHERE');
212
+ if (!Array.isArray(arrayValues))
213
+ throw new Error("[" + arrayValues + "] is't array");
214
+ if (!arrayValues.length)
215
+ arrayValues = ['0'];
216
+ var values = "" + arrayValues.map(function (value) { return "'" + value + "'"; }).join(',');
217
+ if (!sql.includes(this.$utils().constants('WHERE'))) {
218
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + this.$utils().constants('IN') + " (" + values + ")");
219
+ return this;
220
+ }
221
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('OR') + " " + column + " " + this.$utils().constants('IN') + " (" + values + ")");
222
+ return this;
223
+ };
224
+ Database.prototype.whereNotIn = function (column, arrayValues) {
225
+ var sql = this.$db.get('WHERE');
226
+ if (!Array.isArray(arrayValues))
227
+ throw new Error("[" + arrayValues + "] is't array");
228
+ if (!arrayValues.length)
229
+ arrayValues = ['0'];
230
+ var values = "" + arrayValues.map(function (value) { return "'" + value + "'"; }).join(',');
231
+ if (!sql.includes(this.$utils().constants('WHERE'))) {
232
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + this.$utils().constants('NOT_IN') + " (" + values + ")");
233
+ return this;
234
+ }
235
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + this.$utils().constants('NOT_IN') + " (" + values + ")");
236
+ return this;
237
+ };
238
+ Database.prototype.whereSubQuery = function (column, subQuery) {
239
+ var whereSubQuery = this.$db.get('WHERE');
240
+ subQuery = this.$utils().escapeSubQuery(subQuery);
241
+ if (!whereSubQuery.includes(this.$utils().constants('WHERE')))
242
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + this.$utils().constants('IN') + " (" + subQuery + ")");
243
+ else
244
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + this.$utils().constants('IN') + " (" + subQuery + ")");
245
+ return this;
246
+ };
247
+ Database.prototype.whereNotInSubQuery = function (column, subQuery) {
248
+ var whereSubQuery = this.$db.get('WHERE');
249
+ subQuery = this.$utils().escapeSubQuery(subQuery);
250
+ if (!whereSubQuery.includes(this.$utils().constants('WHERE')))
251
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + this.$utils().constants('IN') + " (" + subQuery + ")");
252
+ else
253
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + this.$utils().constants('NOT_IN') + " (" + subQuery + ")");
254
+ return this;
255
+ };
256
+ Database.prototype.orWhereSubQuery = function (column, subQuery) {
257
+ var whereSubQuery = this.$db.get('WHERE');
258
+ subQuery = this.$utils().escapeSubQuery(subQuery);
259
+ if (!whereSubQuery.includes(this.$utils().constants('WHERE')))
260
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + this.$utils().constants('IN') + " (" + subQuery + ")");
261
+ else
262
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('OR') + " " + column + " " + this.$utils().constants('IN') + " (" + subQuery + ")");
263
+ return this;
264
+ };
265
+ Database.prototype.whereBetween = function (column, arrayValue) {
266
+ if (!Array.isArray(arrayValue))
267
+ throw new Error("Value is't array");
268
+ if (!arrayValue.length)
269
+ arrayValue = ['0', '0'];
270
+ var _a = __read(arrayValue, 2), value1 = _a[0], value2 = _a[1];
271
+ value1 = this.$utils().escape(value1);
272
+ value2 = this.$utils().escape(value2);
273
+ var sql = this.$db.get('WHERE');
274
+ if (!sql.includes(this.$utils().constants('WHERE'))) {
275
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + this.$utils().constants('BETWEEN') + " '" + value1 + "' " + this.$utils().constants('AND') + " '" + value2 + "'");
276
+ return this;
277
+ }
278
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + this.$utils().constants('BETWEEN') + " '" + value1 + "' " + this.$utils().constants('AND') + " '" + value2 + "'");
279
+ return this;
280
+ };
281
+ Database.prototype.whereNull = function (column) {
282
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
283
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + this.$utils().constants('IS_NULL'));
284
+ else
285
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + this.$utils().constants('IS_NULL'));
286
+ return this;
287
+ };
288
+ Database.prototype.whereNotNull = function (column) {
289
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
290
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + this.$utils().constants('IS_NOT_NULL'));
291
+ else
292
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " " + column + " " + this.$utils().constants('IS_NOT_NULL'));
293
+ return this;
294
+ };
295
+ Database.prototype.whereSensitive = function (column, operator, value) {
296
+ var _a;
297
+ _a = __read(this._valueAndOperator(value, operator, arguments.length === 2), 2), value = _a[0], operator = _a[1];
298
+ value = this.$utils().escape(value);
299
+ value = this._valueTrueFalse(value);
300
+ if (operator === this.$utils().constants('LIKE'))
301
+ value = "%" + value + "%";
302
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
303
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " BINARY " + column + " " + operator + " '" + value + "'");
304
+ else
305
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " BINARY " + column + " " + operator + " '" + value + "'");
306
+ return this;
307
+ };
308
+ Database.prototype.whereGroupStart = function (column, operator, value) {
309
+ var _a;
310
+ _a = __read(this._valueAndOperator(value, operator, arguments.length === 2), 2), value = _a[0], operator = _a[1];
311
+ value = this.$utils().escape(value);
312
+ value = this._valueTrueFalse(value);
313
+ if (operator === this.$utils().constants('LIKE'))
314
+ value = "%" + value + "%";
315
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
316
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " (" + column + " " + operator + " '" + value + "'");
317
+ else
318
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " (" + column + " " + operator + " '" + value + "'");
319
+ return this;
320
+ };
321
+ Database.prototype.orWhereGroupStart = function (column, operator, value) {
322
+ var _a;
323
+ _a = __read(this._valueAndOperator(value, operator, arguments.length === 2), 2), value = _a[0], operator = _a[1];
324
+ value = this.$utils().escape(value);
325
+ value = this._valueTrueFalse(value);
326
+ if (operator === this.$utils().constants('LIKE'))
327
+ value = "%" + value + "%";
328
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
329
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " (" + column + " " + operator + " '" + value + "'");
330
+ else
331
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('AND') + " (" + column + " " + operator + " '" + value + "'");
332
+ return this;
333
+ };
334
+ Database.prototype.whereGroupEnd = function (column, operator, value) {
335
+ var _a;
336
+ _a = __read(this._valueAndOperator(value, operator, arguments.length === 2), 2), value = _a[0], operator = _a[1];
337
+ value = this.$utils().escape(value);
338
+ value = this._valueTrueFalse(value);
339
+ if (operator === this.$utils().constants('LIKE'))
340
+ value = "%" + value + "%";
341
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
342
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + operator + " '" + value + "')");
343
+ else
344
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('OR') + " " + column + " " + operator + " '" + value + "')");
345
+ return this;
346
+ };
347
+ Database.prototype.orWhereGroupEnd = function (column, operator, value) {
348
+ var _a;
349
+ _a = __read(this._valueAndOperator(value, operator, arguments.length === 2), 2), value = _a[0], operator = _a[1];
350
+ value = this.$utils().escape(value);
351
+ value = this._valueTrueFalse(value);
352
+ if (operator === this.$utils().constants('LIKE'))
353
+ value = "%" + value + "%";
354
+ if (!this.$db.get('WHERE').includes(this.$utils().constants('WHERE')))
355
+ this.$db.set('WHERE', this.$utils().constants('WHERE') + " " + column + " " + operator + " '" + value + "')");
356
+ else
357
+ this.$db.set('WHERE', this.$db.get('WHERE') + " " + this.$utils().constants('OR') + " " + column + " " + operator + " '" + value + "')");
358
+ return this;
359
+ };
360
+ Database.prototype.having = function (condition) {
361
+ this.$db.set('HAVING', condition);
362
+ return this;
363
+ };
364
+ Database.prototype.join = function (pk, fk) {
365
+ var _a;
366
+ var table = (_a = fk.split('.')) === null || _a === void 0 ? void 0 : _a.shift();
367
+ if (this.$db.get('JOIN'))
368
+ this.$db.set('JOIN', this.$db.get('JOIN') + " " + this.$utils().constants('INNER_JOIN') + " " + table + " " + this.$utils().constants('ON') + " " + pk + " = " + fk);
369
+ else
370
+ this.$db.set('JOIN', this.$utils().constants('INNER_JOIN') + " " + table + " " + this.$utils().constants('ON') + " " + pk + " = " + fk);
371
+ return this;
372
+ };
373
+ Database.prototype.rightJoin = function (pk, fk) {
374
+ var _a;
375
+ var table = (_a = fk.split('.')) === null || _a === void 0 ? void 0 : _a.shift();
376
+ if (this.$db.get('JOIN'))
377
+ this.$db.set('JOIN', this.$db.get('JOIN') + " " + this.$utils().constants('RIGHT_JOIN') + " " + table + " " + this.$utils().constants('ON') + " " + pk + " = " + fk);
378
+ else
379
+ this.$db.set('JOIN', this.$utils().constants('RIGHT_JOIN') + " " + table + " " + this.$utils().constants('ON') + " " + pk + " = " + fk);
380
+ return this;
381
+ };
382
+ Database.prototype.leftJoin = function (pk, fk) {
383
+ var _a;
384
+ var table = (_a = fk.split('.')) === null || _a === void 0 ? void 0 : _a.shift();
385
+ if (this.$db.get('JOIN'))
386
+ this.$db.set('JOIN', this.$db.get('JOIN') + " " + this.$utils().constants('LEFT_JOIN') + " " + table + " " + this.$utils().constants('ON') + " " + pk + " = " + fk);
387
+ else
388
+ this.$db.set('JOIN', this.$utils().constants('LEFT_JOIN') + " " + table + " " + this.$utils().constants('ON') + " " + pk + " = " + fk);
389
+ return this;
390
+ };
391
+ Database.prototype.crossJoin = function (pk, fk) {
392
+ var _a;
393
+ var table = (_a = fk.split('.')) === null || _a === void 0 ? void 0 : _a.shift();
394
+ if (this.$db.get('JOIN'))
395
+ this.$db.set('JOIN', this.$db.get('JOIN') + " " + this.$utils().constants('CROSS_JOIN') + " " + table + " " + this.$utils().constants('ON') + " " + pk + " = " + fk);
396
+ else
397
+ this.$db.set('JOIN', this.$utils().constants('CROSS_JOIN') + " " + table + " " + this.$utils().constants('ON') + " " + pk + " = " + fk);
398
+ return this;
399
+ };
400
+ Database.prototype.orderBy = function (column, order) {
401
+ if (order === void 0) { order = this.$utils().constants('ASC'); }
402
+ this.$db.set('ORDER_BY', this.$utils().constants('ORDER_BY') + " " + column + " " + order.toUpperCase());
403
+ return this;
404
+ };
405
+ Database.prototype.latest = function (column) {
406
+ if (column === void 0) { column = 'id'; }
407
+ if (this.$db.get('ORDER_BY')) {
408
+ this.$db.set('ORDER_BY', this.$db.get('ORDER_BY') + " ," + column + " " + this.$utils().constants('DESC'));
409
+ return this;
410
+ }
411
+ this.$db.set('ORDER_BY', this.$utils().constants('ORDER_BY') + " " + column + " " + this.$utils().constants('DESC'));
412
+ return this;
413
+ };
414
+ Database.prototype.oldest = function (column) {
415
+ if (column === void 0) { column = 'id'; }
416
+ if (this.$db.get('ORDER_BY')) {
417
+ this.$db.set('ORDER_BY', this.$db.get('ORDER_BY') + " ," + column + " " + this.$utils().constants('ASC'));
418
+ return this;
419
+ }
420
+ this.$db.set('ORDER_BY', this.$utils().constants('ORDER_BY') + " " + column + " " + this.$utils().constants('ASC'));
421
+ return this;
422
+ };
423
+ Database.prototype.groupBy = function (column) {
424
+ this.$db.set('GROUP_BY', this.$utils().constants('GROUP_BY') + " " + column);
425
+ return this;
426
+ };
427
+ Database.prototype.limit = function (number) {
428
+ if (number === void 0) { number = 1; }
429
+ this.$db.set('LIMIT', this.$utils().constants('LIMIT') + " " + number);
430
+ return this;
431
+ };
432
+ Database.prototype.offset = function (number) {
433
+ if (number === void 0) { number = 1; }
434
+ this.$db.set('OFFSET', this.$utils().constants('OFFSET') + " " + number);
435
+ return this;
436
+ };
437
+ Database.prototype.hidden = function () {
438
+ var columns = [];
439
+ for (var _i = 0; _i < arguments.length; _i++) {
440
+ columns[_i] = arguments[_i];
441
+ }
442
+ this.$db.set('HIDDEN', columns);
443
+ return this;
444
+ };
445
+ Database.prototype.update = function (objects) {
446
+ var query = this._queryUpdate(objects);
447
+ this.$db.set('UPDATE', this.$utils().constants('UPDATE') + " " + this.$db.get('TABLE_NAME') + " " + query);
448
+ this.$db.set('SAVE', 'UPDATE');
449
+ return this;
450
+ };
451
+ Database.prototype.insert = function (objects) {
452
+ var query = this._queryInsert(objects);
453
+ this.$db.set('INSERT', this.$utils().constants('INSERT') + " " + this.$db.get('TABLE_NAME') + " " + query);
454
+ this.$db.set('SAVE', 'INSERT');
455
+ return this;
456
+ };
457
+ Database.prototype.create = function (objects) {
458
+ var query = this._queryInsert(objects);
459
+ this.$db.set('INSERT', this.$utils().constants('INSERT') + " " + this.$db.get('TABLE_NAME') + " " + query);
460
+ this.$db.set('SAVE', 'INSERT');
461
+ return this;
462
+ };
463
+ Database.prototype.createMultiple = function (data) {
464
+ var query = this._queryInsertMultiple(data);
465
+ this.$db.set('INSERT', this.$utils().constants('INSERT') + " " + this.$db.get('TABLE_NAME') + " " + query);
466
+ this.$db.set('SAVE', 'INSERT_MULTIPLE');
467
+ return this;
468
+ };
469
+ Database.prototype.insertMultiple = function (data) {
470
+ var query = this._queryInsertMultiple(data);
471
+ this.$db.set('INSERT', this.$utils().constants('INSERT') + " " + this.$db.get('TABLE_NAME') + " " + query);
472
+ this.$db.set('SAVE', 'INSERT_MULTIPLE');
473
+ return this;
474
+ };
475
+ Database.prototype.toString = function () {
476
+ return this._getSQL();
477
+ };
478
+ Database.prototype.toSQL = function () {
479
+ return this._getSQL();
480
+ };
481
+ Database.prototype.debug = function (debug) {
482
+ if (debug === void 0) { debug = true; }
483
+ this.$db.set('DEBUG', debug);
484
+ return this;
485
+ };
486
+ Database.prototype.dump = function (debug) {
487
+ if (debug === void 0) { debug = true; }
488
+ this.$db.set('DEBUG', debug);
489
+ return this;
490
+ };
491
+ Database.prototype.dd = function (debug) {
492
+ if (debug === void 0) { debug = true; }
493
+ this.$db.set('DEBUG', debug);
494
+ return this;
495
+ };
496
+ Database.prototype.createNotExists = function (objects) {
497
+ var query = this._queryInsert(objects);
498
+ this.$db.set('INSERT', this.$utils().constants('INSERT') + " " + this.$db.get('TABLE_NAME') + " " + query);
499
+ this.$db.set('SAVE', 'INSERT_NOT_EXISTS');
500
+ return this;
501
+ };
502
+ Database.prototype.insertNotExists = function (objects) {
503
+ this.createNotExists(objects);
504
+ return this;
505
+ };
506
+ Database.prototype.upsert = function (objects) {
507
+ var queryUpdate = this._queryUpdate(objects);
508
+ var queryInsert = this._queryInsert(objects);
509
+ this.$db.set('INSERT', this.$utils().constants('INSERT') + " " + this.$db.get('TABLE_NAME') + " " + queryInsert);
510
+ this.$db.set('UPDATE', this.$utils().constants('UPDATE') + " " + this.$db.get('TABLE_NAME') + " " + queryUpdate);
511
+ this.$db.set('SAVE', 'UPDATE_OR_INSERT');
512
+ return this;
513
+ };
514
+ Database.prototype.updateOrCreate = function (objects) {
515
+ var queryUpdate = this._queryUpdate(objects);
516
+ var queryInsert = this._queryInsert(objects);
517
+ this.$db.set('INSERT', this.$utils().constants('INSERT') + " " + this.$db.get('TABLE_NAME') + " " + queryInsert);
518
+ this.$db.set('UPDATE', this.$utils().constants('UPDATE') + " " + this.$db.get('TABLE_NAME') + " " + queryUpdate);
519
+ this.$db.set('SAVE', 'UPDATE_OR_INSERT');
520
+ return this;
521
+ };
522
+ Database.prototype.updateOrInsert = function (objects) {
523
+ this.updateOrCreate(objects);
524
+ return this;
525
+ };
526
+ Database.prototype.insertOrUpdate = function (objects) {
527
+ this.updateOrCreate(objects);
528
+ return this;
529
+ };
530
+ Database.prototype.createOrUpdate = function (objects) {
531
+ this.updateOrCreate(objects);
532
+ return this;
533
+ };
534
+ Database.prototype.rawQuery = function (sql) {
535
+ return __awaiter(this, void 0, void 0, function () {
536
+ return __generator(this, function (_a) {
537
+ switch (_a.label) {
538
+ case 0: return [4 /*yield*/, this._queryStatement(sql)];
539
+ case 1: return [2 /*return*/, _a.sent()];
540
+ }
541
+ });
542
+ });
543
+ };
544
+ Database.prototype.increment = function (column, value) {
545
+ if (column === void 0) { column = 'id'; }
546
+ if (value === void 0) { value = 1; }
547
+ return __awaiter(this, void 0, void 0, function () {
548
+ var query;
549
+ return __generator(this, function (_a) {
550
+ switch (_a.label) {
551
+ case 0:
552
+ query = this.$utils().constants('SET') + " " + column + " = " + column + " + " + value;
553
+ this.$db.set('UPDATE', this.$utils().constants('UPDATE') + " " + this.$db.get('TABLE_NAME') + " " + query);
554
+ return [4 /*yield*/, this._update(true)];
555
+ case 1: return [2 /*return*/, _a.sent()];
556
+ }
557
+ });
558
+ });
559
+ };
560
+ Database.prototype.decrement = function (column, value) {
561
+ if (column === void 0) { column = 'id'; }
562
+ if (value === void 0) { value = 1; }
563
+ return __awaiter(this, void 0, void 0, function () {
564
+ var query;
565
+ return __generator(this, function (_a) {
566
+ switch (_a.label) {
567
+ case 0:
568
+ query = this.$utils().constants('SET') + " " + column + " = " + column + " - " + value;
569
+ this.$db.set('UPDATE', this.$utils().constants('UPDATE') + " " + this.$db.get('TABLE_NAME') + " " + query);
570
+ return [4 /*yield*/, this._update(true)];
571
+ case 1: return [2 /*return*/, _a.sent()];
572
+ }
573
+ });
574
+ });
575
+ };
576
+ Database.prototype.all = function () {
577
+ return __awaiter(this, void 0, void 0, function () {
578
+ var sql;
579
+ return __generator(this, function (_a) {
580
+ switch (_a.label) {
581
+ case 0:
582
+ sql = this.$utils().constants('SELECT') + " * " + this.$utils().constants('FROM') + " " + this.$db.get('TABLE_NAME');
583
+ return [4 /*yield*/, this._queryStatement(sql)];
584
+ case 1: return [2 /*return*/, _a.sent()];
585
+ }
586
+ });
587
+ });
588
+ };
589
+ Database.prototype.find = function (id) {
590
+ return __awaiter(this, void 0, void 0, function () {
591
+ var sql, result;
592
+ return __generator(this, function (_a) {
593
+ switch (_a.label) {
594
+ case 0:
595
+ sql = this.$utils().constants('SELECT') + " * " + this.$utils().constants('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$utils().constants('WHERE') + " id = " + id;
596
+ return [4 /*yield*/, this._queryStatement(sql)];
597
+ case 1:
598
+ result = _a.sent();
599
+ return [2 /*return*/, (result === null || result === void 0 ? void 0 : result.shift()) || null];
600
+ }
601
+ });
602
+ });
603
+ };
604
+ Database.prototype.pagination = function (_a) {
605
+ var _b;
606
+ var _c = _a === void 0 ? {} : _a, _d = _c.limit, limit = _d === void 0 ? 15 : _d, _e = _c.page, page = _e === void 0 ? 1 : _e;
607
+ return __awaiter(this, void 0, void 0, function () {
608
+ var currentPage, nextPage, prevPage, offset, sql, result, count, total, lastPage;
609
+ return __generator(this, function (_f) {
610
+ switch (_f.label) {
611
+ case 0:
612
+ currentPage = page;
613
+ nextPage = currentPage + 1;
614
+ prevPage = currentPage - 1 === 0 ? 1 : currentPage - 1;
615
+ offset = (page - 1) * limit;
616
+ sql = this._getSQL();
617
+ if (!sql.includes(this.$utils().constants('LIMIT'))) {
618
+ sql = sql + " " + this.$utils().constants('LIMIT') + " " + limit + " " + this.$utils().constants('OFFSET') + " " + offset;
619
+ }
620
+ else {
621
+ sql = sql.replace(this.$db.get('LIMIT'), limit + " " + this.$utils().constants('OFFSET') + " " + offset);
622
+ }
623
+ return [4 /*yield*/, this._queryStatement(sql)];
624
+ case 1:
625
+ result = _f.sent();
626
+ if ((_b = this.$db.get('HIDDEN')) === null || _b === void 0 ? void 0 : _b.length)
627
+ this._hiddenColumn(result);
628
+ if (!result.length)
629
+ return [2 /*return*/, {
630
+ meta: {
631
+ total: 0,
632
+ limit: limit,
633
+ total_page: 0,
634
+ current_page: currentPage,
635
+ last_page: 0,
636
+ next_page: 0,
637
+ prev_page: 0
638
+ },
639
+ data: []
640
+ }];
641
+ this.$db.set('SELECT', this.$utils().constants('SELECT') + " " + this.$utils().constants('COUNT') + "(*) " + this.$utils().constants('AS') + " total");
642
+ sql = this._getSQL();
643
+ return [4 /*yield*/, this._queryStatement(sql)];
644
+ case 2:
645
+ count = _f.sent();
646
+ total = count.shift().total || 0;
647
+ lastPage = Math.ceil(total / limit) || 0;
648
+ lastPage = lastPage > 1 ? lastPage : 1;
649
+ return [2 /*return*/, {
650
+ meta: {
651
+ total: total,
652
+ limit: limit,
653
+ current_page: currentPage,
654
+ last_page: lastPage,
655
+ next_page: nextPage,
656
+ prev_page: prevPage
657
+ },
658
+ data: result
659
+ }];
660
+ }
661
+ });
662
+ });
663
+ };
664
+ Database.prototype.paginate = function (_a) {
665
+ var _b = _a === void 0 ? {} : _a, _c = _b.limit, limit = _c === void 0 ? 15 : _c, _d = _b.page, page = _d === void 0 ? 1 : _d;
666
+ return __awaiter(this, void 0, void 0, function () {
667
+ return __generator(this, function (_e) {
668
+ switch (_e.label) {
669
+ case 0: return [4 /*yield*/, this.pagination({ limit: limit, page: page })];
670
+ case 1: return [2 /*return*/, _e.sent()];
671
+ }
672
+ });
673
+ });
674
+ };
675
+ Database.prototype.first = function () {
676
+ var _a;
677
+ return __awaiter(this, void 0, void 0, function () {
678
+ var sql, result;
679
+ return __generator(this, function (_b) {
680
+ switch (_b.label) {
681
+ case 0:
682
+ sql = this._getSQL();
683
+ if (!sql.includes(this.$utils().constants('LIMIT')))
684
+ sql = sql + " " + this.$utils().constants('LIMIT') + " 1";
685
+ else
686
+ sql = sql.replace(this.$db.get('LIMIT'), this.$utils().constants('LIMIT') + " 1");
687
+ return [4 /*yield*/, this._queryStatement(sql)];
688
+ case 1:
689
+ result = _b.sent();
690
+ if ((_a = this.$db.get('HIDDEN')) === null || _a === void 0 ? void 0 : _a.length)
691
+ this._hiddenColumn(result);
692
+ return [2 /*return*/, result.shift() || null];
693
+ }
694
+ });
695
+ });
696
+ };
697
+ Database.prototype.findOne = function () {
698
+ return __awaiter(this, void 0, void 0, function () {
699
+ return __generator(this, function (_a) {
700
+ switch (_a.label) {
701
+ case 0: return [4 /*yield*/, this.first()];
702
+ case 1: return [2 /*return*/, _a.sent()];
703
+ }
704
+ });
705
+ });
706
+ };
707
+ Database.prototype.get = function () {
708
+ var _a;
709
+ return __awaiter(this, void 0, void 0, function () {
710
+ var sql, result;
711
+ return __generator(this, function (_b) {
712
+ switch (_b.label) {
713
+ case 0:
714
+ sql = this._getSQL();
715
+ return [4 /*yield*/, this._queryStatement(sql)];
716
+ case 1:
717
+ result = _b.sent();
718
+ if ((_a = this.$db.get('HIDDEN')) === null || _a === void 0 ? void 0 : _a.length)
719
+ this._hiddenColumn(result);
720
+ return [2 /*return*/, result || []];
721
+ }
722
+ });
723
+ });
724
+ };
725
+ Database.prototype.findMany = function () {
726
+ return __awaiter(this, void 0, void 0, function () {
727
+ return __generator(this, function (_a) {
728
+ switch (_a.label) {
729
+ case 0: return [4 /*yield*/, this.get()];
730
+ case 1: return [2 /*return*/, _a.sent()];
731
+ }
732
+ });
733
+ });
734
+ };
735
+ Database.prototype.toJSON = function () {
736
+ var _a;
737
+ return __awaiter(this, void 0, void 0, function () {
738
+ var sql, result;
739
+ return __generator(this, function (_b) {
740
+ switch (_b.label) {
741
+ case 0:
742
+ sql = this._getSQL();
743
+ return [4 /*yield*/, this._queryStatement(sql)];
744
+ case 1:
745
+ result = _b.sent();
746
+ if ((_a = this.$db.get('HIDDEN')) === null || _a === void 0 ? void 0 : _a.length)
747
+ this._hiddenColumn(result);
748
+ return [2 /*return*/, JSON.stringify(result) || []];
749
+ }
750
+ });
751
+ });
752
+ };
753
+ Database.prototype.toArray = function (column) {
754
+ if (column === void 0) { column = 'id'; }
755
+ return __awaiter(this, void 0, void 0, function () {
756
+ var sql, result, toArray;
757
+ return __generator(this, function (_a) {
758
+ switch (_a.label) {
759
+ case 0:
760
+ this.$db.set('SELECT', this.$utils().constants('SELECT') + " " + column);
761
+ sql = this._getSQL();
762
+ return [4 /*yield*/, this._queryStatement(sql)];
763
+ case 1:
764
+ result = _a.sent();
765
+ toArray = result.map(function (data) { return data[column]; });
766
+ return [2 /*return*/, toArray];
767
+ }
768
+ });
769
+ });
770
+ };
771
+ Database.prototype.count = function (column) {
772
+ if (column === void 0) { column = 'id'; }
773
+ return __awaiter(this, void 0, void 0, function () {
774
+ var sql, result;
775
+ return __generator(this, function (_a) {
776
+ switch (_a.label) {
777
+ case 0:
778
+ this.$db.set('SELECT', this.$utils().constants('SELECT') + " " + this.$utils().constants('COUNT') + "(" + column + ") " + this.$utils().constants('AS') + " total");
779
+ sql = this._getSQL();
780
+ return [4 /*yield*/, this._queryStatement(sql)];
781
+ case 1:
782
+ result = _a.sent();
783
+ return [2 /*return*/, result.shift().total || 0];
784
+ }
785
+ });
786
+ });
787
+ };
788
+ Database.prototype.exists = function () {
789
+ return __awaiter(this, void 0, void 0, function () {
790
+ var sql, result;
791
+ return __generator(this, function (_a) {
792
+ switch (_a.label) {
793
+ case 0:
794
+ sql = this.$utils().constants('SELECT') + " " + this.$utils().constants('EXISTS') + "(" + this.$utils().constants('SELECT') + " * " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$db.get('WHERE') + " LIMIT 1) as 'exists'";
795
+ return [4 /*yield*/, this._queryStatement(sql)];
796
+ case 1:
797
+ result = _a.sent();
798
+ return [2 /*return*/, !!result.shift().exists || false];
799
+ }
800
+ });
801
+ });
802
+ };
803
+ Database.prototype.avg = function (column) {
804
+ if (column === void 0) { column = 'id'; }
805
+ return __awaiter(this, void 0, void 0, function () {
806
+ var sql, result;
807
+ return __generator(this, function (_a) {
808
+ switch (_a.label) {
809
+ case 0:
810
+ this.$db.set('SELECT', this.$utils().constants('SELECT') + " " + this.$utils().constants('AVG') + "(" + column + ") " + this.$utils().constants('AS') + " avg");
811
+ sql = this._getSQL();
812
+ return [4 /*yield*/, this._queryStatement(sql)];
813
+ case 1:
814
+ result = _a.sent();
815
+ return [2 /*return*/, result.shift().avg || 0];
816
+ }
817
+ });
818
+ });
819
+ };
820
+ Database.prototype.sum = function (column) {
821
+ if (column === void 0) { column = 'id'; }
822
+ return __awaiter(this, void 0, void 0, function () {
823
+ var sql, result;
824
+ return __generator(this, function (_a) {
825
+ switch (_a.label) {
826
+ case 0:
827
+ this.$db.set('SELECT', this.$utils().constants('SELECT') + " " + this.$utils().constants('SUM') + "(" + column + ") " + this.$utils().constants('AS') + " sum");
828
+ sql = this._getSQL();
829
+ return [4 /*yield*/, this._queryStatement(sql)];
830
+ case 1:
831
+ result = _a.sent();
832
+ return [2 /*return*/, result.shift().sum || 0];
833
+ }
834
+ });
835
+ });
836
+ };
837
+ Database.prototype.max = function (column) {
838
+ if (column === void 0) { column = 'id'; }
839
+ return __awaiter(this, void 0, void 0, function () {
840
+ var sql, result;
841
+ return __generator(this, function (_a) {
842
+ switch (_a.label) {
843
+ case 0:
844
+ this.$db.set('SELECT', this.$utils().constants('SELECT') + " " + this.$utils().constants('MAX') + "(" + column + ") " + this.$utils().constants('AS') + " max");
845
+ sql = this._getSQL();
846
+ return [4 /*yield*/, this._queryStatement(sql)];
847
+ case 1:
848
+ result = _a.sent();
849
+ return [2 /*return*/, result.shift().max || 0];
850
+ }
851
+ });
852
+ });
853
+ };
854
+ Database.prototype.min = function (column) {
855
+ if (column === void 0) { column = 'id'; }
856
+ return __awaiter(this, void 0, void 0, function () {
857
+ var sql, result;
858
+ return __generator(this, function (_a) {
859
+ switch (_a.label) {
860
+ case 0:
861
+ this.$db.set('SELECT', this.$utils().constants('SELECT') + " " + this.$utils().constants('MIN') + "(" + column + ") " + this.$utils().constants('AS') + " min");
862
+ sql = this._getSQL();
863
+ return [4 /*yield*/, this._queryStatement(sql)];
864
+ case 1:
865
+ result = _a.sent();
866
+ return [2 /*return*/, result.shift().min || 0];
867
+ }
868
+ });
869
+ });
870
+ };
871
+ Database.prototype.delete = function () {
872
+ var _a;
873
+ return __awaiter(this, void 0, void 0, function () {
874
+ var result;
875
+ return __generator(this, function (_b) {
876
+ switch (_b.label) {
877
+ case 0:
878
+ if (!this.$db.get('WHERE'))
879
+ throw new Error("Can't delete without where condition");
880
+ this.$db.set('DELETE', this.$utils().constants('DELETE') + " " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$db.get('WHERE'));
881
+ return [4 /*yield*/, this._actionStatement({ sql: this.$db.get('DELETE') })];
882
+ case 1:
883
+ result = _b.sent();
884
+ if (result)
885
+ return [2 /*return*/, (_a = !!result) !== null && _a !== void 0 ? _a : false];
886
+ return [2 /*return*/, false];
887
+ }
888
+ });
889
+ });
890
+ };
891
+ Database.prototype.getGroupBy = function (column) {
892
+ return __awaiter(this, void 0, void 0, function () {
893
+ var sql, results, data, sqlGroups, groups, resultData;
894
+ return __generator(this, function (_a) {
895
+ switch (_a.label) {
896
+ case 0:
897
+ this.$db.set('GROUP_BY', this.$utils().constants('GROUP_BY') + " " + column);
898
+ this.$db.set('SELECT', this.$db.get('SELECT') + (", " + this.$utils().constants('GROUP_CONCAT') + "(id) " + this.$utils().constants('AS') + " data"));
899
+ sql = this._getSQL();
900
+ return [4 /*yield*/, this._queryStatement(sql)];
901
+ case 1:
902
+ results = _a.sent();
903
+ data = [];
904
+ results.forEach(function (result) {
905
+ var _a, _b;
906
+ var splits = (_b = (_a = result === null || result === void 0 ? void 0 : result.data) === null || _a === void 0 ? void 0 : _a.split(',')) !== null && _b !== void 0 ? _b : '0';
907
+ splits.forEach(function (split) { return data = __spreadArray(__spreadArray([], __read(data), false), [split], false); });
908
+ });
909
+ sqlGroups = this.$utils().constants('SELECT') + " * " + this.$utils().constants('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$utils().constants('WHERE') + " id " + this.$utils().constants('IN') + " (" + (data.map(function (a) { return "'" + a + "'"; }).join(',') || ['0']) + ")";
910
+ return [4 /*yield*/, this._queryStatement(sqlGroups)];
911
+ case 2:
912
+ groups = _a.sent();
913
+ resultData = results.map(function (result) {
914
+ var _a;
915
+ var id = result[column];
916
+ var newData = groups.filter(function (data) { return data[column] === id; });
917
+ return (_a = {},
918
+ _a[column] = id,
919
+ _a.data = newData,
920
+ _a);
921
+ });
922
+ return [2 /*return*/, resultData];
923
+ }
924
+ });
925
+ });
926
+ };
927
+ Database.prototype.findManyGroupBy = function (column) {
928
+ return __awaiter(this, void 0, void 0, function () {
929
+ return __generator(this, function (_a) {
930
+ switch (_a.label) {
931
+ case 0: return [4 /*yield*/, this.getGroupBy(column)];
932
+ case 1: return [2 /*return*/, _a.sent()];
933
+ }
934
+ });
935
+ });
936
+ };
937
+ Database.prototype.save = function (transaction) {
938
+ var _a;
939
+ if (transaction === void 0) { transaction = { query: [{ table: '', id: '' }] }; }
940
+ return __awaiter(this, void 0, void 0, function () {
941
+ var attributes, query_1, query, _b;
942
+ return __generator(this, function (_c) {
943
+ switch (_c.label) {
944
+ case 0:
945
+ this.$db.set('TRANSACTION', transaction);
946
+ attributes = this.$attributes;
947
+ if ((_a = Object.keys(attributes)) === null || _a === void 0 ? void 0 : _a.length) {
948
+ if (this.$db.get('WHERE')) {
949
+ query_1 = this._queryUpdate(attributes);
950
+ this.$db.set('UPDATE', this.$utils().constants('UPDATE') + " " + this.$db.get('TABLE_NAME') + " " + query_1);
951
+ this.$db.set('SAVE', 'UPDATE');
952
+ return [2 /*return*/];
953
+ }
954
+ query = this._queryInsert(attributes);
955
+ this.$db.set('INSERT', this.$utils().constants('INSERT') + " " + this.$db.get('TABLE_NAME') + " " + query);
956
+ this.$db.set('SAVE', 'INSERT');
957
+ }
958
+ _b = this.$db.get('SAVE');
959
+ switch (_b) {
960
+ case 'INSERT_MULTIPLE': return [3 /*break*/, 1];
961
+ case 'INSERT': return [3 /*break*/, 3];
962
+ case 'UPDATE': return [3 /*break*/, 5];
963
+ case 'INSERT_NOT_EXISTS': return [3 /*break*/, 7];
964
+ case 'UPDATE_OR_INSERT': return [3 /*break*/, 9];
965
+ }
966
+ return [3 /*break*/, 11];
967
+ case 1: return [4 /*yield*/, this._createMultiple()];
968
+ case 2: return [2 /*return*/, _c.sent()];
969
+ case 3: return [4 /*yield*/, this._create()];
970
+ case 4: return [2 /*return*/, _c.sent()];
971
+ case 5: return [4 /*yield*/, this._update()];
972
+ case 6: return [2 /*return*/, _c.sent()];
973
+ case 7: return [4 /*yield*/, this._insertNotExists()];
974
+ case 8: return [2 /*return*/, _c.sent()];
975
+ case 9: return [4 /*yield*/, this._updateOrInsert()];
976
+ case 10: return [2 /*return*/, _c.sent()];
977
+ case 11: return [2 /*return*/];
978
+ }
979
+ });
980
+ });
981
+ };
982
+ Database.prototype.faker = function (rounds) {
983
+ if (rounds === void 0) { rounds = 1; }
984
+ return __awaiter(this, void 0, void 0, function () {
985
+ var data, round, sql, fields, columnAndValue, fields_1, fields_1_1, _a, field, type, query;
986
+ var e_1, _b, _c;
987
+ return __generator(this, function (_d) {
988
+ switch (_d.label) {
989
+ case 0:
990
+ data = [];
991
+ round = 0;
992
+ _d.label = 1;
993
+ case 1:
994
+ if (!(round < rounds)) return [3 /*break*/, 4];
995
+ if (this.$db.get('TABLE_NAME') === '' || this.$db.get('TABLE_NAME') == null)
996
+ throw new Error("unknow table");
997
+ sql = this.$utils().constants('SHOW') + " " + this.$utils().constants('FIELDS') + " " + this.$utils().constants('FROM') + " " + this.$db.get('TABLE_NAME');
998
+ return [4 /*yield*/, this._queryStatement(sql)];
999
+ case 2:
1000
+ fields = _d.sent();
1001
+ columnAndValue = {};
1002
+ try {
1003
+ for (fields_1 = (e_1 = void 0, __values(fields)), fields_1_1 = fields_1.next(); !fields_1_1.done; fields_1_1 = fields_1.next()) {
1004
+ _a = fields_1_1.value, field = _a.Field, type = _a.Type;
1005
+ if (field.toLowerCase() === 'id' || field.toLowerCase() === '_id')
1006
+ continue;
1007
+ if (!this.$db.get('UUID') && field.toLowerCase() === 'uuid')
1008
+ continue;
1009
+ columnAndValue = __assign(__assign({}, columnAndValue), (_c = {}, _c[field] = this.$utils().faker(type), _c));
1010
+ }
1011
+ }
1012
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
1013
+ finally {
1014
+ try {
1015
+ if (fields_1_1 && !fields_1_1.done && (_b = fields_1.return)) _b.call(fields_1);
1016
+ }
1017
+ finally { if (e_1) throw e_1.error; }
1018
+ }
1019
+ data = __spreadArray(__spreadArray([], __read(data), false), [columnAndValue], false);
1020
+ _d.label = 3;
1021
+ case 3:
1022
+ round++;
1023
+ return [3 /*break*/, 1];
1024
+ case 4:
1025
+ query = this._queryInsertMultiple(data);
1026
+ this.$db.set('INSERT', this.$utils().constants('INSERT') + " " + this.$db.get('TABLE_NAME') + " " + query);
1027
+ this.$db.set('SAVE', 'INSERT_MULTIPLE');
1028
+ return [2 /*return*/, this.save()];
1029
+ }
1030
+ });
1031
+ });
1032
+ };
1033
+ Database.prototype.truncate = function () {
1034
+ return __awaiter(this, void 0, void 0, function () {
1035
+ var sql;
1036
+ return __generator(this, function (_a) {
1037
+ switch (_a.label) {
1038
+ case 0:
1039
+ sql = "TRUNCATE TABLE " + this.$db.get('TABLE_NAME');
1040
+ return [4 /*yield*/, this._queryStatement(sql)];
1041
+ case 1:
1042
+ _a.sent();
1043
+ return [2 /*return*/, true];
1044
+ }
1045
+ });
1046
+ });
1047
+ };
1048
+ Database.prototype.drop = function () {
1049
+ return __awaiter(this, void 0, void 0, function () {
1050
+ var sql;
1051
+ return __generator(this, function (_a) {
1052
+ switch (_a.label) {
1053
+ case 0:
1054
+ sql = "DROP TABLE " + this.$db.get('TABLE_NAME');
1055
+ return [4 /*yield*/, this._queryStatement(sql)];
1056
+ case 1:
1057
+ _a.sent();
1058
+ return [2 /*return*/, true];
1059
+ }
1060
+ });
1061
+ });
1062
+ };
1063
+ Database.prototype._insertNotExists = function () {
1064
+ var _a;
1065
+ return __awaiter(this, void 0, void 0, function () {
1066
+ var sql, check, _b, result, _c, _d, result_1, id, sql_1, data;
1067
+ return __generator(this, function (_e) {
1068
+ switch (_e.label) {
1069
+ case 0:
1070
+ if (!this.$db.get('WHERE'))
1071
+ throw new Error("Can't insert not exists without where condition");
1072
+ sql = '';
1073
+ check = false;
1074
+ sql = this.$utils().constants('SELECT') + " " + this.$utils().constants('EXISTS') + "(" + this.$utils().constants('SELECT') + " * " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$db.get('WHERE') + " " + this.$utils().constants('LIMIT') + " 1) " + this.$utils().constants('AS') + " 'exists'";
1075
+ return [4 /*yield*/, this._queryStatement(sql)];
1076
+ case 1:
1077
+ _b = __read.apply(void 0, [_e.sent(), 1]), result = _b[0].exists;
1078
+ check = !!parseInt(result);
1079
+ _c = check;
1080
+ switch (_c) {
1081
+ case false: return [3 /*break*/, 2];
1082
+ case true: return [3 /*break*/, 6];
1083
+ }
1084
+ return [3 /*break*/, 7];
1085
+ case 2: return [4 /*yield*/, this._actionStatement({ sql: this.$db.get('INSERT'), returnId: true })];
1086
+ case 3:
1087
+ _d = __read.apply(void 0, [_e.sent(), 2]), result_1 = _d[0], id = _d[1];
1088
+ if (this.$db.get('TRANSACTION')) {
1089
+ (_a = this.$db.get('TRANSACTION')) === null || _a === void 0 ? void 0 : _a.query.push({
1090
+ table: this.$db.get('TABLE_NAME'),
1091
+ id: id
1092
+ });
1093
+ }
1094
+ if (!result_1) return [3 /*break*/, 5];
1095
+ sql_1 = this.$db.get('SELECT') + " " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$utils().constants('WHERE') + " id = " + id;
1096
+ return [4 /*yield*/, this._queryStatement(sql_1)];
1097
+ case 4:
1098
+ data = _e.sent();
1099
+ return [2 /*return*/, (data === null || data === void 0 ? void 0 : data.shift()) || null];
1100
+ case 5: return [2 /*return*/, null];
1101
+ case 6:
1102
+ {
1103
+ return [2 /*return*/, null];
1104
+ }
1105
+ _e.label = 7;
1106
+ case 7:
1107
+ {
1108
+ return [2 /*return*/, null];
1109
+ }
1110
+ _e.label = 8;
1111
+ case 8: return [2 /*return*/];
1112
+ }
1113
+ });
1114
+ });
1115
+ };
1116
+ Database.prototype._queryStatement = function (sql) {
1117
+ return __awaiter(this, void 0, void 0, function () {
1118
+ var CONNECTION, result, err_1;
1119
+ return __generator(this, function (_a) {
1120
+ switch (_a.label) {
1121
+ case 0:
1122
+ _a.trys.push([0, 3, , 4]);
1123
+ if (this.$db.get('DEBUG'))
1124
+ this.$utils().consoleDebug(sql);
1125
+ return [4 /*yield*/, this.$utils().connection()];
1126
+ case 1:
1127
+ CONNECTION = _a.sent();
1128
+ return [4 /*yield*/, CONNECTION.query(sql)];
1129
+ case 2:
1130
+ result = _a.sent();
1131
+ return [2 /*return*/, result];
1132
+ case 3:
1133
+ err_1 = _a.sent();
1134
+ throw new Error(err_1.message);
1135
+ case 4: return [2 /*return*/];
1136
+ }
1137
+ });
1138
+ });
1139
+ };
1140
+ Database.prototype._actionStatement = function (_a) {
1141
+ var _b = _a === void 0 ? {} : _a, sql = _b.sql, _c = _b.returnId, returnId = _c === void 0 ? false : _c;
1142
+ return __awaiter(this, void 0, void 0, function () {
1143
+ var CONNECTION, result_2, result, err_2;
1144
+ return __generator(this, function (_d) {
1145
+ switch (_d.label) {
1146
+ case 0:
1147
+ _d.trys.push([0, 5, , 6]);
1148
+ return [4 /*yield*/, this.$utils().connection()];
1149
+ case 1:
1150
+ CONNECTION = _d.sent();
1151
+ if (this.$db.get('DEBUG'))
1152
+ this.$utils().consoleDebug(sql);
1153
+ if (!returnId) return [3 /*break*/, 3];
1154
+ return [4 /*yield*/, CONNECTION.query(sql)];
1155
+ case 2:
1156
+ result_2 = _d.sent();
1157
+ return [2 /*return*/, [result_2.affectedRows, result_2.insertId]];
1158
+ case 3: return [4 /*yield*/, CONNECTION.query(sql)];
1159
+ case 4:
1160
+ result = (_d.sent()).affectedRows;
1161
+ return [2 /*return*/, result];
1162
+ case 5:
1163
+ err_2 = _d.sent();
1164
+ throw new Error(err_2.message);
1165
+ case 6: return [2 /*return*/];
1166
+ }
1167
+ });
1168
+ });
1169
+ };
1170
+ Database.prototype._create = function () {
1171
+ return __awaiter(this, void 0, void 0, function () {
1172
+ var _a, result, id, sql, data, result_3;
1173
+ return __generator(this, function (_b) {
1174
+ switch (_b.label) {
1175
+ case 0: return [4 /*yield*/, this._actionStatement({ sql: this.$db.get('INSERT'), returnId: true })];
1176
+ case 1:
1177
+ _a = __read.apply(void 0, [_b.sent(), 2]), result = _a[0], id = _a[1];
1178
+ if (this.$db.get('TRANSACTION')) {
1179
+ this.$db.get('TRANSACTION').query.push({
1180
+ table: this.$db.get('TABLE_NAME'),
1181
+ id: id
1182
+ });
1183
+ }
1184
+ if (!result) return [3 /*break*/, 3];
1185
+ sql = this.$db.get('SELECT') + " " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$utils().constants('WHERE') + " id = " + id;
1186
+ return [4 /*yield*/, this._queryStatement(sql)];
1187
+ case 2:
1188
+ data = _b.sent();
1189
+ result_3 = (data === null || data === void 0 ? void 0 : data.shift()) || null;
1190
+ this.$db.set('RESULT', result_3);
1191
+ return [2 /*return*/, result_3];
1192
+ case 3: return [2 /*return*/, null];
1193
+ }
1194
+ });
1195
+ });
1196
+ };
1197
+ Database.prototype._createMultiple = function () {
1198
+ return __awaiter(this, void 0, void 0, function () {
1199
+ var _a, result, id, arrayId, arrayId_1, arrayId_1_1, id_1, sql, data, resultData;
1200
+ var e_2, _b;
1201
+ return __generator(this, function (_c) {
1202
+ switch (_c.label) {
1203
+ case 0: return [4 /*yield*/, this._actionStatement({ sql: this.$db.get('INSERT'), returnId: true })];
1204
+ case 1:
1205
+ _a = __read.apply(void 0, [_c.sent(), 2]), result = _a[0], id = _a[1];
1206
+ if (!result) return [3 /*break*/, 3];
1207
+ arrayId = __spreadArray([], __read(Array(result)), false).map(function (_, i) { return i + id; });
1208
+ try {
1209
+ for (arrayId_1 = __values(arrayId), arrayId_1_1 = arrayId_1.next(); !arrayId_1_1.done; arrayId_1_1 = arrayId_1.next()) {
1210
+ id_1 = arrayId_1_1.value;
1211
+ if (this.$db.get('TRANSACTION')) {
1212
+ this.$db.get('TRANSACTION').query.push({
1213
+ table: this.$db.get('TABLE_NAME'),
1214
+ id: id_1
1215
+ });
1216
+ }
1217
+ }
1218
+ }
1219
+ catch (e_2_1) { e_2 = { error: e_2_1 }; }
1220
+ finally {
1221
+ try {
1222
+ if (arrayId_1_1 && !arrayId_1_1.done && (_b = arrayId_1.return)) _b.call(arrayId_1);
1223
+ }
1224
+ finally { if (e_2) throw e_2.error; }
1225
+ }
1226
+ sql = this.$db.get('SELECT') + " " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$utils().constants('WHERE') + " id " + this.$utils().constants('IN') + " (" + arrayId + ")";
1227
+ return [4 /*yield*/, this._queryStatement(sql)];
1228
+ case 2:
1229
+ data = _c.sent();
1230
+ resultData = data || null;
1231
+ this.$db.set('RESULT', resultData);
1232
+ return [2 /*return*/, resultData];
1233
+ case 3: return [2 /*return*/, null];
1234
+ }
1235
+ });
1236
+ });
1237
+ };
1238
+ Database.prototype._updateOrInsert = function () {
1239
+ return __awaiter(this, void 0, void 0, function () {
1240
+ var sql, check, _a, result, _b, _c, result_4, id, sql_2, data, resultData, result_5, data, data_1, data_1_1, val;
1241
+ var e_3, _d;
1242
+ return __generator(this, function (_e) {
1243
+ switch (_e.label) {
1244
+ case 0:
1245
+ if (!this.$db.get('WHERE'))
1246
+ throw new Error("Can't update or insert without where condition");
1247
+ sql = '';
1248
+ check = false;
1249
+ sql = this.$utils().constants('SELECT') + " " + this.$utils().constants('EXISTS') + "(" + this.$utils().constants('SELECT') + " * " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$db.get('WHERE') + " " + this.$utils().constants('LIMIT') + " 1) " + this.$utils().constants('AS') + " 'exists'";
1250
+ return [4 /*yield*/, this._queryStatement(sql)];
1251
+ case 1:
1252
+ _a = __read.apply(void 0, [_e.sent(), 1]), result = _a[0].exists;
1253
+ check = !!parseInt(result);
1254
+ _b = check;
1255
+ switch (_b) {
1256
+ case false: return [3 /*break*/, 2];
1257
+ case true: return [3 /*break*/, 6];
1258
+ }
1259
+ return [3 /*break*/, 10];
1260
+ case 2: return [4 /*yield*/, this._actionStatement({ sql: this.$db.get('INSERT'), returnId: true })];
1261
+ case 3:
1262
+ _c = __read.apply(void 0, [_e.sent(), 2]), result_4 = _c[0], id = _c[1];
1263
+ if (this.$db.get('TRANSACTION')) {
1264
+ this.$db.get('TRANSACTION').query.push({
1265
+ table: this.$db.get('TABLE_NAME'),
1266
+ id: id
1267
+ });
1268
+ }
1269
+ if (!result_4) return [3 /*break*/, 5];
1270
+ sql_2 = this.$db.get('SELECT') + " " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$utils().constants('WHERE') + " id = " + id;
1271
+ return [4 /*yield*/, this._queryStatement(sql_2)];
1272
+ case 4:
1273
+ data = _e.sent();
1274
+ resultData = __assign(__assign({}, data === null || data === void 0 ? void 0 : data.shift()), { action_status: 'insert' }) || null;
1275
+ this.$db.set('RESULT', resultData);
1276
+ return [2 /*return*/, resultData];
1277
+ case 5: return [2 /*return*/, null];
1278
+ case 6: return [4 /*yield*/, this._actionStatement({ sql: this.$db.get('UPDATE') + " " + this.$db.get('WHERE') })];
1279
+ case 7:
1280
+ result_5 = _e.sent();
1281
+ if (!result_5) return [3 /*break*/, 9];
1282
+ return [4 /*yield*/, this._queryStatement(this.$db.get('SELECT') + " " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$db.get('WHERE'))];
1283
+ case 8:
1284
+ data = _e.sent();
1285
+ if ((data === null || data === void 0 ? void 0 : data.length) > 1) {
1286
+ try {
1287
+ for (data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
1288
+ val = data_1_1.value;
1289
+ val.action_status = 'update';
1290
+ }
1291
+ }
1292
+ catch (e_3_1) { e_3 = { error: e_3_1 }; }
1293
+ finally {
1294
+ try {
1295
+ if (data_1_1 && !data_1_1.done && (_d = data_1.return)) _d.call(data_1);
1296
+ }
1297
+ finally { if (e_3) throw e_3.error; }
1298
+ }
1299
+ return [2 /*return*/, data || []];
1300
+ }
1301
+ return [2 /*return*/, __assign(__assign({}, data === null || data === void 0 ? void 0 : data.shift()), { action_status: 'update' }) || null];
1302
+ case 9: return [2 /*return*/, null];
1303
+ case 10:
1304
+ {
1305
+ return [2 /*return*/, null];
1306
+ }
1307
+ _e.label = 11;
1308
+ case 11: return [2 /*return*/];
1309
+ }
1310
+ });
1311
+ });
1312
+ };
1313
+ Database.prototype._update = function (ignoreWhere) {
1314
+ if (ignoreWhere === void 0) { ignoreWhere = false; }
1315
+ return __awaiter(this, void 0, void 0, function () {
1316
+ var result, data, res;
1317
+ return __generator(this, function (_a) {
1318
+ switch (_a.label) {
1319
+ case 0:
1320
+ if (!this.$db.get('WHERE') && !ignoreWhere)
1321
+ throw new Error("Can't update without where condition");
1322
+ return [4 /*yield*/, this._actionStatement({ sql: this.$db.get('UPDATE') + " " + this.$db.get('WHERE') })];
1323
+ case 1:
1324
+ result = _a.sent();
1325
+ if (!result) return [3 /*break*/, 3];
1326
+ return [4 /*yield*/, this._queryStatement(this.$db.get('SELECT') + " " + this.$db.get('FROM') + " " + this.$db.get('TABLE_NAME') + " " + this.$db.get('WHERE'))];
1327
+ case 2:
1328
+ data = _a.sent();
1329
+ if ((data === null || data === void 0 ? void 0 : data.length) > 1)
1330
+ return [2 /*return*/, data || []];
1331
+ res = (data === null || data === void 0 ? void 0 : data.shift()) || null;
1332
+ this.$db.set('RESULT', res);
1333
+ return [2 /*return*/, res];
1334
+ case 3: return [2 /*return*/, null];
1335
+ }
1336
+ });
1337
+ });
1338
+ };
1339
+ Database.prototype._hiddenColumn = function (data) {
1340
+ var _a;
1341
+ var hidden = this.$db.get('HIDDEN');
1342
+ if ((_a = Object.keys(data)) === null || _a === void 0 ? void 0 : _a.length) {
1343
+ hidden.forEach(function (column) {
1344
+ data.forEach(function (objColumn) {
1345
+ delete objColumn[column];
1346
+ });
1347
+ });
1348
+ }
1349
+ return data;
1350
+ };
1351
+ Database.prototype._queryUpdate = function (data) {
1352
+ var _this = this;
1353
+ var keyValue = Object.entries(data).map(function (_a) {
1354
+ var _b = __read(_a, 2), column = _b[0], value = _b[1];
1355
+ return column + " = " + (value == null || value === 'NULL' ?
1356
+ 'NULL' :
1357
+ "'" + _this.$utils().covertBooleanToNumber(value) + "'");
1358
+ });
1359
+ return this.$utils().constants('SET') + " " + keyValue;
1360
+ };
1361
+ Database.prototype._queryInsert = function (data) {
1362
+ var _this = this;
1363
+ var columns = Object.keys(data).map(function (column) { return "" + column; });
1364
+ var values = Object.values(data).map(function (value) {
1365
+ return "" + (value == null || value === 'NULL' ?
1366
+ 'NULL' :
1367
+ "'" + _this.$utils().covertBooleanToNumber(value) + "'");
1368
+ });
1369
+ return "(" + columns + ") " + this.$utils().constants('VALUES') + " (" + values + ")";
1370
+ };
1371
+ Database.prototype._queryInsertMultiple = function (data) {
1372
+ var e_4, _a;
1373
+ var _this = this;
1374
+ var _b;
1375
+ var values = [];
1376
+ try {
1377
+ for (var data_2 = __values(data), data_2_1 = data_2.next(); !data_2_1.done; data_2_1 = data_2.next()) {
1378
+ var objects = data_2_1.value;
1379
+ var vals = Object.values(objects).map(function (value) {
1380
+ return "" + (value == null || value === 'NULL' ?
1381
+ 'NULL' :
1382
+ "'" + _this.$utils().covertBooleanToNumber(value) + "'");
1383
+ });
1384
+ values.push("(" + vals.join(',') + ")");
1385
+ }
1386
+ }
1387
+ catch (e_4_1) { e_4 = { error: e_4_1 }; }
1388
+ finally {
1389
+ try {
1390
+ if (data_2_1 && !data_2_1.done && (_a = data_2.return)) _a.call(data_2);
1391
+ }
1392
+ finally { if (e_4) throw e_4.error; }
1393
+ }
1394
+ var columns = Object.keys((_b = data[0]) !== null && _b !== void 0 ? _b : []).map(function (column) { return "" + column; });
1395
+ return "(" + columns + ") " + this.$utils().constants('VALUES') + " " + values.join(',');
1396
+ };
1397
+ Database.prototype._valueAndOperator = function (value, operator, useDefault) {
1398
+ if (useDefault === void 0) { useDefault = false; }
1399
+ if (useDefault)
1400
+ return [operator, '='];
1401
+ if (operator === this.$utils().constants('LIKE'))
1402
+ operator = operator.toUpperCase();
1403
+ return [value, operator];
1404
+ };
1405
+ Database.prototype._valueTrueFalse = function (value) {
1406
+ if (value === true)
1407
+ return 1;
1408
+ if (value === false)
1409
+ return 0;
1410
+ return value;
1411
+ };
1412
+ Database.prototype._getSQL = function () {
1413
+ var arraySql = [];
1414
+ if (this.$db.get('INSERT')) {
1415
+ arraySql = [
1416
+ this.$db.get('INSERT'),
1417
+ ];
1418
+ }
1419
+ else if (this.$db.get('UPDATE')) {
1420
+ arraySql = [
1421
+ this.$db.get('UPDATE'),
1422
+ this.$db.get('WHERE'),
1423
+ ];
1424
+ }
1425
+ else if (this.$db.get('DELETE')) {
1426
+ arraySql = [
1427
+ this.$db.get('DELETE')
1428
+ ];
1429
+ }
1430
+ else {
1431
+ arraySql = [
1432
+ this.$db.get('SELECT'),
1433
+ this.$db.get('FROM'),
1434
+ this.$db.get('TABLE_NAME'),
1435
+ this.$db.get('JOIN'),
1436
+ this.$db.get('WHERE'),
1437
+ this.$db.get('GROUP_BY'),
1438
+ this.$db.get('HAVING'),
1439
+ this.$db.get('ORDER_BY'),
1440
+ this.$db.get('LIMIT'),
1441
+ this.$db.get('OFFSET')
1442
+ ];
1443
+ }
1444
+ var filterSql = arraySql.filter(function (data) { return data !== ''; });
1445
+ var sql = filterSql.join(' ');
1446
+ return sql;
1447
+ };
1448
+ return Database;
1449
+ }(AbstractDatabase_1.default));
1450
+ exports.default = Database;