@juadz/knex 0.5.1 → 0.5.2

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

@@ -57,24 +57,20 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KnexProvider = KnexProvider;
+var core_1 = require("@juadz/core");
 var list_1 = require("./list");
-function KnexProvider(schema, connection, dataTableName) {
+function KnexProvider(dataTableName, schema, connection) {
     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]; });
+    // schema.name = schema.name || dataTableName;
+    var flags = (0, core_1.flagPaths)(schema);
+    var searchableFields = flags.$search || [];
+    var filterableFields = flags.$filter || [];
+    var sortableFields = flags.$sort || [];
     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)
+                case 0: return [4 /*yield*/, connection(dataTableName)
                         .select("*")
                         .where("id", id)
                         .first()];
@@ -87,7 +83,7 @@ function KnexProvider(schema, connection, dataTableName) {
     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 0: return [4 /*yield*/, connection(dataTableName).where("id", id).update(patch)];
                 case 1:
                     _a.sent();
                     return [4 /*yield*/, get(id)];
@@ -102,14 +98,14 @@ function KnexProvider(schema, connection, dataTableName) {
                 case 0:
                     params = __assign({}, params_);
                     if (!(connection.client.config.client === "sqlite3")) return [3 /*break*/, 2];
-                    return [4 /*yield*/, connection(tableName)
+                    return [4 /*yield*/, connection(dataTableName)
                             .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)
+                case 2: return [4 /*yield*/, connection(dataTableName)
                         .returning("id")
                         .insert(__assign({}, params))];
                 case 3:
@@ -135,7 +131,7 @@ function KnexProvider(schema, connection, dataTableName) {
                         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), [
+                    return [4 /*yield*/, connection.raw("REPLACE INTO `".concat(dataTableName, "` 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:
@@ -151,16 +147,17 @@ function KnexProvider(schema, connection, dataTableName) {
         var result;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, connection(tableName).where("id", id).delete()];
+                case 0: return [4 /*yield*/, connection(dataTableName).where("id", id).delete()];
                 case 1:
                     result = _a.sent();
                     return [2 /*return*/, result];
             }
         });
     }); };
-    var list = (0, list_1.KnexQueryList)(connection, tableName, searchableFields, filterableFields, sortableFields);
+    var list = (0, list_1.KnexQueryList)(connection, dataTableName, searchableFields, filterableFields, sortableFields);
     return {
         schema: schema,
+        name: dataTableName,
         get: get,
         replace: replace,
         update: update,

package/build/list.js

@@ -51,7 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KnexQueryList = KnexQueryList;
-var dayjs_1 = __importDefault(require("dayjs"));
+// import dayjs from "dayjs";
 var debug_1 = __importDefault(require("debug"));
 var debug = (0, debug_1.default)("juadz:knex:list");
 function KnexQueryList(knex, tableName, searchableFields, filterableFields, sortableFields) {
@@ -111,18 +111,22 @@ function KnexQueryList(knex, tableName, searchableFields, filterableFields, sort
                                         ]);
                                         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],
-                                            ]);
-                                        }
+                                        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, [

package/build/list.test.js

@@ -84,7 +84,7 @@ test("KnexQueryList", function () { return __awaiter(void 0, void 0, void 0, fun
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                func = (0, list_1.KnexQueryList)(knex, "users", ["name", "lastname"], ["age", "tool"], ["age"]);
+                func = (0, list_1.KnexQueryList)(knex, "users", ["name", "last_name"], ["age", "tool"], ["age"]);
                 return [4 /*yield*/, func({
                         resource: "users",
                         range: { offset: 0, limit: 10 },
@@ -97,6 +97,9 @@ test("KnexQueryList", function () { return __awaiter(void 0, void 0, void 0, fun
                     })];
             case 1:
                 result = _a.sent();
+                r = result;
+                debug = r.sql;
+                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",
@@ -110,8 +113,6 @@ test("KnexQueryList", function () { return __awaiter(void 0, void 0, void 0, fun
                     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,6 +1,6 @@
 {
   "name": "@juadz/knex",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Juadz: Rapid restful API development",
   "main": "build/index.js",
   "types": "build/index.d.ts",

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");
@@ -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":