Skip to content

The open alternative to Salesforce, designed for AI.

ORM v2: relation-keyed where clauses (#24230)

Charles Bochet044fc2d38908
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/__tests__/workspace-select-query-builder-v2-relation-where.spec.ts b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/__tests__/workspace-select-query-builder-v2-relation-where.spec.ts
new file mode 100644
index 00000000000..58905d7b569
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/__tests__/workspace-select-query-builder-v2-relation-where.spec.ts
@@ -0,0 +1,212 @@
+import { Any, Equal } from 'typeorm';
+
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
+import { TwentyOrmV2Exception } from 'src/engine/twenty-orm-v2/exceptions/twenty-orm-v2.exception';
+import { applyFindOptionsToQueryBuilder } from 'src/engine/twenty-orm-v2/query-builder/utils/apply-find-options.util';
+import { buildQueryBuilder } from 'src/engine/twenty-orm-v2/query-builder/__tests__/workspace-select-query-builder-v2-test-shapes.util';
+
+describe('WorkspaceSelectQueryBuilderV2 relation-keyed where', () => {
+ it('should filter a to-many relation with a correlated EXISTS instead of a join', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ queryBuilder
+ .setFindOptions({ select: { id: true } })
+ .where({ people: { name: Equal('Twenty') } });
+
+ const [text, values] = queryBuilder.getQueryAndParameters();
+
+ expect(text).toContain(
+ 'EXISTS (SELECT 1 FROM "workspace_1wgvd1injqtife6y4rvfbu3h5"."company" AS "person_people_filter" WHERE "person_people_filter"."personId" = "person"."id" AND ("person_people_filter"."name" = $1) AND "person_people_filter"."deletedAt" IS NULL)',
+ );
+ expect(text).not.toContain('JOIN');
+ expect(values).toEqual(['Twenty']);
+ });
+
+ it('should correlate a to-one relation on the parent join column', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ queryBuilder
+ .setFindOptions({ select: { id: true } })
+ .where({ company: { name: Equal('Twenty') } });
+
+ expect(queryBuilder.getQuery()).toContain(
+ 'EXISTS (SELECT 1 FROM "workspace_1wgvd1injqtife6y4rvfbu3h5"."company" AS "person_company_filter" WHERE "person"."companyId" = "person_company_filter"."id"',
+ );
+ });
+
+ it('should combine a relation filter with sibling column conditions', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ queryBuilder.setFindOptions({ select: { id: true } }).where({
+ nameFirstName: Equal('Ada'),
+ people: { name: Equal('Twenty') },
+ });
+
+ const [text, values] = queryBuilder.getQueryAndParameters();
+
+ expect(text).toContain('"person"."nameFirstName" = $1 AND EXISTS (');
+ expect(values).toEqual(['Ada', 'Twenty']);
+ });
+
+ it('should keep a relation filter inside its OR group', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ applyFindOptionsToQueryBuilder(queryBuilder, {
+ select: { id: true },
+ where: [
+ { nameFirstName: Equal('Ada') },
+ { people: { name: Equal('Twenty') } },
+ ],
+ });
+
+ const text = queryBuilder.getQuery();
+
+ expect(text).toContain('OR');
+ expect(text).toContain('EXISTS (');
+ expect(text).not.toContain('__ormV2ExistsFilter');
+ });
+
+ it('should nest a relation filter reached through another relation', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ queryBuilder
+ .setFindOptions({ select: { id: true } })
+ .where({ people: { person: { name: Equal('Twenty') } } });
+
+ const text = queryBuilder.getQuery();
+
+ expect(text).toContain('"person_people_filter"."personId" = "person"."id"');
+ expect(text).toContain(
+ '"person_people_filter"."personId" = "person_people_filter_person_filter"."id"',
+ );
+ expect(text).not.toContain('__ormV2ExistsFilter');
+ });
+
+ it('should drop the soft-delete predicate inside the subquery when deleted rows are included', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ queryBuilder
+ .setFindOptions({ select: { id: true } })
+ .where({ people: { name: Equal('Twenty') } })
+ .withDeleted();
+
+ expect(queryBuilder.getQuery()).not.toContain(
+ '"person_people_filter"."deletedAt" IS NULL',
+ );
+ });
+
+ it('should apply a row-level permission predicate inside the subquery', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ queryBuilder
+ .setFindOptions({ select: { id: true } })
+ .where({ people: { name: Equal('Twenty') } });
+
+ queryBuilder.addJoinCondition(
+ 'person_people_filter',
+ '"person_people_filter"."name" <> \'hidden\'',
+ );
+
+ expect(queryBuilder.getQuery()).toContain(
+ 'AND "person_people_filter"."name" <> \'hidden\'',
+ );
+ });
+
+ it('should expose the filtered relation as a join attribute so permissions resolve it', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ queryBuilder
+ .setFindOptions({ select: { id: true } })
+ .where({ people: { name: Equal('Twenty') } });
+
+ expect(
+ queryBuilder.expressionMap.joinAttributes.map(
+ (joinAttribute) => joinAttribute.alias.name,
+ ),
+ ).toContain('person_people_filter');
+ expect(
+ queryBuilder.getJoinedTableShape('person_people_filter')?.nameSingular,
+ ).toBe('company');
+ });
+
+ it('should count parents once when filtering on a to-many relation', async () => {
+ const { queryBuilder, executedStatements } = buildQueryBuilder({
+ rows: [{ count: '2' }],
+ });
+
+ queryBuilder.where({ people: { name: Equal('Twenty') } });
+
+ await expect(queryBuilder.getCount()).resolves.toBe(2);
+
+ expect(executedStatements[0].text).toContain('EXISTS (');
+ expect(executedStatements[0].text).not.toContain('DISTINCT');
+ expect(executedStatements[0].text).not.toContain('JOIN');
+ });
+
+ it('should pass an Any operator through to the subquery', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ queryBuilder
+ .setFindOptions({ select: { id: true } })
+ .where({ people: { id: Any(['a', 'b']) } });
+
+ const [text, values] = queryBuilder.getQueryAndParameters();
+
+ expect(text).toContain('"person_people_filter"."id" = ANY($1)');
+ expect(values).toEqual([['a', 'b']]);
+ });
+
+ it('should reject a relation filter whose inverse foreign key cannot be resolved', () => {
+ const { queryBuilder } = buildQueryBuilder({
+ tableShape: {
+ objectMetadataId: 'person-object-id',
+ nameSingular: 'person',
+ schemaName: 'workspace_1wgvd1injqtife6y4rvfbu3h5',
+ tableName: 'person',
+ columnShapeByColumnName: {},
+ columnNames: [],
+ relationShapeByFieldName: {
+ orphans: {
+ fieldName: 'orphans',
+ fieldMetadataId: 'field-orphans',
+ relationType: RelationType.ONE_TO_MANY,
+ targetObjectMetadataId: 'company-object-id',
+ targetFieldMetadataId: null,
+ },
+ },
+ hasDeletedAtColumn: false,
+ },
+ });
+
+ expect(() =>
+ queryBuilder.where({ orphans: { name: Equal('Twenty') } }),
+ ).toThrow(TwentyOrmV2Exception);
+ });
+
+ it('should carry relation filters into a builder that copies the where clauses', () => {
+ const { queryBuilder } = buildQueryBuilder();
+ const { queryBuilder: snapshotQueryBuilder } = buildQueryBuilder();
+
+ queryBuilder
+ .setFindOptions({ select: { id: true } })
+ .where({ people: { name: Equal('Twenty') } });
+
+ snapshotQueryBuilder
+ .setFindOptions({ select: { id: true } })
+ .copyWhereFrom(queryBuilder);
+
+ const text = snapshotQueryBuilder.getQuery();
+
+ expect(text).toContain('EXISTS (');
+ expect(text).not.toContain('__ormV2ExistsFilter');
+ });
+
+ it('should reject a relation filter on a mutation', () => {
+ const { queryBuilder } = buildQueryBuilder();
+
+ queryBuilder.where({ people: { name: Equal('Twenty') } });
+
+ expect(() => queryBuilder.delete()).toThrow(TwentyOrmV2Exception);
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2.ts b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2.ts
index 3250d9c52d6..3d69fde6e50 100644
--- a/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2.ts
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/query-builder/workspace-select-query-builder-v2.ts
@@ -39,6 +39,7 @@ import {
quoteColumn,
quoteQualifiedAliasReferences,
type ColumnSelection,
+ type ExistsFilterClause,
type ToManyDedupOrder,
type JoinClause,
type OrderByClause,
@@ -50,6 +51,14 @@ import { type WorkspaceTableShape } from 'src/engine/twenty-orm-v2/table-shape/t
import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';
let objectWhereParameterSequence = 0;
+let existsFilterSequence = 0;
+
+const isNestedWhereObject = (value: unknown): value is ObjectWhereLike =>
+ isDefined(value) &&
+ typeof value === 'object' &&
+ !Array.isArray(value) &&
+ !(value instanceof FindOperator) &&
+ !(value instanceof Date);
export type QueryBuilderV2Context = {
tableShape: WorkspaceTableShape;
@@ -70,6 +79,7 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
private readonly context: QueryBuilderV2Context;
private readonly whereClauses: WhereClause[] = [];
private readonly joinClauses: JoinClause[] = [];
+ private readonly existsFilterClauses: ExistsFilterClause[] = [];
private readonly extraSelectClauses: SelectClause[] = [];
private readonly pendingColumnSelections: string[] = [];
private orderByClauses: OrderByClause[] = [];
@@ -93,13 +103,19 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
get expressionMap(): ExpressionMapLike {
return {
queryType: 'select',
- joinAttributes: this.joinClauses.map((joinClause) => ({
- alias: { name: joinClause.alias },
- relation: {
- isOneToMany: joinClause.relationType === RelationType.ONE_TO_MANY,
- isManyToMany: false,
- },
- })),
+ joinAttributes: [
+ ...this.joinClauses.map((joinClause) => ({
+ alias: { name: joinClause.alias },
+ relation: {
+ isOneToMany: joinClause.relationType === RelationType.ONE_TO_MANY,
+ isManyToMany: false,
+ },
+ })),
+ ...this.existsFilterClauses.map((existsFilterClause) => ({
+ alias: { name: existsFilterClause.alias },
+ relation: { isOneToMany: false, isManyToMany: false },
+ })),
+ ],
};
}
@@ -107,6 +123,12 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
const cloned = new WorkspaceSelectQueryBuilderV2(this.alias, this.context);
cloned.whereClauses.push(...this.whereClauses);
+ cloned.existsFilterClauses.push(
+ ...this.existsFilterClauses.map((existsFilterClause) => ({
+ ...existsFilterClause,
+ additionalOnConditions: [...existsFilterClause.additionalOnConditions],
+ })),
+ );
cloned.joinClauses.push(
...this.joinClauses.map((joinClause) => ({
...joinClause,
@@ -147,6 +169,12 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
copyWhereFrom(source: WorkspaceSelectQueryBuilderV2): this {
this.whereClauses.push(...source.whereClauses);
+ this.existsFilterClauses.push(
+ ...source.existsFilterClauses.map((existsFilterClause) => ({
+ ...existsFilterClause,
+ additionalOnConditions: [...existsFilterClause.additionalOnConditions],
+ })),
+ );
this.parameters = { ...this.parameters, ...source.parameters };
return this;
@@ -623,12 +651,23 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
joinClause.additionalOnConditions.push(condition);
}
+ for (const existsFilterClause of this.existsFilterClauses) {
+ if (existsFilterClause.alias === alias) {
+ existsFilterClause.additionalOnConditions.push(condition);
+ }
+ }
+
return this;
}
getJoinedTableShape(alias: string): WorkspaceTableShape | undefined {
- return this.joinClauses.find((joinClause) => joinClause.alias === alias)
- ?.targetTableShape;
+ return (
+ this.joinClauses.find((joinClause) => joinClause.alias === alias)
+ ?.targetTableShape ??
+ this.existsFilterClauses.find(
+ (existsFilterClause) => existsFilterClause.alias === alias,
+ )?.targetTableShape
+ );
}
markRowLevelPermissionApplied(alias: string): boolean {
@@ -705,6 +744,15 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
);
}
+ // Row-level permission predicates are injected on the select path only, so an
+ // EXISTS rendered here would filter the related table with no predicate at all.
+ if (this.existsFilterClauses.length > 0) {
+ throw new TwentyOrmV2Exception(
+ `A mutation cannot carry a relation filter; rewrite the filter as an "id IN (subquery)" predicate first`,
+ TwentyOrmV2ExceptionCode.UNSUPPORTED_OPERATION,
+ );
+ }
+
return new WorkspaceMutationQueryBuilderV2({
alias: this.alias,
kind,
@@ -737,9 +785,11 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
const nestedSql = nestedBuilder.buildWhereExpression({
includeSoftDeletePredicate: false,
+ substituteExistsFilters: false,
});
this.setParameters(nestedBuilder.parameters);
+ this.existsFilterClauses.push(...nestedBuilder.existsFilterClauses);
if (nestedSql.length > 0) {
this.whereClauses.push({
@@ -794,6 +844,22 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
continue;
}
+ const relationShape =
+ this.tableShape.relationShapeByFieldName[columnName];
+
+ if (isDefined(relationShape) && isNestedWhereObject(value)) {
+ conditions.push(
+ this.buildRelationExistsCondition({
+ relationFieldName: columnName,
+ relationShape,
+ where: value,
+ parameters,
+ }),
+ );
+
+ continue;
+ }
+
const hasCompositeChildColumns = Object.values(
this.tableShape.columnShapeByColumnName,
).some((shape) => shape.compositeParentFieldName === columnName);
@@ -843,6 +909,94 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
return { sql: conditions.join(' AND '), parameters };
}
+ private buildRelationExistsCondition({
+ relationFieldName,
+ relationShape,
+ where,
+ parameters,
+ }: {
+ relationFieldName: string;
+ relationShape: WorkspaceTableShape['relationShapeByFieldName'][string];
+ where: ObjectWhereLike;
+ parameters: Record<string, unknown>;
+ }): string {
+ const targetTableShape = this.context.tableShapeByObjectMetadataId(
+ relationShape.targetObjectMetadataId,
+ );
+
+ const alias = this.buildExistsFilterAlias(relationFieldName);
+
+ const correlationCondition = isDefined(relationShape.joinColumnName)
+ ? `${this.quoteColumn(this.alias, relationShape.joinColumnName)} = ${this.quoteColumn(alias, 'id')}`
+ : this.buildToManyJoin({
+ parentAlias: this.alias,
+ alias,
+ targetTableShape,
+ targetFieldMetadataId: relationShape.targetFieldMetadataId,
+ })?.condition;
+
+ if (!isDefined(correlationCondition)) {
+ throw new TwentyOrmV2Exception(
+ `Relation "${relationFieldName}" on "${this.tableShape.nameSingular}" cannot be filtered on because its inverse foreign key could not be resolved`,
+ TwentyOrmV2ExceptionCode.UNKNOWN_RELATION,
+ );
+ }
+
+ const nestedBuilder = new WorkspaceSelectQueryBuilderV2(alias, {
+ ...this.context,
+ tableShape: targetTableShape,
+ });
+
+ nestedBuilder.where(where);
+
+ Object.assign(parameters, nestedBuilder.parameters);
+
+ const token = `__ormV2ExistsFilter_${existsFilterSequence++}__`;
+
+ this.existsFilterClauses.push(
+ {
+ token,
+ alias,
+ parentAlias: this.alias,
+ relationFieldName,
+ targetTableShape,
+ correlationCondition,
+ conditionSql: nestedBuilder.buildWhereExpression({
+ includeSoftDeletePredicate: false,
+ substituteExistsFilters: false,
+ }),
+ additionalOnConditions: [],
+ },
+ ...nestedBuilder.existsFilterClauses,
+ );
+
+ return token;
+ }
+
+ private buildExistsFilterAlias(relationFieldName: string): string {
+ const baseAlias = `${this.alias}_${relationFieldName}_filter`;
+
+ const takenAliases = new Set([
+ this.alias,
+ ...this.joinClauses.map((joinClause) => joinClause.alias),
+ ...this.existsFilterClauses.map(
+ (existsFilterClause) => existsFilterClause.alias,
+ ),
+ ]);
+
+ if (!takenAliases.has(baseAlias)) {
+ return baseAlias;
+ }
+
+ let suffix = 2;
+
+ while (takenAliases.has(`${baseAlias}_${suffix}`)) {
+ suffix++;
+ }
+
+ return `${baseAlias}_${suffix}`;
+ }
+
private buildValueCondition(
quotedColumn: string,
columnName: string,
@@ -1014,6 +1168,7 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
private buildWhereExpression(options?: {
includeSoftDeletePredicate?: boolean;
+ substituteExistsFilters?: boolean;
}): string {
return buildWhereExpression(this.toSelectStatementState(), options);
}
@@ -1038,6 +1193,7 @@ export class WorkspaceSelectQueryBuilderV2 implements WhereExpressionLike {
columnSelections: this.resolveColumnSelections(),
joinClauses: this.joinClauses,
whereClauses: this.whereClauses,
+ existsFilterClauses: this.existsFilterClauses,
groupByExpressions: this.groupByExpressions,
orderByClauses: this.orderByClauses,
distinctOnExpressions: this.distinctOnExpressions,
diff --git a/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-select-statement.util.ts b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-select-statement.util.ts
index 0c6f967f28d..4cfc20ce984 100644
--- a/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-select-statement.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm-v2/sql/utils/build-select-statement.util.ts
@@ -37,6 +37,17 @@ export type ToManyDedupOrder = {
nulls?: 'NULLS FIRST' | 'NULLS LAST';
};
+export type ExistsFilterClause = {
+ token: string;
+ alias: string;
+ parentAlias: string;
+ relationFieldName: string;
+ targetTableShape: WorkspaceTableShape;
+ correlationCondition: string;
+ conditionSql: string;
+ additionalOnConditions: string[];
+};
+
export type ColumnSelection = {
alias: string;
columnName: string;
@@ -62,6 +73,7 @@ export type SelectStatementState = {
columnSelections: ColumnSelection[];
joinClauses: JoinClause[];
whereClauses: WhereClause[];
+ existsFilterClauses: ExistsFilterClause[];
groupByExpressions: string[];
orderByClauses: OrderByClause[];
distinctOnExpressions: string[];
@@ -286,17 +298,77 @@ export const renderUserWhereExpression = (
)
.join(' ');
+const renderExistsFilter = (
+ existsFilterClause: ExistsFilterClause,
+ includeDeleted: boolean,
+): string => {
+ const conditions = [
+ existsFilterClause.correlationCondition,
+ ...existsFilterClause.additionalOnConditions,
+ ];
+
+ if (existsFilterClause.conditionSql.length > 0) {
+ conditions.push(existsFilterClause.conditionSql);
+ }
+
+ if (
+ !includeDeleted &&
+ existsFilterClause.targetTableShape.hasDeletedAtColumn
+ ) {
+ conditions.push(
+ `${quoteColumn(existsFilterClause.alias, 'deletedAt')} IS NULL`,
+ );
+ }
+
+ const tableExpression = `${escapeIdentifier(
+ existsFilterClause.targetTableShape.schemaName,
+ )}.${escapeIdentifier(existsFilterClause.targetTableShape.tableName)}`;
+
+ return `EXISTS (SELECT 1 FROM ${tableExpression} AS ${escapeIdentifier(
+ existsFilterClause.alias,
+ )} WHERE ${conditions.join(' AND ')})`;
+};
+
+export const substituteExistsFilterTokens = ({
+ expression,
+ existsFilterClauses,
+ includeDeleted,
+}: {
+ expression: string;
+ existsFilterClauses: ExistsFilterClause[];
+ includeDeleted: boolean;
+}): string =>
+ existsFilterClauses.reduce(
+ (substituted, existsFilterClause) =>
+ substituted
+ .split(existsFilterClause.token)
+ .join(renderExistsFilter(existsFilterClause, includeDeleted)),
+ expression,
+ );
+
export const buildWhereExpression = (
state: SelectStatementState,
{
includeSoftDeletePredicate = true,
- }: { includeSoftDeletePredicate?: boolean } = {},
+ substituteExistsFilters = true,
+ }: {
+ includeSoftDeletePredicate?: boolean;
+ substituteExistsFilters?: boolean;
+ } = {},
): string => {
- const userExpression = quoteQualifiedAliasReferences(
+ const renderedWhereClauses = quoteQualifiedAliasReferences(
renderUserWhereExpression(state.whereClauses),
collectStatementAliases(state),
);
+ const userExpression = substituteExistsFilters
+ ? substituteExistsFilterTokens({
+ expression: renderedWhereClauses,
+ existsFilterClauses: state.existsFilterClauses,
+ includeDeleted: state.includeDeleted,
+ })
+ : renderedWhereClauses;
+
const shouldAddSoftDeletePredicate =
includeSoftDeletePredicate &&
!state.includeDeleted &&