@juadz/knex 0.5.1 → 0.5.4-beta2

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+yarn run v1.22.22
+$ tsc
+Done in 3.38s.

package/build/basic.d.ts

@@ -1,3 +1,4 @@
-import { IDataRecord, IDataRepositoryProvider, Schema } from "@juadz/core";
+import { IDataRecord, IDataRepositoryProvider } from "@juadz/core";
 import { Knex } from "knex";
-export declare function KnexProvider<T extends IDataRecord>(schema: Schema<T>, connection: Knex, dataTableName?: string): IDataRepositoryProvider<T>;
+import { output, ZodObject, ZodRawShape } from "zod";
+export declare function KnexProvider<Shape extends ZodRawShape, Schema extends ZodObject<Shape>, T extends IDataRecord = output<Schema> & IDataRecord>(dataTableName: string, schema: Schema, connection: Knex): IDataRepositoryProvider<T>;

package/build/basic.js

@@ -1,171 +1,82 @@
 "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(schema, connection, dataTableName) {
-    var _this = this;
-    var tableName = dataTableName || schema.name;
-    var searchableFields = Object.entries(schema.flags)
-        .filter(function (v) { return v[1].$search == true; })
-        .map(function (k) { return k[0]; });
-    var filterableFields = Object.entries(schema.flags)
-        .filter(function (v) { return v[1].$filter == true; })
-        .map(function (k) { return k[0]; });
-    var sortableFields = Object.entries(schema.flags)
-        .filter(function (v) { return v[1].$sort == true; })
-        .map(function (k) { return k[0]; });
-    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];
-            }
+const core_1 = require("@juadz/core");
+const list_1 = require("./list");
+function KnexProvider(dataTableName, schema, connection) {
+    // schema.name = schema.name || dataTableName;
+    const flags = (0, core_1.flagPaths)(schema);
+    const searchableFields = flags.$search || [];
+    const filterableFields = flags.$filter || [];
+    const sortableFields = flags.$sort || [];
+    const get = async (id) => {
+        const c = await connection(dataTableName)
+            .select("*")
+            .where("id", id)
+            .first();
+        return c;
+    };
+    const update = async (id, patch) => {
+        await connection(dataTableName).where("id", id).update(patch);
+        return await get(id);
+    };
+    const create = async (params_) => {
+        const params = {
+            ...params_,
+        };
+        let insertedId;
+        if (connection.client.config.client === "sqlite3") {
+            // SQLite does not support `.returning('id')`
+            const inserted = await connection(dataTableName)
+                .returning("id")
+                .insert({
+                ...params,
+            });
+            insertedId = inserted[0].id;
+        }
+        else {
+            // For other SQL clients that support `.returning('id')`
+            const inserted = await connection(dataTableName)
+                .returning("id")
+                .insert({
+                ...params,
+            });
+            insertedId = inserted[0];
+        }
+        const insertedData = await get(insertedId);
+        return insertedData;
+    };
+    const replace = async (id, params_) => {
+        const params = {
+            id,
+            ...params_,
+        };
+        const fields = [];
+        const values = [];
+        Object.keys(params).forEach((f) => {
+            fields.push(`\`${f}\`=?`);
+            values.push(params[f]);
         });
-    }); };
-    var list = (0, list_1.KnexQueryList)(connection, tableName, searchableFields, filterableFields, sortableFields);
+        await connection.raw(`REPLACE INTO \`${dataTableName}\` SET ${fields.join(", ")} WHERE id=?`, [
+            ...values,
+            id, // Ensure the ID is at the end for the WHERE clause
+        ]);
+        const insertedData = await get(id);
+        return insertedData;
+    };
+    const delete_ = async (id) => {
+        const result = await connection(dataTableName).where("id", id).delete();
+        return result;
+    };
+    const list = (0, list_1.KnexQueryList)(connection, dataTableName, searchableFields, filterableFields, sortableFields);
     return {
-        schema: schema,
-        get: get,
-        replace: replace,
-        update: update,
-        create: create,
+        schema,
+        name: dataTableName,
+        get,
+        replace,
+        update,
+        create,
         delete: delete_,
-        list: list,
+        list,
     };
 }

