@zuzjs/orm 0.2.2 → 0.2.4

package/dist/drivers/queryBuilder.d.ts

@@ -1,7 +1,7 @@
 import { QueryResult } from "mysql2";
 import { ObjectLiteral, Repository } from "typeorm";
 import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
-import { QueryAction } from "../types";
+import { PartialConditions, QueryAction } from "../types";
 declare class ZormQueryBuilder<T extends ObjectLiteral, R = QueryResult> extends Promise<R> {
     private repository;
     private queryBuilder;
@@ -44,13 +44,13 @@ declare class ZormQueryBuilder<T extends ObjectLiteral, R = QueryResult> extends
      * @param condition - The condition to be added.
      * @returns The current instance of ZormQueryBuilder.
      */
-    where(condition: Partial<Record<keyof T, any>>): this;
+    where(condition: PartialConditions<T>): this;
     /**
      * Adds an OR condition to the query.
      * @param condition - The condition to be added.
      * @returns The current instance of ZormQueryBuilder.
      */
-    or(condition: Partial<Record<keyof T, any>>): this;
+    or(condition: PartialConditions<T>): this;
     /**
      * Adds an ORDER BY clause to the query.
      * @param field - The field to order by.
@@ -118,13 +118,13 @@ declare class ZormQueryBuilder<T extends ObjectLiteral, R = QueryResult> extends
      * @param value - A string or an array of strings to match.
      * @returns The current instance of ZormQueryBuilder.
      */
-    like(field: keyof T, value: string | string[]): this;
+    like(conditions: Partial<Record<keyof T, string | string[]>>): this;
     /**
      * Adds a DISTINCT clause to the query.
      * @returns The current instance of ZormQueryBuilder.
      */
     distinct(): this;
-    count(): Promise<number>;
+    count(field?: keyof T): Promise<number>;
     sum(field: keyof T): Promise<number>;
     avg(field: keyof T): Promise<number>;
     min(field: keyof T): Promise<number>;

package/dist/drivers/queryBuilder.js

@@ -111,6 +111,7 @@ class ZormQueryBuilder extends Promise {
     applyCondition(qb, condition, type) {
         Object.entries(condition).forEach(([key, value], index) => {
             const paramKey = `${key}Param${index}_${this.whereCount}`; // Unique parameter name
+            let sqlOperator = "="; // Default to "="
             if (typeof value === "string") {
                 const match = value.match(/^(!=|>=|<=|>|<|=)\s*(.+)$/); // Improved regex
                 if (match) {
@@ -121,6 +122,24 @@ class ZormQueryBuilder extends Promise {
                     return;
                 }
             }
+            else if (typeof value === "object" && value !== null) {
+                // Support object-based conditions: { age: { gt: 18, lt: 20 } }
+                const operators = {
+                    gt: ">",
+                    gte: ">=",
+                    lt: "<",
+                    lte: "<=",
+                    ne: "!=",
+                    eq: "="
+                };
+                Object.entries(value).forEach(([opKey, opValue]) => {
+                    if (operators[opKey]) {
+                        const paramKey = `${key}Param_${opKey}_${this.whereCount++}`; // Unique param key
+                        qb[type](`${qb.alias}.${key} ${operators[opKey]} :${paramKey}`, { [paramKey]: opValue });
+                    }
+                });
+                return; // Prevent default equality case for objects
+            }
             // Default case (normal equality condition)
             qb[type](`${this.entityAlias}.${key} = :${paramKey}`, { [paramKey]: value });
             this.whereCount++;
@@ -251,20 +270,26 @@ class ZormQueryBuilder extends Promise {
      * @param value - A string or an array of strings to match.
      * @returns The current instance of ZormQueryBuilder.
      */
-    like(field, value) {
-        if (!value || (Array.isArray(value) && value.length === 0))
+    like(conditions) {
+        if (!conditions || Object.keys(conditions).length === 0)
             return this;
         const qb = this.queryBuilder;
-        const conditions = [];
-        const params = {}; // Ensure this is always an object
-        const values = Array.isArray(value) ? value : [value];
-        values.forEach((val, index) => {
-            const paramKey = `${String(field)}LikeParam${index}_${this.whereCount}`;
-            conditions.push(`${this.entityAlias}.${String(field)} LIKE :${paramKey}`);
-            params[paramKey] = val; // Directly use the value, allowing custom `%xyz%` patterns
+        const orConditions = [];
+        const params = {};
+        Object.entries(conditions).forEach(([field, value]) => {
+            const values = Array.isArray(value) ? value : [value];
+            const fieldConditions = [];
+            values.forEach((val, index) => {
+                const paramKey = `${field}LikeParam${index}_${this.whereCount}`;
+                fieldConditions.push(`${this.entityAlias}.${String(field)} LIKE :${paramKey}`);
+                params[paramKey] = val; // Directly use the value (supports %xyz% pattern)
+            });
+            if (fieldConditions.length > 0) {
+                orConditions.push(`(${fieldConditions.join(" OR ")})`);
+            }
         });
-        if (conditions.length > 0) {
-            qb.andWhere(`(${conditions.join(" OR ")})`, params);
+        if (orConditions.length > 0) {
+            qb.andWhere(`(${orConditions.join(" OR ")})`, params);
             this.whereCount++;
         }
         return this;
@@ -277,7 +302,10 @@ class ZormQueryBuilder extends Promise {
         this.queryBuilder.distinct(true);
         return this;
     }
-    async count() {
+    async count(field) {
+        if (field) {
+            this.queryBuilder.select(`COUNT(${field})`);
+        }
         return await this.queryBuilder.getCount();
     }
     async sum(field) {

package/dist/types.d.ts

@@ -17,6 +17,58 @@ export type ConnectionDetails = {
 };
 export type QueryAction = "create" | "upsert" | "select" | "update" | "delete";
 export type QueryResult = InsertQueryResult | SelectQueryResult | UpdateQueryResult | DeleteQueryResult;
+/**
+ * Defines supported comparison operators for filtering queries.
+ * Enables IntelliSense support in `.where()` conditions.
+ *
+ * @template T The type of the value being compared (e.g., number, string, Date).
+ */
+export type WhereOperators<T> = {
+    /**
+     * Greater than (`>`) operator.
+     *
+     * @example
+     * query.where({ age: { gt: 18 } }) // WHERE age > 18
+     */
+    gt?: T;
+    /**
+     * Greater than or equal to (`>=`) operator.
+     *
+     * @example
+     * query.where({ price: { gte: 100 } }) // WHERE price >= 100
+     */
+    gte?: T;
+    /**
+     * Less than (`<`) operator.
+     *
+     * @example
+     * query.where({ age: { lt: 30 } }) // WHERE age < 30
+     */
+    lt?: T;
+    /**
+     * Less than or equal to (`<=`) operator.
+     *
+     * @example
+     * query.where({ date: { lte: '2024-01-01' } }) // WHERE date <= '2024-01-01'
+     */
+    lte?: T;
+    /**
+     * Not equal (`!=`) operator.
+     *
+     * @example
+     * query.where({ status: { ne: 'inactive' } }) // WHERE status != 'inactive'
+     */
+    ne?: T;
+    /**
+     * Equal (`=`) operator.
+     * This is typically unnecessary since `.where({ key: value })` already handles equality.
+     *
+     * @example
+     * query.where({ id: { eq: 1 } }) // WHERE id = 1
+     */
+    eq?: T;
+};
+export type PartialConditions<T> = Partial<Record<keyof T, string | number | boolean | WhereOperators<any>>>;
 export type QueryError = {
     code: number | string;
     message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zuzjs/orm",
-    "version": "0.2.2",
+    "version": "0.2.4",
     "keywords": [
         "orm",
         "zuz",