@cheetah.js/orm 0.1.147 → 0.1.150

package/dist/SqlBuilder.js

@@ -5,6 +5,7 @@ const entities_1 = require("./domain/entities");
 const orm_1 = require("./orm");
 const value_processor_1 = require("./utils/value-processor");
 const sql_condition_builder_1 = require("./query/sql-condition-builder");
+const sql_subquery_builder_1 = require("./query/sql-subquery-builder");
 const model_transformer_1 = require("./query/model-transformer");
 const sql_column_manager_1 = require("./query/sql-column-manager");
 const sql_join_manager_1 = require("./query/sql-join-manager");
@@ -27,6 +28,8 @@ class SqlBuilder {
             return this.joinManager.applyJoin(relationship, value, alias);
         };
         this.conditionBuilder = new sql_condition_builder_1.SqlConditionBuilder(this.entityStorage, applyJoinWrapper, this.statements);
+        const subqueryBuilder = new sql_subquery_builder_1.SqlSubqueryBuilder(this.entityStorage, () => this.conditionBuilder);
+        this.conditionBuilder.setSubqueryBuilder(subqueryBuilder);
         this.joinManager = new sql_join_manager_1.SqlJoinManager(this.entityStorage, this.statements, this.entity, this.model, this.driver, this.logger, this.conditionBuilder, this.columnManager, this.modelTransformer, () => this.originalColumns, this.getAlias.bind(this));
     }
     initializeCacheManager() {

package/dist/driver/driver.interface.d.ts

@@ -248,6 +248,8 @@ export type OperatorMap<T> = {
     $lt?: ExpandScalar<T>;
     $lte?: ExpandScalar<T>;
     $like?: string;
+    $exists?: FilterQuery<ExpandProperty<T>>;
+    $nexists?: FilterQuery<ExpandProperty<T>>;
 };
 export type ExcludeFunctions<T, K extends keyof T> = T[K] extends Function ? never : K extends symbol ? never : K;
 export type Scalar = boolean | number | string | bigint | symbol | Date | RegExp | Uint8Array | {

package/dist/query/sql-condition-builder.d.ts

@@ -1,5 +1,6 @@
 import { FilterQuery, Relationship, Statement } from '../driver/driver.interface';
 import { EntityStorage } from '../domain/entities';
+import { SqlSubqueryBuilder } from './sql-subquery-builder';
 type ApplyJoinCallback = (relationship: Relationship<any>, value: FilterQuery<any>, alias: string) => string;
 export declare class SqlConditionBuilder<T> {
     private entityStorage;
@@ -7,10 +8,13 @@ export declare class SqlConditionBuilder<T> {
     private statements;
     private readonly OPERATORS;
     private lastKeyNotOperator;
+    private subqueryBuilder?;
     constructor(entityStorage: EntityStorage, applyJoinCallback: ApplyJoinCallback, statements: Statement<T>);
+    setSubqueryBuilder(subqueryBuilder: SqlSubqueryBuilder): void;
     build(condition: FilterQuery<T>, alias: string, model: Function): string;
     private processConditions;
     private processEntry;
+    private hasExistsOperator;
     private handleRelationship;
     private handleScalarValue;
     private handleObjectValue;
@@ -39,6 +43,8 @@ export declare class SqlConditionBuilder<T> {
     private isLogicalOperator;
     private extractLogicalOperator;
     private trackLastNonOperatorKey;
+    private buildExistsCondition;
+    private buildTopLevelExistsCondition;
     private resolveColumnName;
     private resolveRelationColumn;
 }

package/dist/query/sql-condition-builder.js

@@ -8,15 +8,19 @@ class SqlConditionBuilder {
         this.entityStorage = entityStorage;
         this.applyJoinCallback = applyJoinCallback;
         this.statements = statements;
-        this.OPERATORS = ['$eq', '$ne', '$in', '$nin', '$like', '$gt', '$gte', '$lt', '$lte', '$and', '$or'];
+        this.OPERATORS = ['$eq', '$ne', '$in', '$nin', '$like', '$gt', '$gte', '$lt', '$lte', '$and', '$or', '$exists', '$nexists'];
         this.lastKeyNotOperator = '';
     }
+    setSubqueryBuilder(subqueryBuilder) {
+        this.subqueryBuilder = subqueryBuilder;
+    }
     build(condition, alias, model) {
         const sqlParts = this.processConditions(condition, alias, model);
         if (sqlParts.length === 0) {
             return '';
         }
-        return this.wrapWithLogicalOperator(sqlParts, 'AND');
+        const result = this.wrapWithLogicalOperator(sqlParts, 'AND');
+        return result;
     }
     processConditions(condition, alias, model) {
         const sqlParts = [];
@@ -32,7 +36,7 @@ class SqlConditionBuilder {
     processEntry(key, value, alias, model) {
         this.trackLastNonOperatorKey(key, model);
         const relationship = this.findRelationship(key, model);
-        if (relationship) {
+        if (relationship && !this.hasExistsOperator(value)) {
             return this.handleRelationship(relationship, value, alias);
         }
         if (this.isScalarValue(value)) {
@@ -43,6 +47,9 @@ class SqlConditionBuilder {
         }
         return this.handleObjectValue(key, value, alias, model);
     }
+    hasExistsOperator(value) {
+        return typeof value === 'object' && value !== null && ('$exists' in value || '$nexists' in value);
+    }
     handleRelationship(relationship, value, alias) {
         const sql = this.applyJoinCallback(relationship, value, alias);
         if (this.statements.strategy === 'joined') {
@@ -60,6 +67,9 @@ class SqlConditionBuilder {
         if (this.isLogicalOperator(key)) {
             return this.buildLogicalOperatorCondition(key, value, alias, model);
         }
+        if (key === '$exists' || key === '$nexists') {
+            return this.buildTopLevelExistsCondition(key, value, alias, model);
+        }
         return this.buildOperatorConditions(key, value, alias, model);
     }
     buildLogicalOperatorCondition(key, value, alias, model) {
@@ -100,6 +110,10 @@ class SqlConditionBuilder {
             case '$and':
             case '$or':
                 return this.buildNestedLogicalCondition(operator, value, alias, model);
+            case '$exists':
+                return this.buildExistsCondition(key, value, alias, model, false);
+            case '$nexists':
+                return this.buildExistsCondition(key, value, alias, model, true);
             default:
                 return '';
         }
@@ -202,6 +216,31 @@ class SqlConditionBuilder {
             this.lastKeyNotOperator = key;
         }
     }
+    buildExistsCondition(key, filters, alias, model, negate) {
+        const relationship = this.findRelationship(key, model);
+        if (!relationship) {
+            const entity = this.entityStorage.get(model);
+            const availableRelations = entity?.relations
+                ?.map((r) => r.propertyKey)
+                .join(', ') || 'none';
+            throw new Error(`Cannot use $${negate ? 'nexists' : 'exists'} on non-relationship field '${key}'. ` +
+                `Available relationships: ${availableRelations}`);
+        }
+        if (!this.subqueryBuilder) {
+            throw new Error('SqlSubqueryBuilder not initialized. This is an internal error.');
+        }
+        return this.subqueryBuilder.buildExistsSubquery(relationship, filters, alias, negate, model);
+    }
+    buildTopLevelExistsCondition(operator, value, alias, model) {
+        const negate = operator === '$nexists';
+        const conditions = [];
+        for (const [relationshipKey, filters] of Object.entries(value)) {
+            const condition = this.buildExistsCondition(relationshipKey, filters, alias, model, negate);
+            conditions.push(condition);
+        }
+        const result = this.wrapWithLogicalOperator(conditions, 'AND');
+        return result;
+    }
     resolveColumnName(property, model) {
         if (property.startsWith('$')) {
             return property;

package/dist/query/sql-subquery-builder.d.ts

@@ -0,0 +1,20 @@
+import { FilterQuery, Relationship } from '../driver/driver.interface';
+import { EntityStorage } from '../domain/entities';
+import { SqlConditionBuilder } from './sql-condition-builder';
+export declare class SqlSubqueryBuilder {
+    private entityStorage;
+    private getConditionBuilder;
+    private aliasCounter;
+    constructor(entityStorage: EntityStorage, getConditionBuilder: () => SqlConditionBuilder<any>);
+    buildExistsSubquery(relationship: Relationship<any>, filters: FilterQuery<any>, outerAlias: string, negate: boolean, outerModel?: Function): string;
+    private buildSubquery;
+    private buildWhereClause;
+    private buildCorrelation;
+    private getOuterPrimaryKey;
+    private buildFilterConditions;
+    private combineConditions;
+    private resolveTableName;
+    private generateAlias;
+    private getFkKey;
+    private getRelatedPrimaryKey;
+}

package/dist/query/sql-subquery-builder.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlSubqueryBuilder = void 0;
+class SqlSubqueryBuilder {
+    constructor(entityStorage, getConditionBuilder) {
+        this.entityStorage = entityStorage;
+        this.getConditionBuilder = getConditionBuilder;
+        this.aliasCounter = 1;
+    }
+    buildExistsSubquery(relationship, filters, outerAlias, negate, outerModel) {
+        const prefix = negate ? 'NOT EXISTS' : 'EXISTS';
+        const subquery = this.buildSubquery(relationship, filters, outerAlias, outerModel);
+        return `${prefix} (${subquery})`;
+    }
+    buildSubquery(relationship, filters, outerAlias, outerModel) {
+        const subqueryAlias = this.generateAlias();
+        const tableName = this.resolveTableName(relationship);
+        const whereClause = this.buildWhereClause(relationship, filters, outerAlias, subqueryAlias, outerModel);
+        return `SELECT 1 FROM ${tableName} ${subqueryAlias} WHERE ${whereClause}`;
+    }
+    buildWhereClause(relationship, filters, outerAlias, subqueryAlias, outerModel) {
+        const correlation = this.buildCorrelation(relationship, outerAlias, subqueryAlias, outerModel);
+        const filterSql = this.buildFilterConditions(filters, subqueryAlias, relationship);
+        return this.combineConditions(correlation, filterSql);
+    }
+    buildCorrelation(relationship, outerAlias, subqueryAlias, outerModel) {
+        const fkKey = this.getFkKey(relationship);
+        const outerPkKey = this.getOuterPrimaryKey(relationship, outerModel);
+        const relatedPkKey = this.getRelatedPrimaryKey(relationship);
+        if (relationship.relation === 'one-to-many') {
+            return `${subqueryAlias}."${fkKey}" = ${outerAlias}."${outerPkKey}"`;
+        }
+        const outerFk = relationship.columnName;
+        return `${outerAlias}."${outerFk}" = ${subqueryAlias}."${relatedPkKey}"`;
+    }
+    getOuterPrimaryKey(relationship, outerModel) {
+        if (!outerModel) {
+            return 'id';
+        }
+        const entity = this.entityStorage.get(outerModel);
+        if (!entity) {
+            return 'id';
+        }
+        for (const prop in entity.properties) {
+            if (entity.properties[prop].options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
+    buildFilterConditions(filters, alias, relationship) {
+        if (!filters || Object.keys(filters).length === 0) {
+            return '';
+        }
+        const conditionBuilder = this.getConditionBuilder();
+        const entity = relationship.entity();
+        return conditionBuilder.build(filters, alias, entity);
+    }
+    combineConditions(correlation, filterSql) {
+        if (!filterSql) {
+            return correlation;
+        }
+        return `${correlation} AND ${filterSql}`;
+    }
+    resolveTableName(relationship) {
+        const entity = this.entityStorage.get(relationship.entity());
+        if (!entity) {
+            const name = relationship.entity().name.toLowerCase();
+            return `public.${name}`;
+        }
+        const schema = entity.schema || 'public';
+        const tableName = entity.tableName || relationship.entity().name.toLowerCase();
+        return `${schema}."${tableName}"`;
+    }
+    generateAlias() {
+        const alias = `sq${this.aliasCounter}`;
+        this.aliasCounter++;
+        return alias;
+    }
+    getFkKey(relationship) {
+        if (typeof relationship.fkKey === 'undefined') {
+            return 'id';
+        }
+        if (typeof relationship.fkKey === 'string') {
+            return relationship.fkKey;
+        }
+        const match = /\.(?<propriedade>[\w]+)/.exec(relationship.fkKey.toString());
+        const propertyKey = match ? match.groups.propriedade : '';
+        const entity = this.entityStorage.get(relationship.entity());
+        if (!entity) {
+            throw new Error(`Entity not found in storage for relationship. ` +
+                `Make sure the entity ${relationship.entity().name} is decorated with @Entity()`);
+        }
+        const property = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
+        if (property) {
+            return property.options.columnName;
+        }
+        const relation = entity.relations.find((rel) => rel.propertyKey === propertyKey);
+        if (relation && relation.columnName) {
+            return relation.columnName;
+        }
+        throw new Error(`Property or relation "${propertyKey}" not found in entity "${entity.tableName}". ` +
+            `Available properties: ${Object.keys(entity.properties).join(', ')}. ` +
+            `Available relations: ${entity.relations.map((r) => r.propertyKey).join(', ')}`);
+    }
+    getRelatedPrimaryKey(relationship) {
+        const entity = this.entityStorage.get(relationship.entity());
+        if (!entity) {
+            return 'id';
+        }
+        for (const prop in entity.properties) {
+            if (entity.properties[prop].options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
+}
+exports.SqlSubqueryBuilder = SqlSubqueryBuilder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.147",
+  "version": "0.1.150",
   "description": "A simple ORM for Cheetah.js.",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "9efbea28c5bb4bdc91e8aa6ba03a634f0a4ab00f"
+  "gitHead": "f8214d31758bc38e63d8cc2e4db4c5572db28201"
 }