package/build/index.js

@@ -14,6 +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 });
-var basic_1 = require("./basic");
+const basic_1 = require("./basic");
 exports.default = basic_1.KnexProvider;
 __exportStar(require("./list"), exports);

package/build/list.js

@@ -1,188 +1,138 @@
 "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");
+// import dayjs from "dayjs";
+const debug_1 = __importDefault(require("debug"));
+const 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;
-                                }
+    return async (params) => {
+        const query = knex(tableName);
+        if (params.filter.length > 0) {
+            debug("Applying filters:", params.filter);
+            query.where((query) => {
+                params.filter.forEach((f) => {
+                    const { field, op, value } = f;
+                    if (field === "_search" && (op === "=" || op === "contains")) {
+                        query.andWhere((query) => {
+                            (searchableFields || []).forEach((k) => {
+                                query.orWhere(k, "LIKE", `%${`${value}`.replace(/(["'$%]+)/g, "")}%`);
                             });
                         });
+                        return;
                     }
-                    else {
-                        debug("No filters applied");
+                    if (!filterableFields.includes(field)) {
+                        debug(`Field "${field}" is not filterable`);
+                        return;
                     }
-                    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);
+                    let values = [];
+                    if (Array.isArray(value)) {
+                        values = value;
                     }
-                    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 } : {}))];
+                    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, `%${value}%`);
+                            return;
+                        case "!contains":
+                            query.whereRaw(`\`${field}\` NOT LIKE ?`, [
+                                `%${value}%`,
+                            ]);
+                            return;
+                        case "between":
+                            query.whereBetween(field, [values[0], values[1]]);
+                            //if (query.client.config.client === "sqlite3") {
+                            //    query.whereBetween(field, [
+                            //        dayjs(values[0]).format(
+                            //            "YYYY-MM-DD HH:mm:ss",
+                            //        ),
+                            //        dayjs(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");
+        }
+        let sql = null;
+        const sorter = params.sort
+            .filter((s) => {
+            const pass = sortableFields.includes(s.field);
+            if (!pass) {
+                debug(`Field "${s.field}" is not sortable`);
             }
-        });
-    }); };
+            return pass;
+        })
+            .map((s) => ({
+            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);
+        }
+        const data = await query
+            .clone()
+            .offset(params.range.offset)
+            .limit(params.range.limit)
+            .orderBy(sorter);
+        debug("Data fetched:", data.length, "rows");
+        const totalRow = await query
+            .clone()
+            .clearSelect()
+            .count("* AS T");
+        const total = totalRow && totalRow.length ? totalRow[0].T : 0;
+        debug("Total rows:", total);
+        return {
+            total,
+            data,
+            ...(sql ? { sql } : {}),
+        };
+    };
 }

package/build/list.test.js

@@ -1,119 +1,65 @@
 "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*/];
-        }
+const list_1 = require("./list");
+const knex_1 = __importDefault(require("knex"));
+let knex;
+beforeAll(async () => {
+    knex = (0, knex_1.default)({
+        client: "sqlite3",
+        connection: {
+            filename: ":memory:",
+        },
+        useNullAsDefault: true,
+    });
+    await knex.schema.createTable("users", (table) => {
+        table.increments();
+        table.string("name");
+        table.string("last_name");
+        table.integer("age");
+        table.string("tool");
     });
-}); });
-afterAll(function () {
+    await 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" },
+    ]);
+});
+afterAll(() => {
     // 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*/];
-        }
+test("KnexQueryList", async () => {
+    const func = (0, list_1.KnexQueryList)(knex, "users", ["name", "last_name"], ["age", "tool"], ["age"]);
+    const result = await 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"] },
+        ],
+    });
+    const r = result;
+    const { sql: debug } = r;
+    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");
+    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",
+    });
+    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");
+});

