@zuzjs/orm 0.3.2 → 0.3.4

package/dist/drivers/expressionBuilder.d.ts

@@ -1,19 +1,32 @@
 import { ObjectLiteral } from "typeorm";
 declare class ZormExprBuilder<T extends ObjectLiteral> {
-    private _expression;
-    private _param;
-    private _paramIndex;
-    field(column: keyof T | string): this;
+    private _parts;
+    private _params;
+    private _paramIdx;
+    private _alias;
+    private static globalParamIdx;
+    constructor(alias?: string, parent?: {
+        params: Record<string, any>;
+        idx: number;
+    });
+    field(col: keyof T | string): this;
+    equals(value: any): this;
+    append(extra: string): this;
+    wrap(wrapper: (expr: string) => string): this;
+    exists(sub: (q: ZormExprBuilder<T>) => ZormExprBuilder<T>): this;
+    select(expr: string): this;
+    from(table: string, alias: string): this;
+    where(cond: Record<string, any>): this;
+    or(): this;
+    group(): 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): {
+    toExpression(): {
         expression: string;
         param: Record<string, any>;
     };
     buildExpression(): string;
-    buildParam(): Record<string, any>;
+    buildParams(): Record<string, any>;
 }
 export default ZormExprBuilder;

package/dist/drivers/expressionBuilder.js

