@zuzjs/orm 0.3.0 → 0.3.1

package/dist/drivers/expressionBuilder.d.ts

@@ -0,0 +1,19 @@
+import { ObjectLiteral } from "typeorm";
+declare class ZormExprBuilder<T extends ObjectLiteral> {
+    private _expression;
+    private _param;
+    private _paramIndex;
+    field(column: keyof T | string): this;
+    fromUnixTime(): this;
+    date(): this;
+    substring(column: keyof T | string, delimiter: string, index: number): this;
+    append(extra: string): this;
+    wrap(wrapper: (expr: string) => string): this;
+    equals(value: string | number | boolean): {
+        expression: string;
+        param: Record<string, any>;
+    };
+    buildExpression(): string;
+    buildParam(): Record<string, any>;
+}
+export default ZormExprBuilder;

package/dist/drivers/expressionBuilder.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ZormExprBuilder {
+    _expression = "";
+    _param = {};
+    _paramIndex = 0;
+    field(column) {
+        this._expression = String(column);
+        return this;
+    }
+    fromUnixTime() {
+        this._expression = `FROM_UNIXTIME(${this._expression})`;
+        return this;
+    }
+    date() {
+        this._expression = `DATE(${this._expression})`;
+        return this;
+    }
+    substring(column, delimiter, index) {
+        this._expression = `SUBSTRING_INDEX(${String(column)}, '${delimiter}', ${index})`;
+        return this;
+    }
+    append(extra) {
+        this._expression = `${this._expression}${extra}`;
+        return this;
+    }
+    wrap(wrapper) {
+        this._expression = wrapper(this._expression);
+        return this;
+    }
+    equals(value) {
+        const paramKey = `param${this._paramIndex++}`;
+        this._param[paramKey] = value;
+        return {
+            expression: `${this._expression} = :${paramKey}`,
+            param: this._param,
+        };
+    }
+    buildExpression() {
+        return this._expression;
+    }
+    buildParam() {
+        return this._param;
+    }
+}
+exports.default = ZormExprBuilder;

package/dist/drivers/queryBuilder.d.ts

@@ -2,6 +2,7 @@ import { QueryResult } from "mysql2";
 import { ObjectLiteral, Repository } from "typeorm";
 import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 import { PartialConditions, QueryAction } from "../types";
+import ZormExprBuilder from "./expressionBuilder";
 declare class ZormQueryBuilder<T extends ObjectLiteral, R = QueryResult> extends Promise<R> {
     private repository;
     private queryBuilder;
@@ -40,6 +41,14 @@ declare class ZormQueryBuilder<T extends ObjectLiteral, R = QueryResult> extends
      */
     select(fields: (keyof T)[]): this;
     private applyCondition;
+    /**
+     * Adds a custom expression-based WHERE clause using a fluent builder.
+     * @param fn - A callback that receives a ZormExprBuilder and returns an expression + param.
+     */
+    expression(exprFn: (q: ZormExprBuilder<T>) => {
+        expression: string;
+        param: Record<string, any>;
+    } | ZormExprBuilder<T>): this;
     /**
      * Adds a WHERE condition to the query.
      * @param condition - The condition to be added.

package/dist/drivers/queryBuilder.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("../core");
+const expressionBuilder_1 = __importDefault(require("./expressionBuilder"));
 const index_js_1 = require("./mysql/index.js");
 class ZormQueryBuilder extends Promise {
     repository;
@@ -171,6 +175,23 @@ class ZormQueryBuilder extends Promise {
             this.whereCount++;
         });
     }
+    /**
+     * Adds a custom expression-based WHERE clause using a fluent builder.
+     * @param fn - A callback that receives a ZormExprBuilder and returns an expression + param.
+     */
+    expression(exprFn) {
+        const qb = this.queryBuilder;
+        const result = exprFn(new expressionBuilder_1.default());
+        if ('expression' in result && 'param' in result) {
+            qb.andWhere(result.expression, result.param);
+        }
+        else {
+            // fallback if only expression was built without .equals()
+            qb.andWhere(result.buildExpression(), result.buildParam());
+        }
+        this.whereCount++;
+        return this;
+    }
     /**
      * Adds a WHERE condition to the query.
      * @param condition - The condition to be added.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zuzjs/orm",
-    "version": "0.3.0",
+    "version": "0.3.1",
     "keywords": [
         "orm",
         "zuz",
@@ -31,21 +31,21 @@
     "sideEffects": ["reflect-metadata"],
     "dependencies": {
         "@types/md5": "^2.3.5",
-        "commander": "^13.1.0",
+        "commander": "14.0.0",
         "md5": "^2.3.0",
-        "mysql2": "^3.12.0",
-        "nanoid": "^5.1.0",
+        "mysql2": "3.14.1",
+        "nanoid": "5.1.5",
         "picocolors": "^1.1.1",
         "reflect-metadata": "^0.2.2",
-        "typeorm": "^0.3.20"
+        "typeorm": "^0.3.25"
     },
     "devDependencies": {
         "husky": "^9.1.7",
         "ts-node": "^10.9.2",
-        "typescript": "^5.7.3"
+        "typescript": "^5.8.3"
     },
     "peerDependencies": {
         "reflect-metadata": "^0.2.2",
-        "typeorm": "^0.3.0"
+        "typeorm": "^0.3.25"
     }
 }