@zuzjs/orm 0.3.3 → 0.3.5

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

@@ -156,6 +156,49 @@ class MySqlDriver {
                 WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND REFERENCED_TABLE_NAME IS NOT NULL`, [this.conn.database, tableName]);
             foreignKeys[tableName] = fkResults;
         }
+        // Track inverse relations: { tableName: { fkColumn: targetTable } }
+        const inverseRelations = {};
+        // Populate inverse map
+        for (const [tableName, fks] of Object.entries(foreignKeys)) {
+            for (const fk of fks) {
+                const targetTable = fk.REFERENCED_TABLE_NAME;
+                const fkColumn = fk.COLUMN_NAME;
+                if (!inverseRelations[targetTable]) {
+                    inverseRelations[targetTable] = [];
+                }
+                inverseRelations[targetTable].push({
+                    fkColumn,
+                    targetTable: tableName,
+                    targetEntity: (0, index_js_1.toPascalCase)(tableName)
+                });
+            }
+        }
+        // Detect 2 Column Junction Tables for ManyToMany
+        const junctionTables = {};
+        for (const tableName of tableNames) {
+            const [cols] = await this.pool.execute(`SELECT COLUMN_NAME, COLUMN_KEY, EXTRA FROM INFORMATION_SCHEMA.COLUMNS 
+                 WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?`, [this.conn.database, tableName]);
+            const fks = foreignKeys[String(tableName)] || [];
+            if (fks.length !== 2)
+                continue;
+            // Must have exactly 2 columns
+            if (cols.length !== 2)
+                continue;
+            // Both columns must be primary key
+            if (cols.filter(c => c.COLUMN_KEY !== 'PRI').length > 0)
+                continue;
+            const [left, right] = fks;
+            const [t1, t2] = [left.REFERENCED_TABLE_NAME, right.REFERENCED_TABLE_NAME].sort();
+            const key = `${t1}_${t2}`;
+            if (!junctionTables[key]) {
+                junctionTables[key] = {
+                    left: t1,
+                    right: t2,
+                    leftCol: left.COLUMN_NAME,
+                    rightCol: right.COLUMN_NAME
+                };
+            }
+        }
         for (const tableName of tableNames) {
             const enums = [];
             const imports = [];
@@ -222,6 +265,43 @@ class MySqlDriver {
                     }
                 }
             }
+            // Add OneToMany Relations
+            const inverse = inverseRelations[String(tableName)] || [];
+            for (const rel of inverse) {
+                const propName = rel.targetTable.endsWith('s') ? rel.targetTable : `${rel.targetTable}s`;
+                // Avoid duplicate
+                if (entityCode.some(line => line.includes(`@${propName}`)))
+                    continue;
+                const importLine = `import { ${rel.targetEntity} } from "./${rel.targetTable}";`;
+                if (!imports.includes(importLine)) {
+                    imports.push(importLine);
+                }
+                if (!_imports.includes('OneToMany'))
+                    _imports.push('OneToMany');
+                entityCode.push(`\t@OneToMany(() => ${rel.targetEntity}, r => r.${rel.fkColumn})`);
+                entityCode.push(`\tfk${(0, index_js_1.toPascalCase)(propName)}!: ${rel.targetEntity}[];\n`);
+            }
+            // Add Many-to-Many Relations
+            const junctions = Object.values(junctionTables)
+                .filter(j => j.left === tableName || j.right === tableName);
+            for (const j of junctions) {
+                const targetTable = j.left === tableName ? j.right : j.left;
+                const targetEntity = (0, index_js_1.toPascalCase)(targetTable);
+                const propName = targetTable.endsWith('s') ? targetTable : `${targetTable}s`;
+                if (entityCode.some(line => line.includes(`@${propName}`)))
+                    continue;
+                const importLine = `import { ${targetEntity} } from "./${targetTable}";`;
+                if (!imports.includes(importLine)) {
+                    imports.push(importLine);
+                }
+                if (!_imports.includes('ManyToMany'))
+                    _imports.push('ManyToMany');
+                if (!_imports.includes('JoinTable'))
+                    _imports.push('JoinTable');
+                entityCode.push(`\t@ManyToMany(() => ${targetEntity})`);
+                entityCode.push(`\t@JoinTable()`);
+                entityCode.push(`\tom${propName}!: ${targetEntity}[];\n`);
+            }
             const Code = [
                 `/**`,
                 `* AutoGenerated by @zuzjs/orm.`,

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/dist/types.d.ts

@@ -101,4 +101,4 @@ export type DeleteQueryResult = {
     count: number;
     error?: QueryError;
 };
-export { BaseEntity, Column, Entity, JoinColumn, OneToOne, PrimaryColumn, PrimaryGeneratedColumn } from "typeorm";
+export { BaseEntity, Column, Entity, JoinColumn, ManyToMany, ManyToOne, OneToMany, OneToOne, PrimaryColumn, PrimaryGeneratedColumn } from "typeorm";

package/dist/types.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrimaryGeneratedColumn = exports.PrimaryColumn = exports.OneToOne = exports.JoinColumn = exports.Entity = exports.Column = exports.BaseEntity = void 0;
+exports.PrimaryGeneratedColumn = exports.PrimaryColumn = exports.OneToOne = exports.OneToMany = exports.ManyToOne = exports.ManyToMany = exports.JoinColumn = exports.Entity = exports.Column = exports.BaseEntity = void 0;
 var typeorm_1 = require("typeorm");
 Object.defineProperty(exports, "BaseEntity", { enumerable: true, get: function () { return typeorm_1.BaseEntity; } });
 Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return typeorm_1.Column; } });
 Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return typeorm_1.Entity; } });
 Object.defineProperty(exports, "JoinColumn", { enumerable: true, get: function () { return typeorm_1.JoinColumn; } });
+Object.defineProperty(exports, "ManyToMany", { enumerable: true, get: function () { return typeorm_1.ManyToMany; } });
+Object.defineProperty(exports, "ManyToOne", { enumerable: true, get: function () { return typeorm_1.ManyToOne; } });
+Object.defineProperty(exports, "OneToMany", { enumerable: true, get: function () { return typeorm_1.OneToMany; } });
 Object.defineProperty(exports, "OneToOne", { enumerable: true, get: function () { return typeorm_1.OneToOne; } });
 Object.defineProperty(exports, "PrimaryColumn", { enumerable: true, get: function () { return typeorm_1.PrimaryColumn; } });
 Object.defineProperty(exports, "PrimaryGeneratedColumn", { enumerable: true, get: function () { return typeorm_1.PrimaryGeneratedColumn; } });

package/package.json

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