The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsnew file mode 100644index 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.tsindex 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/timport { 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.tsindex 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 &&