@mrnafisia/type-query 1.0.40 → 1.0.41

package/dist/testUtil.js

@@ -1,331 +1,334 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            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;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTestTableData = exports.testTransaction = void 0;
-var lodash_1 = require("lodash");
-var entity_1 = require("./entity");
-var never_catch_1 = require("never-catch");
-var schema_1 = require("./schema");
-var testTransaction = function (tablesWithData, callback, pool, isolationLevel, rollback) {
-    if (isolationLevel === void 0) { isolationLevel = 'serializable'; }
-    if (rollback === void 0) { rollback = true; }
-    return __awaiter(void 0, void 0, void 0, function () {
-        var error;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, pool.transaction(function (client) { return __awaiter(void 0, void 0, void 0, function () {
-                        var createTableResult, resolvedTablesResult, sortedTablesWithData, _i, sortedTablesWithData_1, tableWithData, insertResult, differences, _loop_1, _a, sortedTablesWithData_2, _b, table, finalData, skipIt, lengthCheck, state_1;
-                        var _c;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0: return [4 /*yield*/, (0, schema_1.createTables)(client, tablesWithData.map(function (v) { return v.table; }))];
-                                case 1:
-                                    createTableResult = _d.sent();
-                                    if (!createTableResult.ok) {
-                                        error = createTableResult;
-                                        return [2 /*return*/, (0, never_catch_1.err)(undefined)];
-                                    }
-                                    resolvedTablesResult = (0, schema_1.resolveTablesDependency)(tablesWithData.map(function (v) { return v.table; }));
-                                    if (!resolvedTablesResult.ok) {
-                                        error = resolvedTablesResult;
-                                        return [2 /*return*/, (0, never_catch_1.err)(undefined)];
-                                    }
-                                    sortedTablesWithData = tablesWithData.sort(function (a, b) { return resolvedTablesResult.value.indexOf(a.table) - resolvedTablesResult.value.indexOf(b.table); });
-                                    _i = 0, sortedTablesWithData_1 = sortedTablesWithData;
-                                    _d.label = 2;
-                                case 2:
-                                    if (!(_i < sortedTablesWithData_1.length)) return [3 /*break*/, 5];
-                                    tableWithData = sortedTablesWithData_1[_i];
-                                    if (!(tableWithData.startData.length !== 0)) return [3 /*break*/, 4];
-                                    return [4 /*yield*/, (0, entity_1.createEntity)(tableWithData.table)
-                                            .insert(tableWithData.startData, [{ exp: true, as: 'confirm' }], {
-                                            nullableDefaultColumns: Object.entries(tableWithData.table.columns).filter(function (_a) {
-                                                var _ = _a[0], value = _a[1];
-                                                return value.nullable || value.default !== false;
-                                            }).map(function (_a) {
-                                                var key = _a[0], _ = _a[1];
-                                                return key;
-                                            })
-                                        }).exec(client, ['count', tableWithData.startData.length])];
-                                case 3:
-                                    insertResult = _d.sent();
-                                    if (!insertResult.ok) {
-                                        error = insertResult;
-                                        return [2 /*return*/, (0, never_catch_1.err)(undefined)];
-                                    }
-                                    _d.label = 4;
-                                case 4:
-                                    _i++;
-                                    return [3 /*break*/, 2];
-                                case 5: 
-                                // callback
-                                return [4 /*yield*/, callback(client)];
-                                case 6:
-                                    // callback
-                                    _d.sent();
-                                    differences = [];
-                                    _loop_1 = function (table, finalData, skipIt, lengthCheck) {
-                                        var primaryKeys, selectResult, result, usage, _loop_2, _e, _f, dbRow, i, _g, mode, number, result;
-                                        return __generator(this, function (_h) {
-                                            switch (_h.label) {
-                                                case 0:
-                                                    primaryKeys = Object.entries(table.columns).filter(function (_a) {
-                                                        var _ = _a[0], value = _a[1];
-                                                        return !value.nullable && value.primary;
-                                                    }).map(function (_a) {
-                                                        var key = _a[0], _ = _a[1];
-                                                        return key;
-                                                    });
-                                                    return [4 /*yield*/, (0, entity_1.createEntity)(table)
-                                                            .select(Object.keys(table.columns), true).exec(client, [])];
-                                                case 1:
-                                                    selectResult = _h.sent();
-                                                    if (!selectResult.ok) {
-                                                        error = selectResult;
-                                                        return [2 /*return*/, { value: (0, never_catch_1.err)(undefined) }];
-                                                    }
-                                                    if (!(typeof finalData === 'function')) return [3 /*break*/, 3];
-                                                    return [4 /*yield*/, finalData(selectResult.value)];
-                                                case 2:
-                                                    result = _h.sent();
-                                                    if (!result.ok) {
-                                                        differences.push(result.error);
-                                                    }
-                                                    return [2 /*return*/, "continue"];
-                                                case 3:
-                                                    usage = new Array(finalData.length).fill(0);
-                                                    _loop_2 = function (dbRow) {
-                                                        var found, tempDifferences, candidateFinalData, i, finalRow, _j, _k, _l, key, value, result, customCheckResult;
-                                                        return __generator(this, function (_m) {
-                                                            switch (_m.label) {
-                                                                case 0:
-                                                                    found = false;
-                                                                    tempDifferences = [];
-                                                                    candidateFinalData = finalData.filter(function (_a) {
-                                                                        var finalRow = _a.row;
-                                                                        for (var _i = 0, primaryKeys_1 = primaryKeys; _i < primaryKeys_1.length; _i++) {
-                                                                            var primaryKey = primaryKeys_1[_i];
-                                                                            if (!(0, lodash_1.isEqual)(finalRow[primaryKey], dbRow[primaryKey])) {
-                                                                                return false;
-                                                                            }
-                                                                        }
-                                                                        return true;
-                                                                    });
-                                                                    i = 0;
-                                                                    _m.label = 1;
-                                                                case 1:
-                                                                    if (!(i < candidateFinalData.length)) return [3 /*break*/, 8];
-                                                                    found = true;
-                                                                    finalRow = candidateFinalData[i].row;
-                                                                    _j = [];
-                                                                    for (_k in dbRow)
-                                                                        _j.push(_k);
-                                                                    _l = 0;
-                                                                    _m.label = 2;
-                                                                case 2:
-                                                                    if (!(_l < _j.length)) return [3 /*break*/, 6];
-                                                                    key = _j[_l];
-                                                                    value = finalRow[key];
-                                                                    if (!(typeof value === 'function')) return [3 /*break*/, 4];
-                                                                    return [4 /*yield*/, value(dbRow[key], dbRow, selectResult.value)];
-                                                                case 3:
-                                                                    result = _m.sent();
-                                                                    if (!result.ok) {
-                                                                        tempDifferences.push({
-                                                                            dbRow: dbRow,
-                                                                            finalRow: finalRow,
-                                                                            key: key,
-                                                                            message: "->".concat(JSON.stringify(dbRow[key]), "<- did not accepted by match function")
-                                                                        });
-                                                                        found = false;
-                                                                    }
-                                                                    return [3 /*break*/, 5];
-                                                                case 4:
-                                                                    if (!(0, lodash_1.isEqual)(dbRow[key], value)) {
-                                                                        tempDifferences.push({
-                                                                            dbRow: dbRow,
-                                                                            finalRow: finalRow,
-                                                                            key: key,
-                                                                            message: "->".concat(JSON.stringify(dbRow[key]), "<- is not equal to ->").concat(JSON.stringify(value), "<-")
-                                                                        });
-                                                                        found = false;
-                                                                    }
-                                                                    _m.label = 5;
-                                                                case 5:
-                                                                    _l++;
-                                                                    return [3 /*break*/, 2];
-                                                                case 6:
-                                                                    if (found) {
-                                                                        usage[finalData.indexOf(candidateFinalData[i])]++;
-                                                                        return [3 /*break*/, 8];
-                                                                    }
-                                                                    _m.label = 7;
-                                                                case 7:
-                                                                    i++;
-                                                                    return [3 /*break*/, 1];
-                                                                case 8:
-                                                                    if (!(!found && skipIt !== undefined)) return [3 /*break*/, 10];
-                                                                    return [4 /*yield*/, skipIt(dbRow)];
-                                                                case 9:
-                                                                    customCheckResult = _m.sent();
-                                                                    if (customCheckResult.ok) {
-                                                                        found = true;
-                                                                    }
-                                                                    _m.label = 10;
-                                                                case 10:
-                                                                    if (!found) {
-                                                                        if (tempDifferences.length === 0) {
-                                                                            tempDifferences.push("following row was not found ".concat(JSON.stringify(dbRow)));
-                                                                        }
-                                                                        differences.push.apply(differences, tempDifferences);
-                                                                    }
-                                                                    return [2 /*return*/];
-                                                            }
-                                                        });
-                                                    };
-                                                    _e = 0, _f = selectResult.value;
-                                                    _h.label = 4;
-                                                case 4:
-                                                    if (!(_e < _f.length)) return [3 /*break*/, 7];
-                                                    dbRow = _f[_e];
-                                                    return [5 /*yield**/, _loop_2(dbRow)];
-                                                case 5:
-                                                    _h.sent();
-                                                    _h.label = 6;
-                                                case 6:
-                                                    _e++;
-                                                    return [3 /*break*/, 4];
-                                                case 7:
-                                                    for (i = 0; i < finalData.length; i++) {
-                                                        _g = (_c = finalData[i].useTime) !== null && _c !== void 0 ? _c : ['equal', 1], mode = _g[0], number = _g[1];
-                                                        if (number === -1) {
-                                                            continue;
-                                                        }
-                                                        switch (mode) {
-                                                            case 'equal':
-                                                                if (number !== usage[i]) {
-                                                                    differences.push({
-                                                                        finalRow: finalData[i].row,
-                                                                        index: i,
-                                                                        message: "expect this final row to be used ".concat(number, " times, but It got used ").concat(usage[i], " times")
-                                                                    });
-                                                                }
-                                                                break;
-                                                            case 'lessThanEqual':
-                                                                if (number < usage[i]) {
-                                                                    differences.push({
-                                                                        finalRow: finalData[i].row,
-                                                                        index: i,
-                                                                        message: "expect this final row to be used less than ".concat(number, " times, but It got used ").concat(usage[i], " times")
-                                                                    });
-                                                                }
-                                                                break;
-                                                            case 'moreThanEqual':
-                                                                if (number > usage[i]) {
-                                                                    differences.push({
-                                                                        finalRow: finalData[i].row,
-                                                                        index: i,
-                                                                        message: "expect this final row to be more than ".concat(number, " times, but It got used ").concat(usage[i], " times")
-                                                                    });
-                                                                }
-                                                                break;
-                                                        }
-                                                    }
-                                                    if (!(lengthCheck !== undefined)) return [3 /*break*/, 10];
-                                                    if (!(typeof lengthCheck === 'function')) return [3 /*break*/, 9];
-                                                    return [4 /*yield*/, lengthCheck(selectResult.value)];
-                                                case 8:
-                                                    result = _h.sent();
-                                                    if (!result.ok) {
-                                                        differences.push("length check failed ".concat(result.error));
-                                                    }
-                                                    return [3 /*break*/, 10];
-                                                case 9:
-                                                    if (selectResult.value.length !== lengthCheck) {
-                                                        differences.push("length check failed expected(".concat(lengthCheck, ") received(").concat(selectResult.value.length, ")"));
-                                                    }
-                                                    _h.label = 10;
-                                                case 10: return [2 /*return*/];
-                                            }
-                                        });
-                                    };
-                                    _a = 0, sortedTablesWithData_2 = sortedTablesWithData;
-                                    _d.label = 7;
-                                case 7:
-                                    if (!(_a < sortedTablesWithData_2.length)) return [3 /*break*/, 10];
-                                    _b = sortedTablesWithData_2[_a], table = _b.table, finalData = _b.finalData, skipIt = _b.skipIt, lengthCheck = _b.lengthCheck;
-                                    return [5 /*yield**/, _loop_1(table, finalData, skipIt, lengthCheck)];
-                                case 8:
-                                    state_1 = _d.sent();
-                                    if (typeof state_1 === "object")
-                                        return [2 /*return*/, state_1.value];
-                                    _d.label = 9;
-                                case 9:
-                                    _a++;
-                                    return [3 /*break*/, 7];
-                                case 10:
-                                    if (differences.length !== 0) {
-                                        error = (0, never_catch_1.err)(differences);
-                                    }
-                                    if (rollback) {
-                                        return [2 /*return*/, (0, never_catch_1.err)(undefined)];
-                                    }
-                                    else {
-                                        return [2 /*return*/, (0, never_catch_1.ok)(undefined)];
-                                    }
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); }, isolationLevel)];
-                case 1:
-                    _a.sent();
-                    if (error === undefined) {
-                        return [2 /*return*/, undefined];
-                    }
-                    else {
-                        throw error;
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
-};
-exports.testTransaction = testTransaction;
-var createTestTableData = function (table, startData, finalData, skipIt, lengthCheck) { return ({ table: table, startData: startData, finalData: finalData, skipIt: skipIt, lengthCheck: lengthCheck }); };
-exports.createTestTableData = createTestTableData;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            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;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestTableData = exports.testTransaction = void 0;
+var lodash_1 = require("lodash");
+var entity_1 = require("./entity");
+var never_catch_1 = require("never-catch");
+var schema_1 = require("./schema");
+var testTransaction = function (tablesWithData, callback, pool, isolationLevel, rollback) {
+    if (isolationLevel === void 0) { isolationLevel = 'serializable'; }
+    if (rollback === void 0) { rollback = true; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var error;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, pool.transaction(function (client) { return __awaiter(void 0, void 0, void 0, function () {
+                        var createTableResult, resolvedTablesResult, sortedTablesWithData, _i, sortedTablesWithData_1, tableWithData, insertResult, differences, _loop_1, _a, sortedTablesWithData_2, _b, table, finalData, skipIt, lengthCheck, state_1;
+                        var _c;
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0: return [4 /*yield*/, (0, schema_1.createTables)(client, tablesWithData.map(function (v) { return v.table; }))];
+                                case 1:
+                                    createTableResult = _d.sent();
+                                    if (!createTableResult.ok) {
+                                        error = createTableResult;
+                                        return [2 /*return*/, (0, never_catch_1.err)(undefined)];
+                                    }
+                                    resolvedTablesResult = (0, schema_1.resolveTablesDependency)(tablesWithData.map(function (v) { return v.table; }));
+                                    if (!resolvedTablesResult.ok) {
+                                        error = resolvedTablesResult;
+                                        return [2 /*return*/, (0, never_catch_1.err)(undefined)];
+                                    }
+                                    sortedTablesWithData = tablesWithData.sort(function (a, b) { return resolvedTablesResult.value.indexOf(a.table) - resolvedTablesResult.value.indexOf(b.table); });
+                                    _i = 0, sortedTablesWithData_1 = sortedTablesWithData;
+                                    _d.label = 2;
+                                case 2:
+                                    if (!(_i < sortedTablesWithData_1.length)) return [3 /*break*/, 5];
+                                    tableWithData = sortedTablesWithData_1[_i];
+                                    if (!(tableWithData.startData.length !== 0)) return [3 /*break*/, 4];
+                                    return [4 /*yield*/, (0, entity_1.createEntity)(tableWithData.table)
+                                            .insert(tableWithData.startData, [{ exp: true, as: 'confirm' }], {
+                                            nullableDefaultColumns: Object.entries(tableWithData.table.columns).filter(function (_a) {
+                                                var _ = _a[0], value = _a[1];
+                                                return value.nullable || value.default !== false;
+                                            }).map(function (_a) {
+                                                var key = _a[0], _ = _a[1];
+                                                return key;
+                                            })
+                                        }).exec(client, ['count', tableWithData.startData.length])];
+                                case 3:
+                                    insertResult = _d.sent();
+                                    if (!insertResult.ok) {
+                                        error = insertResult;
+                                        return [2 /*return*/, (0, never_catch_1.err)(undefined)];
+                                    }
+                                    _d.label = 4;
+                                case 4:
+                                    _i++;
+                                    return [3 /*break*/, 2];
+                                case 5: 
+                                // callback
+                                return [4 /*yield*/, callback(client)];
+                                case 6:
+                                    // callback
+                                    _d.sent();
+                                    differences = [];
+                                    _loop_1 = function (table, finalData, skipIt, lengthCheck) {
+                                        var primaryKeys, selectResult, result, usage, _loop_2, _e, _f, dbRow, i, _g, mode, number, result;
+                                        return __generator(this, function (_h) {
+                                            switch (_h.label) {
+                                                case 0:
+                                                    primaryKeys = Object.entries(table.columns).filter(function (_a) {
+                                                        var _ = _a[0], value = _a[1];
+                                                        return !value.nullable && value.primary;
+                                                    }).map(function (_a) {
+                                                        var key = _a[0], _ = _a[1];
+                                                        return key;
+                                                    });
+                                                    return [4 /*yield*/, (0, entity_1.createEntity)(table)
+                                                            .select(Object.keys(table.columns), true).exec(client, [])];
+                                                case 1:
+                                                    selectResult = _h.sent();
+                                                    if (!selectResult.ok) {
+                                                        error = selectResult;
+                                                        return [2 /*return*/, { value: (0, never_catch_1.err)(undefined) }];
+                                                    }
+                                                    if (!(typeof finalData === 'function')) return [3 /*break*/, 3];
+                                                    return [4 /*yield*/, finalData(selectResult.value)];
+                                                case 2:
+                                                    result = _h.sent();
+                                                    if (!result.ok) {
+                                                        differences.push(result.error);
+                                                    }
+                                                    return [2 /*return*/, "continue"];
+                                                case 3:
+                                                    usage = new Array(finalData.length).fill(0);
+                                                    _loop_2 = function (dbRow) {
+                                                        var found, tempDifferences, candidateFinalData, i, finalRow, _j, _k, _l, _m, key, value, result, customCheckResult;
+                                                        return __generator(this, function (_o) {
+                                                            switch (_o.label) {
+                                                                case 0:
+                                                                    found = false;
+                                                                    tempDifferences = [];
+                                                                    candidateFinalData = finalData.filter(function (_a) {
+                                                                        var finalRow = _a.row;
+                                                                        for (var _i = 0, primaryKeys_1 = primaryKeys; _i < primaryKeys_1.length; _i++) {
+                                                                            var primaryKey = primaryKeys_1[_i];
+                                                                            if (!(0, lodash_1.isEqual)(finalRow[primaryKey], dbRow[primaryKey])) {
+                                                                                return false;
+                                                                            }
+                                                                        }
+                                                                        return true;
+                                                                    });
+                                                                    i = 0;
+                                                                    _o.label = 1;
+                                                                case 1:
+                                                                    if (!(i < candidateFinalData.length)) return [3 /*break*/, 8];
+                                                                    found = true;
+                                                                    finalRow = candidateFinalData[i].row;
+                                                                    _j = dbRow;
+                                                                    _k = [];
+                                                                    for (_l in _j)
+                                                                        _k.push(_l);
+                                                                    _m = 0;
+                                                                    _o.label = 2;
+                                                                case 2:
+                                                                    if (!(_m < _k.length)) return [3 /*break*/, 6];
+                                                                    _l = _k[_m];
+                                                                    if (!(_l in _j)) return [3 /*break*/, 5];
+                                                                    key = _l;
+                                                                    value = finalRow[key];
+                                                                    if (!(typeof value === 'function')) return [3 /*break*/, 4];
+                                                                    return [4 /*yield*/, value(dbRow[key], dbRow, selectResult.value)];
+                                                                case 3:
+                                                                    result = _o.sent();
+                                                                    if (!result.ok) {
+                                                                        tempDifferences.push({
+                                                                            dbRow: dbRow,
+                                                                            finalRow: finalRow,
+                                                                            key: key,
+                                                                            message: "->".concat(JSON.stringify(dbRow[key]), "<- did not accepted by match function")
+                                                                        });
+                                                                        found = false;
+                                                                    }
+                                                                    return [3 /*break*/, 5];
+                                                                case 4:
+                                                                    if (!(0, lodash_1.isEqual)(dbRow[key], value)) {
+                                                                        tempDifferences.push({
+                                                                            dbRow: dbRow,
+                                                                            finalRow: finalRow,
+                                                                            key: key,
+                                                                            message: "->".concat(JSON.stringify(dbRow[key]), "<- is not equal to ->").concat(JSON.stringify(value), "<-")
+                                                                        });
+                                                                        found = false;
+                                                                    }
+                                                                    _o.label = 5;
+                                                                case 5:
+                                                                    _m++;
+                                                                    return [3 /*break*/, 2];
+                                                                case 6:
+                                                                    if (found) {
+                                                                        usage[finalData.indexOf(candidateFinalData[i])]++;
+                                                                        return [3 /*break*/, 8];
+                                                                    }
+                                                                    _o.label = 7;
+                                                                case 7:
+                                                                    i++;
+                                                                    return [3 /*break*/, 1];
+                                                                case 8:
+                                                                    if (!(!found && skipIt !== undefined)) return [3 /*break*/, 10];
+                                                                    return [4 /*yield*/, skipIt(dbRow)];
+                                                                case 9:
+                                                                    customCheckResult = _o.sent();
+                                                                    if (customCheckResult.ok) {
+                                                                        found = true;
+                                                                    }
+                                                                    _o.label = 10;
+                                                                case 10:
+                                                                    if (!found) {
+                                                                        if (tempDifferences.length === 0) {
+                                                                            tempDifferences.push("following row was not found ".concat(JSON.stringify(dbRow)));
+                                                                        }
+                                                                        differences.push.apply(differences, tempDifferences);
+                                                                    }
+                                                                    return [2 /*return*/];
+                                                            }
+                                                        });
+                                                    };
+                                                    _e = 0, _f = selectResult.value;
+                                                    _h.label = 4;
+                                                case 4:
+                                                    if (!(_e < _f.length)) return [3 /*break*/, 7];
+                                                    dbRow = _f[_e];
+                                                    return [5 /*yield**/, _loop_2(dbRow)];
+                                                case 5:
+                                                    _h.sent();
+                                                    _h.label = 6;
+                                                case 6:
+                                                    _e++;
+                                                    return [3 /*break*/, 4];
+                                                case 7:
+                                                    for (i = 0; i < finalData.length; i++) {
+                                                        _g = (_c = finalData[i].useTime) !== null && _c !== void 0 ? _c : ['equal', 1], mode = _g[0], number = _g[1];
+                                                        if (number === -1) {
+                                                            continue;
+                                                        }
+                                                        switch (mode) {
+                                                            case 'equal':
+                                                                if (number !== usage[i]) {
+                                                                    differences.push({
+                                                                        finalRow: finalData[i].row,
+                                                                        index: i,
+                                                                        message: "expect this final row to be used ".concat(number, " times, but It got used ").concat(usage[i], " times")
+                                                                    });
+                                                                }
+                                                                break;
+                                                            case 'lessThanEqual':
+                                                                if (number < usage[i]) {
+                                                                    differences.push({
+                                                                        finalRow: finalData[i].row,
+                                                                        index: i,
+                                                                        message: "expect this final row to be used less than ".concat(number, " times, but It got used ").concat(usage[i], " times")
+                                                                    });
+                                                                }
+                                                                break;
+                                                            case 'moreThanEqual':
+                                                                if (number > usage[i]) {
+                                                                    differences.push({
+                                                                        finalRow: finalData[i].row,
+                                                                        index: i,
+                                                                        message: "expect this final row to be more than ".concat(number, " times, but It got used ").concat(usage[i], " times")
+                                                                    });
+                                                                }
+                                                                break;
+                                                        }
+                                                    }
+                                                    if (!(lengthCheck !== undefined)) return [3 /*break*/, 10];
+                                                    if (!(typeof lengthCheck === 'function')) return [3 /*break*/, 9];
+                                                    return [4 /*yield*/, lengthCheck(selectResult.value)];
+                                                case 8:
+                                                    result = _h.sent();
+                                                    if (!result.ok) {
+                                                        differences.push("length check failed ".concat(result.error));
+                                                    }
+                                                    return [3 /*break*/, 10];
+                                                case 9:
+                                                    if (selectResult.value.length !== lengthCheck) {
+                                                        differences.push("length check failed expected(".concat(lengthCheck, ") received(").concat(selectResult.value.length, ")"));
+                                                    }
+                                                    _h.label = 10;
+                                                case 10: return [2 /*return*/];
+                                            }
+                                        });
+                                    };
+                                    _a = 0, sortedTablesWithData_2 = sortedTablesWithData;
+                                    _d.label = 7;
+                                case 7:
+                                    if (!(_a < sortedTablesWithData_2.length)) return [3 /*break*/, 10];
+                                    _b = sortedTablesWithData_2[_a], table = _b.table, finalData = _b.finalData, skipIt = _b.skipIt, lengthCheck = _b.lengthCheck;
+                                    return [5 /*yield**/, _loop_1(table, finalData, skipIt, lengthCheck)];
+                                case 8:
+                                    state_1 = _d.sent();
+                                    if (typeof state_1 === "object")
+                                        return [2 /*return*/, state_1.value];
+                                    _d.label = 9;
+                                case 9:
+                                    _a++;
+                                    return [3 /*break*/, 7];
+                                case 10:
+                                    if (differences.length !== 0) {
+                                        error = (0, never_catch_1.err)(differences);
+                                    }
+                                    if (rollback) {
+                                        return [2 /*return*/, (0, never_catch_1.err)(undefined)];
+                                    }
+                                    else {
+                                        return [2 /*return*/, (0, never_catch_1.ok)(undefined)];
+                                    }
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); }, isolationLevel)];
+                case 1:
+                    _a.sent();
+                    if (error === undefined) {
+                        return [2 /*return*/, undefined];
+                    }
+                    else {
+                        throw error;
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.testTransaction = testTransaction;
+var createTestTableData = function (table, startData, finalData, skipIt, lengthCheck) { return ({ table: table, startData: startData, finalData: finalData, skipIt: skipIt, lengthCheck: lengthCheck }); };
+exports.createTestTableData = createTestTableData;
 //# sourceMappingURL=testUtil.js.map