@juadz/knex 0.3.1 → 0.5.0

package/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+    presets: [
+        ['@babel/preset-env', {targets: {node: 'current'}}],
+        '@babel/preset-typescript',
+    ],
+};

package/build/basic.d.ts

@@ -0,0 +1,3 @@
+import { IDataRecord, IDataRepositoryProvider } from "@juadz/core";
+import { Knex } from "knex";
+export declare function KnexProvider<T extends IDataRecord>(connection: Knex, dataTableName?: string): IDataRepositoryProvider<T>;

package/build/basic.js

@@ -0,0 +1,200 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnexProvider = KnexProvider;
+var list_1 = require("./list");
+function KnexProvider(connection, dataTableName) {
+    var _this = this;
+    var tableName = dataTableName || null;
+    var searchableFields = [];
+    var filterableFields = [];
+    var sortableFields = [];
+    var init = function (sch) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            if (!tableName) {
+                tableName = sch.name;
+            }
+            searchableFields = Object.entries(sch.flags)
+                .filter(function (_a) {
+                var _ = _a[0], v = _a[1];
+                return v.$search == true;
+            })
+                .map(function (_a) {
+                var k = _a[0], _ = _a[1];
+                return k;
+            });
+            filterableFields = Object.entries(sch.flags)
+                .filter(function (_a) {
+                var _ = _a[0], v = _a[1];
+                return v.$filter == true;
+            })
+                .map(function (_a) {
+                var k = _a[0], _ = _a[1];
+                return k;
+            });
+            sortableFields = Object.entries(sch.flags)
+                .filter(function (_a) {
+                var _ = _a[0], v = _a[1];
+                return v.$sort == true;
+            })
+                .map(function (_a) {
+                var k = _a[0], _ = _a[1];
+                return k;
+            });
+            return [2 /*return*/];
+        });
+    }); };
+    var get = function (id) { return __awaiter(_this, void 0, void 0, function () {
+        var c;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, connection(tableName)
+                        .select("*")
+                        .where("id", id)
+                        .first()];
+                case 1:
+                    c = _a.sent();
+                    return [2 /*return*/, c];
+            }
+        });
+    }); };
+    var update = function (id, patch) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, connection(tableName).where("id", id).update(patch)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, get(id)];
+                case 2: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); };
+    var create = function (params_) { return __awaiter(_this, void 0, void 0, function () {
+        var params, insertedId, inserted, inserted, insertedData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    params = __assign({}, params_);
+                    if (!(connection.client.config.client === "sqlite3")) return [3 /*break*/, 2];
+                    return [4 /*yield*/, connection(tableName)
+                            .returning("id")
+                            .insert(__assign({}, params))];
+                case 1:
+                    inserted = _a.sent();
+                    insertedId = inserted[0].id;
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, connection(tableName)
+                        .returning("id")
+                        .insert(__assign({}, params))];
+                case 3:
+                    inserted = _a.sent();
+                    insertedId = inserted[0];
+                    _a.label = 4;
+                case 4: return [4 /*yield*/, get(insertedId)];
+                case 5:
+                    insertedData = _a.sent();
+                    return [2 /*return*/, insertedData];
+            }
+        });
+    }); };
+    var replace = function (id, params_) { return __awaiter(_this, void 0, void 0, function () {
+        var params, fields, values, insertedData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    params = __assign({ id: id }, params_);
+                    fields = [];
+                    values = [];
+                    Object.keys(params).forEach(function (f) {
+                        fields.push("`".concat(f, "`=?"));
+                        values.push(params[f]);
+                    });
+                    return [4 /*yield*/, connection.raw("REPLACE INTO `".concat(tableName, "` SET ").concat(fields.join(", "), " WHERE id=?"), __spreadArray(__spreadArray([], values, true), [
+                            id, // Ensure the ID is at the end for the WHERE clause
+                        ], false))];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, get(id)];
+                case 2:
+                    insertedData = _a.sent();
+                    return [2 /*return*/, insertedData];
+            }
+        });
+    }); };
+    var delete_ = function (id) { return __awaiter(_this, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, connection(tableName).where("id", id).delete()];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result];
+            }
+        });
+    }); };
+    var list = (0, list_1.KnexQueryList)(connection, tableName, searchableFields, filterableFields, sortableFields);
+    return {
+        init: init,
+        get: get,
+        replace: replace,
+        update: update,
+        create: create,
+        delete: delete_,
+        list: list,
+    };
+}