package/build/types.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juadz/knex",
-  "version": "0.5.1",
+  "version": "0.5.4-beta2",
   "description": "Juadz: Rapid restful API development",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -20,7 +20,7 @@
   "author": "hereblur",
   "repository": {
     "type": "git",
-    "url": "github.com/hereblur/juadz-core.git"
+    "url": "github.com/hereblur/juadz.git"
   },
   "license": "MIT",
   "devDependencies": {
@@ -48,7 +48,7 @@
     "zod": "^4"
   },
   "peerDependencies": {
-    "@juadz/core": "^0.5.0",
+    "@juadz/core": "0.5.4-beta2",
     "debug": "^4.4.0",
     "zod": "^4"
   },

package/src/basic.ts

@@ -1,26 +1,26 @@
-import { IDataRecord, IDataRepositoryProvider, Schema } from "@juadz/core";
+import { flagPaths, IDataRecord, IDataRepositoryProvider } from "@juadz/core";
 import { Knex } from "knex";
 import { KnexQueryList } from "./list";
-
-export function KnexProvider<T extends IDataRecord>(
-    schema: Schema<T>,
+import { output, ZodObject, ZodRawShape } from "zod";
+
+export function KnexProvider<
+    Shape extends ZodRawShape,
+    Schema extends ZodObject<Shape>,
+    T extends IDataRecord = output<Schema> & IDataRecord,
+>(
+    dataTableName: string,
+    schema: Schema,
     connection: Knex,
-    dataTableName?: string,
 ): IDataRepositoryProvider<T> {
-    const tableName = dataTableName || schema.name;
-
-    const searchableFields = Object.entries(schema.flags)
-        .filter((v) => v[1].$search == true)
-        .map((k) => k[0]);
-    const filterableFields = Object.entries(schema.flags)
-        .filter((v) => v[1].$filter == true)
-        .map((k) => k[0]);
-    const sortableFields = Object.entries(schema.flags)
-        .filter((v) => v[1].$sort == true)
-        .map((k) => k[0]);
+    // schema.name = schema.name || dataTableName;
+    const flags = flagPaths(schema);
+
+    const searchableFields = flags.$search || [];
+    const filterableFields = flags.$filter || [];
+    const sortableFields = flags.$sort || [];
 
     const get = async (id: string | number) => {
-        const c = await connection(tableName)
+        const c = await connection(dataTableName)
             .select("*")
             .where("id", id)
             .first();
@@ -29,7 +29,7 @@ export function KnexProvider<T extends IDataRecord>(
     };
 
     const update = async (id: string | number, patch: object) => {
-        await connection(tableName).where("id", id).update(patch);
+        await connection(dataTableName).where("id", id).update(patch);
 
         return await get(id);
     };
@@ -43,7 +43,7 @@ export function KnexProvider<T extends IDataRecord>(
 
         if (connection.client.config.client === "sqlite3") {
             // SQLite does not support `.returning('id')`
-            const inserted = await connection(tableName)
+            const inserted = await connection(dataTableName)
                 .returning("id")
                 .insert({
                     ...params,
@@ -52,7 +52,7 @@ export function KnexProvider<T extends IDataRecord>(
             insertedId = (inserted[0] as unknown as { id: string | number }).id;
         } else {
             // For other SQL clients that support `.returning('id')`
-            const inserted = await connection(tableName)
+            const inserted = await connection(dataTableName)
                 .returning("id")
                 .insert({
                     ...params,
@@ -79,7 +79,7 @@ export function KnexProvider<T extends IDataRecord>(
         });
 
         await connection.raw(
-            `REPLACE INTO \`${tableName}\` SET ${fields.join(", ")} WHERE id=?`,
+            `REPLACE INTO \`${dataTableName}\` SET ${fields.join(", ")} WHERE id=?`,
             [
                 ...values,
                 id, // Ensure the ID is at the end for the WHERE clause
@@ -92,14 +92,14 @@ export function KnexProvider<T extends IDataRecord>(
     };
 
     const delete_ = async (id: string | number) => {
-        const result = await connection(tableName).where("id", id).delete();
+        const result = await connection(dataTableName).where("id", id).delete();
 
         return result;
     };
 
     const list = KnexQueryList(
         connection,
-        tableName,
+        dataTableName,
         searchableFields,
         filterableFields,
         sortableFields,
@@ -107,6 +107,8 @@ export function KnexProvider<T extends IDataRecord>(
 
     return {
         schema,
+        name: dataTableName,
+
         get,
         replace,
         update,

package/src/list.test.ts

@@ -42,7 +42,7 @@ test("KnexQueryList", async () => {
     const func = KnexQueryList(
         knex,
         "users",
-        ["name", "lastname"],
+        ["name", "last_name"],
         ["age", "tool"],
         ["age"],
     );
@@ -57,6 +57,12 @@ test("KnexQueryList", async () => {
             { field: "tool", op: "!in", value: ["pencil", "pen"] },
         ],
     });
+    const r = result as unknown;
+    const { sql: debug } = r as DebugObj;
+
+    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",
+    );
 
     expect(result.total).toBe(2);
     expect(result.data[0]).toMatchObject({
@@ -72,13 +78,11 @@ test("KnexQueryList", async () => {
         tool: "crayon",
     });
 
-    const r = result as unknown;
-    const { debug } = r as DebugObj;
     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",
     );
 });
 
 interface DebugObj {
-    debug: string;
+    sql: string;
 }

package/src/list.ts

@@ -1,7 +1,7 @@
 import { QueryListParam, QueryFilter, QueryListFunction } from "@juadz/core";
 
 import { Knex } from "knex";
-import dayjs from "dayjs";
+// import dayjs from "dayjs";
 import Debug from "debug";
 
 const debug = Debug("juadz:knex:list");
@@ -29,7 +29,7 @@ export function KnexQueryList<T>(
             query.where((query: Knex) => {
                 params.filter.forEach((f: QueryFilter) => {
                     const { field, op, value } = f;
-                    if (field === "_search" && op === "=") {
+                    if (field === "_search" && (op === "=" || op === "contains")) {
                         query.andWhere((query: Knex) => {
                             (searchableFields || []).forEach((k) => {
                                 query.orWhere(
@@ -80,21 +80,22 @@ export function KnexQueryList<T>(
                             ]);
                             return;
                         case "between":
-                            if (query.client.config.client === "sqlite3") {
-                                query.whereBetween(field, [
-                                    dayjs(values[0]).format(
-                                        "YYYY-MM-DD HH:mm:ss",
-                                    ),
-                                    dayjs(values[1]).format(
-                                        "YYYY-MM-DD HH:mm:ss",
-                                    ),
-                                ]);
-                            } else {
-                                query.whereBetween(field, [
-                                    values[0],
-                                    values[1],
-                                ]);
-                            }
+                            query.whereBetween(field, [values[0], values[1]]);
+                            //if (query.client.config.client === "sqlite3") {
+                            //    query.whereBetween(field, [
+                            //        dayjs(values[0]).format(
+                            //            "YYYY-MM-DD HH:mm:ss",
+                            //        ),
+                            //        dayjs(values[1]).format(
+                            //            "YYYY-MM-DD HH:mm:ss",
+                            //        ),
+                            //    ]);
+                            //} else {
+                            //    query.whereBetween(field, [
+                            //        values[0],
+                            //        values[1],
+                            //    ]);
+                            //}
 
                             return;
                         case "!between":

package/tsconfig.json

@@ -3,9 +3,13 @@
   "compilerOptions": {
     "rootDir": "src",
     "outDir": "build",
+    "noEmit": false,
     "declaration": true,
     "declarationDir": "build",
     "emitDeclarationOnly": false,
+    "paths": {
+      "@juadz/core": ["../juadz-core/build/index.d.ts"]
+    }
   },
   "include": [
     "src/**/*"