chore: bump version to 1.0.15 in package.json and improve code formatting in tests and repository methods

Author: kingRayhan

__tests__/repository/find.test.ts

@@ -13,9 +13,14 @@ import {
   neq,
   notInArray,
   regexp,
-  Repository,
+  Repository
 } from "../../src";
-import {cleanupTestData, DomainUser, executor, setupTestTables,} from "../../test-setup";
+import {
+  cleanupTestData,
+  DomainUser,
+  executor,
+  setupTestTables
+} from "../../test-setup";
 
 describe("Repository findRows", () => {
   let repository: Repository<DomainUser>;
@@ -32,128 +37,128 @@ describe("Repository findRows", () => {
   describe("Comparison Operators", () => {
     it("should find rows with neq operator", async () => {
       const result = await repository.find({
-        where: neq("email", "test-not-exists@example.com"),
+        where: neq("email", "test-not-exists@example.com")
       });
 
       expect(result.every((user) => user.email !== "test@example.com")).toBe(
-        true,
+        true
       );
     });
 
     it("should find rows with gt operator", async () => {
       const result = await repository.find({
-        where: gt("age", 30),
+        where: gt("age", 30)
       });
 
       expect(result.every((user) => user.age! > 30)).toBe(true);
     });
 
     it("should find rows with gte operator", async () => {
       const result = await repository.find({
-        where: gte("age", 30),
+        where: gte("age", 30)
       });
 
       expect(result.every((user) => user.age! >= 30)).toBe(true);
     });
 
     it("should find rows with lt operator", async () => {
       const result = await repository.find({
-        where: lt("age", 40),
+        where: lt("age", 40)
       });
 
       expect(result.every((user) => user.age! < 40)).toBe(true);
     });
 
     it("should find rows with lte operator", async () => {
       const result = await repository.find({
-        where: lte("age", 40),
+        where: lte("age", 40)
       });
 
       expect(result.every((user) => user.age! <= 40)).toBe(true);
     });
 
     it("should find rows with like operator", async () => {
       const result = await repository.find({
-        where: like("name", "%john%"),
+        where: like("name", "%john%")
       });
 
       expect(
-        result.every((user) => user.name.toLowerCase().includes("john")),
+        result.every((user) => user.name.toLowerCase().includes("john"))
       ).toBe(true);
     });
 
     it("should find rows with ilike operator", async () => {
       const result = await repository.find({
-        where: ilike("name", "%JOHN%"),
+        where: ilike("name", "%JOHN%")
       });
 
       expect(
-        result.every((user) => user.name.toLowerCase().includes("john")),
+        result.every((user) => user.name.toLowerCase().includes("john"))
       ).toBe(true);
     });
 
     it("should find rows with inArray operator", async () => {
       const result = await repository.find({
-        where: inArray("email", ["test1@example.com", "test2@example.com"]),
+        where: inArray("email", ["test1@example.com", "test2@example.com"])
       });
 
       expect(
         result.every((user) =>
-          ["test1@example.com", "test2@example.com"].includes(user.email),
-        ),
+          ["test1@example.com", "test2@example.com"].includes(user.email)
+        )
       ).toBe(true);
     });
 
     it("should find rows with notInArray operator", async () => {
       const result = await repository.find({
-        where: notInArray("email", ["test1@example.com", "test2@example.com"]),
+        where: notInArray("email", ["test1@example.com", "test2@example.com"])
       });
 
       expect(
         result.every(
           (user) =>
-            !["test1@example.com", "test2@example.com"].includes(user.email),
-        ),
+            !["test1@example.com", "test2@example.com"].includes(user.email)
+        )
       ).toBe(true);
     });
 
     it("should find rows with isNull operator", async () => {
       const result = await repository.find({
-        where: isNull("bio"),
+        where: isNull("bio")
       });
 
       expect(result.every((user) => user.bio === null)).toBe(true);
     });
 
     it("should find rows with isNotNull operator", async () => {
       const result = await repository.find({
-        where: isNotNull("bio"),
+        where: isNotNull("bio")
       });
 
       expect(result.every((user) => user.bio !== null)).toBe(true);
     });
 
     it("should find rows with between operator", async () => {
       const result = await repository.find({
-        where: between("age", 25, 35),
+        where: between("age", 25, 35)
       });
 
       expect(result.every((user) => user.age! >= 25 && user.age! <= 35)).toBe(
-        true,
+        true
       );
     });
 
     it("should find rows with regexp operator", async () => {
       const result = await repository.find({
-        where: regexp("name", "^[A-Z]"),
+        where: regexp("name", "^[A-Z]")
       });
 
       expect(result.every((user) => /^[A-Z]/.test(user.name))).toBe(true);
     });
 
     it("should find rows with iregexp operator", async () => {
       const result = await repository.find({
-        where: iregexp("name", "^[a-z]"),
+        where: iregexp("name", "^[a-z]")
       });
 
       expect(result.every((user) => /^[a-z]/i.test(user.name))).toBe(true);

__tests__/repository/insert.test.ts

@@ -2,11 +2,11 @@ import {
   setupTestTables,
   cleanupTestData,
   executor,
-  DomainUser,
+  DomainUser
 } from "../../test-setup";
 import { Repository } from "../../src";
 
-describe("Repository - insertMany", () => {
+describe("Repository - insert", () => {
   let repository: Repository<DomainUser>;
 
   beforeAll(async () => {
@@ -21,7 +21,7 @@ describe("Repository - insertMany", () => {
   it("should insert multiple records into the database", async () => {
     const records = [
       { name: "John Doe", email: "john@example.com", age: 30 },
-      { name: "Jane Smith", email: "jane@example.com", age: 25 },
+      { name: "Jane Smith", email: "jane@example.com", age: 25 }
     ];
     const result = await repository.insert(records);
 
@@ -31,25 +31,24 @@ describe("Repository - insertMany", () => {
 
     const insertedRecords = await executor.executeSQL(
       "SELECT * FROM users WHERE email IN ($1, $2)",
-      ["john@example.com", "jane@example.com"],
+      ["john@example.com", "jane@example.com"]
     );
 
     expect(insertedRecords.rows).toHaveLength(2);
     expect(insertedRecords.rows).toEqual(
       expect.arrayContaining([
         expect.objectContaining(records[0]),
-        expect.objectContaining(records[1]),
-      ]),
+        expect.objectContaining(records[1])
+      ])
     );
   });
 
   it("should throw an error if one of the records violates constraints", async () => {
-    const records: DomainUser[] | {[key:string]: any} = [
+    const records: DomainUser[] | { [key: string]: any } = [
       { name: "Valid User", email: "valid@example.com", age: 40 },
-      { name: null, email: "invalid@example.com" }, // Assuming 'name' cannot be null
+      { name: null, email: "invalid@example.com" } // Assuming 'name' cannot be null
     ];
 
-    
     await expect(repository.insert(records as any)).rejects.toThrow();
   });
 });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlkit",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "A lightweight SQL builder for TypeScript",
   "license": "MIT",
   "author": {

src/repository/repository.ts

@@ -42,7 +42,7 @@ export class Repository<T> {
         sql: builder.build().sql,
         values: builder.build().values,
         result: {
-          rows: result.rows,
+          rows: JSON.stringify(result.rows, null, 2),
           rowCount: result.rowCount
         }
       });
@@ -93,7 +93,7 @@ export class Repository<T> {
         sql: builder.build().sql,
         values: builder.build().values,
         result: {
-          rows: result.rows,
+          rows: JSON.stringify(result.rows, null, 2),
           rowCount: result.rowCount
         }
       });
@@ -120,7 +120,7 @@ export class Repository<T> {
         sql: builder.build().sql,
         values: builder.build().values,
         result: {
-          rows: result.rows,
+          rows: JSON.stringify(result.rows, null, 2),
           rowCount: result.rowCount
         }
       });
@@ -143,7 +143,7 @@ export class Repository<T> {
         sql: builder.build().sql,
         values: builder.build().values,
         result: {
-          rows: result.rows,
+          rows: JSON.stringify(result.rows, null, 2),
           rowCount: result.rowCount
         }
       });