@@ -1,46 +1,100 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class ZormExprBuilder {
-    _expression = "";
-    _param = {};
-    _paramIndex = 0;
-    field(column) {
-        this._expression = String(column);
+    _parts = [];
+    _params = {};
+    _paramIdx = 0;
+    _alias;
+    static globalParamIdx = 0;
+    constructor(alias, parent) {
+        this._alias = alias ? `${alias}.` : ``;
+        this._paramIdx = parent ? parent.idx : 0;
+        this._params = parent ? parent.params : {};
+    }
+    field(col) {
+        this._parts.push(`${this._alias}${String(col)}`);
         return this;
     }
-    fromUnixTime() {
-        this._expression = `FROM_UNIXTIME(${this._expression})`;
+    equals(value) {
+        const key = `p${this._paramIdx++}`;
+        this.append(` = :${key}`);
+        // this._parts[this._parts.length - 1] += ` = :${key}`;
+        this._params[key] = value;
         return this;
     }
-    date() {
-        this._expression = `DATE(${this._expression})`;
+    append(extra) {
+        if (this._parts.length === 0)
+            throw new Error("Cannot append to empty expression");
+        this._parts[this._parts.length - 1] += extra;
         return this;
     }
-    substring(column, delimiter, index) {
-        this._expression = `SUBSTRING_INDEX(${String(column)}, '${delimiter}', ${index})`;
+    wrap(wrapper) {
+        if (this._parts.length === 0)
+            throw new Error("Cannot wrap empty expression");
+        this._parts[this._parts.length - 1] = wrapper(this._parts[this._parts.length - 1]);
         return this;
     }
-    append(extra) {
-        this._expression = `${this._expression}${extra}`;
+    exists(sub) {
+        const subQ = new ZormExprBuilder(undefined, { params: this._params, idx: this._paramIdx });
+        sub(subQ);
+        // const { expression, param } = subQ.toExpression();
+        this._parts.push(`EXISTS (${subQ.buildExpression()})`);
+        // Object.assign(this._params, param);
+        this._paramIdx = subQ._paramIdx;
         return this;
     }
-    wrap(wrapper) {
-        this._expression = wrapper(this._expression);
+    select(expr) {
+        this._parts.push(`SELECT ${expr}`);
         return this;
     }
-    equals(value) {
-        const paramKey = `param${this._paramIndex++}`;
-        this._param[paramKey] = value;
-        return {
-            expression: `${this._expression} = :${paramKey}`,
-            param: this._param,
-        };
+    from(table, alias) {
+        this._parts.push(`FROM ${table} ${alias}`);
+        this._alias = alias;
+        return this;
+    }
+    where(cond) {
+        const whereParts = [];
+        for (const [k, v] of Object.entries(cond)) {
+            const key = `p${this._paramIdx++}`;
+            whereParts.push(`${k} = :${key}`);
+            this._params[key] = v;
+        }
+        this._parts.push(`WHERE ${whereParts.join(' AND ')}`);
+        return this;
+    }
+    // or(sub: ZormExprBuilder<any> | { expression: string; param: Record<string, any> }): this {
+    //     const { expression, param } = 'toExpression' in sub ? sub.toExpression() : sub;
+    //     this._parts.push(this._parts.length === 0 ? expression : `OR ${expression}`);
+    //     Object.assign(this._params, param);
+    //     return this;
+    // }
+    or() {
+        this._parts.push(`OR`);
+        return this;
+    }
+    group() {
+        return this.wrap(e => `(${e})`);
+    }
+    fromUnixTime() {
+        this.wrap(expr => `FROM_UNIXTIME(${expr})`);
+        return this;
+    }
+    date() {
+        this.wrap(expr => `DATE(${expr})`);
+        return this;
+    }
+    substring(column, delimiter, index) {
+        this._parts = [`SUBSTRING_INDEX(${this._alias}${String(column)}, '${delimiter}', ${index})`];
+        return this;
+    }
+    toExpression() {
+        return { expression: this._parts.join(' '), param: this._params };
     }
     buildExpression() {
-        return this._expression;
+        return this.toExpression().expression;
     }
-    buildParam() {
-        return this._param;
+    buildParams() {
+        return this.toExpression().param;
     }
 }
 exports.default = ZormExprBuilder;

package/dist/drivers/mysql/index.js

@@ -210,7 +210,7 @@ class MySqlDriver {
             if (foreignKeys[tableName]) {
                 for (const fk of foreignKeys[tableName] || []) {
                     const relatedEntity = (0, index_js_1.toPascalCase)(fk.REFERENCED_TABLE_NAME);
-                    if (entityCode.includes(`fk${relatedEntity}!: ${relatedEntity};`) === false) {
+                    if (imports.includes(`import { ${relatedEntity} } from "./${fk.REFERENCED_TABLE_NAME}";`) === false) {
                         entityCode.push(`\t@OneToOne(() => ${relatedEntity})`);
                         entityCode.push(`\t@JoinColumn({ name: "${fk.COLUMN_NAME}" })`);
                         entityCode.push(`\tfk${relatedEntity}!: ${relatedEntity};\n`);

package/dist/drivers/queryBuilder.d.ts

@@ -45,10 +45,9 @@ declare class ZormQueryBuilder<T extends ObjectLiteral, R = QueryResult> extends
      * 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;
+    expression(exprFn: (q: ZormExprBuilder<T>) => ZormExprBuilder<T>, 
+    /** Add parentheses group to built expression */
+    group?: boolean): this;
     /**
      * Adds a WHERE condition to the query.
      * @param condition - The condition to be added.

package/dist/drivers/queryBuilder.js

@@ -179,19 +179,29 @@ class ZormQueryBuilder extends Promise {
      * 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) {
+    expression(exprFn, 
+    /** Add parentheses group to built expression */
+    group = true) {
         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());
-        }
+        const result = exprFn(new expressionBuilder_1.default(this.entityAlias));
+        const _expression = result.buildExpression();
+        qb.andWhere(group ? `(${_expression})` : _expression, result.buildParams());
         this.whereCount++;
         return this;
     }
+    // expression(exprFn: (q: ZormExprBuilder<T>) => ZormExprBuilder<T>): this {
+    //     const qb = this.queryBuilder as SelectQueryBuilder<T> | UpdateQueryBuilder<T>;
+    //     const result = exprFn(new ZormExprBuilder<T>(this.entityAlias));
+    //     // const expression = 
+    //     qb.andWhere(result.buildExpression(), result.buildParams());
+    //     // if ('expression' in result && 'param' in result) {
+    //     // } else {
+    //     //     // fallback if only expression was built without .equals()
+    //     // }
+    //     // qb.andWhere(result.buildExpression(), result.buildParams());
+    //     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.2",
+    "version": "0.3.4",
     "keywords": [
         "orm",
         "zuz",