package/build/index.d.ts

@@ -0,0 +1,3 @@
+import { KnexProvider } from "./basic";
+export default KnexProvider;
+export * from "./list";

package/build/{src/index.js → index.js}

@@ -14,7 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const basic_1 = require("./basic");
-exports.default = basic_1.SimpleKnexConnection;
+var basic_1 = require("./basic");
+exports.default = basic_1.KnexProvider;
 __exportStar(require("./list"), exports);
-//# sourceMappingURL=index.js.map

package/build/list.d.ts

@@ -0,0 +1,6 @@
+import { QueryListFunction } from "@juadz/core";
+import { Knex } from "knex";
+export interface KnexQueryBuilder {
+    clone: () => Knex;
+}
+export declare function KnexQueryList<T>(knex: Knex, tableName: string, searchableFields: string[], filterableFields: string[], sortableFields: string[]): QueryListFunction<T>;

package/build/list.js

@@ -0,0 +1,187 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnexQueryList = KnexQueryList;
+var dayjs_1 = __importDefault(require("dayjs"));
+var debug_1 = __importDefault(require("debug"));
+var debug = (0, debug_1.default)("juadz:knex:list");
+function KnexQueryList(knex, tableName, searchableFields, filterableFields, sortableFields) {
+    var _this = this;
+    return function (params) { return __awaiter(_this, void 0, void 0, function () {
+        var query, sql, sorter, data, totalRow, total;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    query = knex(tableName);
+                    if (params.filter.length > 0) {
+                        debug("Applying filters:", params.filter);
+                        query.where(function (query) {
+                            params.filter.forEach(function (f) {
+                                var field = f.field, op = f.op, value = f.value;
+                                if ((field === "_search") && op === "=") {
+                                    query.andWhere(function (query) {
+                                        (searchableFields || []).forEach(function (k) {
+                                            query.orWhere(k, 'LIKE', "%".concat("".concat(value).replace(/(["'$%]+)/g, ''), "%"));
+                                        });
+                                    });
+                                    return;
+                                }
+                                if (!filterableFields.includes(field)) {
+                                    debug("Field \"".concat(field, "\" is not filterable"));
+                                    return;
+                                }
+                                var values = [];
+                                if (Array.isArray(value)) {
+                                    values = value;
+                                }
+                                switch (op) {
+                                    case "=":
+                                        query.where(field, value);
+                                        return;
+                                    case "!=":
+                                        query.whereNot(field, value);
+                                        return;
+                                    case ">":
+                                    case ">=":
+                                    case "<":
+                                    case "<=":
+                                        query.where(field, op, value);
+                                        return;
+                                    case "in":
+                                        query.whereIn(field, values);
+                                        return;
+                                    case "!in":
+                                        query.whereNotIn(field, values);
+                                        return;
+                                    case "contains":
+                                        query.whereILike(field, "%".concat(value, "%"));
+                                        return;
+                                    case "!contains":
+                                        query.whereRaw("`".concat(field, "` NOT LIKE ?"), [
+                                            "%".concat(value, "%"),
+                                        ]);
+                                        return;
+                                    case "between":
+                                        if (query.client.config.client === "sqlite3") {
+                                            query.whereBetween(field, [
+                                                (0, dayjs_1.default)(values[0]).format("YYYY-MM-DD HH:mm:ss"),
+                                                (0, dayjs_1.default)(values[1]).format("YYYY-MM-DD HH:mm:ss"),
+                                            ]);
+                                        }
+                                        else {
+                                            query.whereBetween(field, [
+                                                values[0],
+                                                values[1],
+                                            ]);
+                                        }
+                                        return;
+                                    case "!between":
+                                        query.whereNotBetween(field, [
+                                            values[0],
+                                            values[1],
+                                        ]);
+                                        return;
+                                    case "null":
+                                        query.whereNull(field);
+                                        return;
+                                    case "!null":
+                                        query.whereNotNull(field);
+                                        return;
+                                }
+                            });
+                        });
+                    }
+                    else {
+                        debug("No filters applied");
+                    }
+                    sql = null;
+                    sorter = params.sort.filter((function (s) {
+                        var pass = sortableFields.includes(s.field);
+                        if (!pass) {
+                            debug("Field \"".concat(s.field, "\" is not sortable"));
+                        }
+                        return pass;
+                    }))
+                        .map(function (s) { return ({
+                        column: s.field,
+                        order: s.direction,
+                    }); });
+                    if (process.env.NODE_ENV !== "production") {
+                        sql = query
+                            .clone()
+                            .offset(params.range.offset)
+                            .limit(params.range.limit)
+                            .orderBy(sorter)
+                            .toString();
+                        debug("SQL Query:", sql);
+                    }
+                    return [4 /*yield*/, query
+                            .clone()
+                            .offset(params.range.offset)
+                            .limit(params.range.limit)
+                            .orderBy(sorter)];
+                case 1:
+                    data = _a.sent();
+                    debug("Data fetched:", data.length, "rows");
+                    return [4 /*yield*/, query
+                            .clone()
+                            .clearSelect()
+                            .count("* AS T")];
+                case 2:
+                    totalRow = _a.sent();
+                    total = totalRow && totalRow.length ? totalRow[0].T : 0;
+                    debug("Total rows:", total);
+                    return [2 /*return*/, __assign({ total: total, data: data }, (sql ? { sql: sql } : {}))];
+            }
+        });
+    }); };
+}

package/build/list.test.js

@@ -0,0 +1,119 @@
+"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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var list_1 = require("./list");
+var knex_1 = __importDefault(require("knex"));
+var knex;
+beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                knex = (0, knex_1.default)({
+                    client: "sqlite3",
+                    connection: {
+                        filename: ":memory:",
+                    },
+                    useNullAsDefault: true,
+                });
+                return [4 /*yield*/, knex.schema.createTable("users", function (table) {
+                        table.increments();
+                        table.string("name");
+                        table.string("last_name");
+                        table.integer("age");
+                        table.string("tool");
+                    })];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, knex("users").insert([
+                        { name: "Peter", last_name: "Parker", age: 11, tool: "ruler" },
+                        { name: "Mark", last_name: "Olivier", age: 18, tool: "pencil" },
+                        { name: "Andre", last_name: "Hudson", age: 18, tool: "pen" },
+                        { name: "Tony", last_name: "Oliver", age: 18, tool: "pen" },
+                        { name: "Bruce", last_name: "Pedersen", age: 13, tool: "crayon" },
+                    ])];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+afterAll(function () {
+    // The test uses an in-memory SQLite database (:memory:), so /tmp/test.sqlite is never created. Remove or update this cleanup to match the actual test database.
+    // unlink('/tmp/test.sqlite', () => {});
+});
+test("KnexQueryList", function () { return __awaiter(void 0, void 0, void 0, function () {
+    var func, result, r, debug;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                func = (0, list_1.KnexQueryList)(knex, "users", ['name', 'lastname'], ['age', 'tool'], ['age']);
+                return [4 /*yield*/, func({
+                        resource: "users",
+                        range: { offset: 0, limit: 10 },
+                        sort: [{ field: "age", direction: "ASC" }],
+                        filter: [
+                            { field: "_search", op: "=", value: "Pe" },
+                            { field: "age", op: "between", value: [8, 17] },
+                            { field: "tool", op: "!in", value: ["pencil", "pen"] },
+                        ],
+                    })];
+            case 1:
+                result = _a.sent();
+                expect(result.total).toBe(2);
+                expect(result.data[0]).toMatchObject({
+                    name: "Peter",
+                    last_name: "Parker",
+                    age: 11,
+                    tool: "ruler",
+                });
+                expect(result.data[1]).toMatchObject({
+                    name: "Bruce",
+                    last_name: "Pedersen",
+                    age: 13,
+                    tool: "crayon",
+                });
+                r = result;
+                debug = r.debug;
+                expect(debug).toBe("select * from `users` where ((`name` like '%Pe%' or `last_name` like '%Pe%') and `age` between 8 and 17 and `tool` not in ('pencil', 'pen')) order by `age` ASC limit 10");
+                return [2 /*return*/];
+        }
+    });
+}); });

package/package.json

@@ -1,50 +1,56 @@
 {
   "name": "@juadz/knex",
-  "version": "0.3.1",
-  "description": "Use Knex as datalayer's for Juadz.",
-  "main": "build/src/index.js",
+  "version": "0.5.0",
+  "description": "Juadz: Rapid restful API development",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "engines": {
+    "node": ">=12.0.0"
+  },
   "scripts": {
+    "build": "tsc",
     "test": "jest .",
-    "lint": "gts lint",
-    "clean": "gts clean",
+    "lint": "eslint . --ext .ts",
     "compile": "tsc",
-    "fix": "gts fix",
+    "fix": "eslint . --ext .ts --fix",
     "prepare": "yarn run compile",
     "pretest": "yarn run compile",
     "posttest": "yarn run lint"
   },
-  "author": "Supasak Sutha",
-  "license": "MIT",
+  "author": "hereblur",
   "repository": {
     "type": "git",
-    "url": "https://github.com/hereblur/juadz-knex"
-  },
-  "files": [
-    "build/**/*"
-  ],
-  "peerDependencies": {
-    "@juadz/core": "^0.1.2",
-    "ajv": "^8.11.0",
-    "knex": "^2.2.0"
+    "url": "github.com/hereblur/juadz-core.git"
   },
+  "license": "MIT",
   "devDependencies": {
-    "@babel/core": "^7.18.10",
-    "@babel/preset-env": "^7.18.10",
-    "@babel/preset-typescript": "^7.18.6",
-    "@types/jest": "^28.1.6",
-    "@types/jsonwebtoken": "^8.5.9",
-    "@types/memory-cache": "^0.2.2",
-    "@types/node": "^18.6.4",
-    "@types/rimraf": "^3.0.2",
-    "babel-jest": "^28.1.3",
-    "gts": "^3.1.0",
-    "jest": "^28.1.3",
-    "knex": "^2.2.0",
-    "redis": "^4.2.0",
-    "sqlite3": "^5.0.11",
-    "typescript": "^4.7.4"
+    "@babel/core": "^7.26.7",
+    "@babel/preset-env": "^7.26.7",
+    "@babel/preset-typescript": "^7.26.0",
+    "@types/debug": "^4.1.12",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.7.5",
+    "@typescript-eslint/eslint-plugin": "^8.36.0",
+    "@typescript-eslint/parser": "^8.36.0",
+    "dayjs": "^1.11.13",
+    "debug": "^4.4.0",
+    "eslint": "^9.30.1",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.5.1",
+    "jest": "^29.7.0",
+    "knex": "^3.1.0",
+    "mysql2": "^3.14.1",
+    "prettier": "^3.6.2",
+    "sqlite": "^5.1.1",
+    "tsc": "^2.0.4",
+    "typescript": "^5.6.3",
+    "zod": "^4",
+    "@juadz/core": "^0.5.0"
+  },
+  "peerDependencies": {
+    "debug": "^4.4.0",
+    "zod": "^4",
+    "@juadz/core": "^0.5.0"
   },
-  "dependencies": {
-    "@juadz/core": "^0.3.0"
-  }
+  "dependencies": {}
 }