admin/twenty
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

[permissions] Remove raw queries and restrict its usage (#12360)

Browse Source 
Closes https://github.com/twentyhq/core-team-issues/issues/748

In the frame of the work on permissions we

- remove all raw queries possible to use repositories instead
- forbid usage workspaceDataSource.executeRawQueries()
- restrict usage of workspaceDataSource.query() to force developers to
pass on shouldBypassPermissionChecks to use it.

---------

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>
This commit is contained in:
Marie
2025-06-02 10:53:51 +02:00
committed by GitHub
parent 1ef7b7a474
commit 9706f0df13
49 changed files with 495 additions and 754 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-condition.parser.ts
View File

@ -1,13 +1,9 @@
import {
Brackets,
NotBrackets,
SelectQueryBuilder,
WhereExpressionBuilder,
} from 'typeorm';
import { Brackets, NotBrackets, WhereExpressionBuilder } from 'typeorm';
import { ObjectRecordFilter } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metadata-map';
import { WorkspaceSelectQueryBuilder } from 'src/engine/twenty-orm/repository/workspace-select-query-builder';
import { GraphqlQueryFilterFieldParser } from './graphql-query-filter-field.parser';
@ -30,11 +26,11 @@ export class GraphqlQueryFilterConditionParser {
public parse(
// eslint-disable-next-line @typescript-eslint/no-explicit-any
queryBuilder: SelectQueryBuilder<any>,
queryBuilder: WorkspaceSelectQueryBuilder<any>,
objectNameSingular: string,
filter: Partial<ObjectRecordFilter>,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
): SelectQueryBuilder<any> {
): WorkspaceSelectQueryBuilder<any> {
if (!filter || Object.keys(filter).length === 0) {
return queryBuilder;
}

20
packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser.ts
View File

@ -1,9 +1,4 @@
import {
FindOptionsWhere,
ObjectLiteral,
OrderByCondition,
SelectQueryBuilder,
} from 'typeorm';
import { FindOptionsWhere, ObjectLiteral, OrderByCondition } from 'typeorm';
import {
ObjectRecordFilter,
@ -24,6 +19,7 @@ import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metada
import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
import { WorkspaceSelectQueryBuilder } from 'src/engine/twenty-orm/repository/workspace-select-query-builder';
export class GraphqlQueryParser {
private fieldMetadataMapByName: FieldMetadataMap;
@ -51,11 +47,11 @@ export class GraphqlQueryParser {
public applyFilterToBuilder(
// eslint-disable-next-line @typescript-eslint/no-explicit-any
queryBuilder: SelectQueryBuilder<any>,
queryBuilder: WorkspaceSelectQueryBuilder<any>,
objectNameSingular: string,
recordFilter: Partial<ObjectRecordFilter>,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
): SelectQueryBuilder<any> {
): WorkspaceSelectQueryBuilder<any> {
return this.filterConditionParser.parse(
queryBuilder,
objectNameSingular,
@ -65,10 +61,10 @@ export class GraphqlQueryParser {
public applyDeletedAtToBuilder(
// eslint-disable-next-line @typescript-eslint/no-explicit-any
queryBuilder: SelectQueryBuilder<any>,
queryBuilder: WorkspaceSelectQueryBuilder<any>,
recordFilter: Partial<ObjectRecordFilter>,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
): SelectQueryBuilder<any> {
): WorkspaceSelectQueryBuilder<any> {
if (this.checkForDeletedAtFilter(recordFilter)) {
queryBuilder.withDeleted();
}
@ -104,12 +100,12 @@ export class GraphqlQueryParser {
public applyOrderToBuilder(
// eslint-disable-next-line @typescript-eslint/no-explicit-any
queryBuilder: SelectQueryBuilder<any>,
queryBuilder: WorkspaceSelectQueryBuilder<any>,
orderBy: ObjectRecordOrderBy,
objectNameSingular: string,
isForwardPagination = true,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
): SelectQueryBuilder<any> {
): WorkspaceSelectQueryBuilder<any> {
const parsedOrderBys = this.orderFieldParser.parse(
orderBy,
objectNameSingular,

3
packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/process-aggregate.helper.ts
View File

@ -5,6 +5,7 @@ import { SelectQueryBuilder } from 'typeorm';
import { AggregateOperations } from 'src/engine/api/graphql/graphql-query-runner/constants/aggregate-operations.constant';
import { AggregationField } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';
import { WorkspaceSelectQueryBuilder } from 'src/engine/twenty-orm/repository/workspace-select-query-builder';
import { formatColumnNamesFromCompositeFieldAndSubfields } from 'src/engine/twenty-orm/utils/format-column-names-from-composite-field-and-subfield.util';
@Injectable()
@ -15,7 +16,7 @@ export class ProcessAggregateHelper {
}: {
selectedAggregatedFields: Record<string, AggregationField>;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
queryBuilder: SelectQueryBuilder<any>;
queryBuilder: WorkspaceSelectQueryBuilder<any>;
}) => {
queryBuilder.select([]);

9
packages/twenty-server/src/engine/api/graphql/graphql-query-runner/helpers/process-nested-relations-v2.helper.ts
View File

@ -1,11 +1,7 @@
import { Injectable } from '@nestjs/common';
import { FieldMetadataType } from 'twenty-shared/types';
import {
FindOptionsRelations,
ObjectLiteral,
SelectQueryBuilder,
} from 'typeorm';
import { FindOptionsRelations, ObjectLiteral } from 'typeorm';
import { ObjectRecord } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
@ -22,6 +18,7 @@ import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/typ
import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
import { WorkspaceDataSource } from 'src/engine/twenty-orm/datasource/workspace.datasource';
import { WorkspaceSelectQueryBuilder } from 'src/engine/twenty-orm/repository/workspace-select-query-builder';
import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
@ -269,7 +266,7 @@ export class ProcessNestedRelationsV2Helper {
sourceFieldName,
}: {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
referenceQueryBuilder: SelectQueryBuilder<any>;
referenceQueryBuilder: WorkspaceSelectQueryBuilder<any>;
column: string;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
ids: any[];

3
packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-runner.module.ts
View File

@ -13,9 +13,7 @@ import { FileModule } from 'src/engine/core-modules/file/file.module';
import { RecordPositionModule } from 'src/engine/core-modules/record-position/record-position.module';
import { RecordTransformerModule } from 'src/engine/core-modules/record-transformer/record-transformer.module';
import { TelemetryModule } from 'src/engine/core-modules/telemetry/telemetry.module';
import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
import { EntityEventsToDbListener } from './listeners/entity-events-to-db.listener';
@ -25,7 +23,6 @@ import { EntityEventsToDbListener } from './listeners/entity-events-to-db.listen
WorkspaceQueryBuilderModule,
WorkspaceDataSourceModule,
WorkspaceQueryHookModule,
ObjectMetadataRepositoryModule.forFeature([WorkspaceMemberWorkspaceEntity]),
TypeOrmModule.forFeature([FeatureFlag], 'core'),
AuditModule,
TelemetryModule,

11
packages/twenty-server/src/engine/api/rest/core/interfaces/rest-api-base.handler.ts
View File

@ -3,7 +3,7 @@ import { BadRequestException, Inject } from '@nestjs/common';
import { Request } from 'express';
import { FieldMetadataType } from 'twenty-shared/types';
import { capitalize, isDefined } from 'twenty-shared/utils';
import { In, ObjectLiteral, SelectQueryBuilder } from 'typeorm';
import { In, ObjectLiteral } from 'typeorm';
import {
ObjectRecord,
@ -12,6 +12,7 @@ import {
import { GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
import { ApiEventEmitterService } from 'src/engine/api/graphql/graphql-query-runner/services/api-event-emitter.service';
import { encodeCursor } from 'src/engine/api/graphql/graphql-query-runner/utils/cursors.util';
import { CoreQueryBuilderFactory } from 'src/engine/api/rest/core/query-builder/core-query-builder.factory';
import { GetVariablesFactory } from 'src/engine/api/rest/core/query-builder/factories/get-variables.factory';
import { parseCorePath } from 'src/engine/api/rest/core/query-builder/utils/path-parsers/parse-core-path.utils';
@ -21,18 +22,18 @@ import {
DepthInputFactory,
MAX_DEPTH,
} from 'src/engine/api/rest/input-factories/depth-input.factory';
import { computeCursorArgFilter } from 'src/engine/api/utils/compute-cursor-arg-filter.utils';
import { CreatedByFromAuthContextService } from 'src/engine/core-modules/actor/services/created-by-from-auth-context.service';
import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
import { RecordInputTransformerService } from 'src/engine/core-modules/record-transformer/services/record-input-transformer.service';
import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
import { WorkspacePermissionsCacheService } from 'src/engine/metadata-modules/workspace-permissions-cache/workspace-permissions-cache.service';
import { WorkspaceSelectQueryBuilder } from 'src/engine/twenty-orm/repository/workspace-select-query-builder';
import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { formatResult as formatGetManyData } from 'src/engine/twenty-orm/utils/format-result.util';
import { encodeCursor } from 'src/engine/api/graphql/graphql-query-runner/utils/cursors.util';
import { computeCursorArgFilter } from 'src/engine/api/utils/compute-cursor-arg-filter.utils';
import { CreatedByFromAuthContextService } from 'src/engine/core-modules/actor/services/created-by-from-auth-context.service';
export interface PageInfo {
hasNextPage?: boolean;
@ -392,7 +393,7 @@ export abstract class RestApiBaseHandler {
}
async getTotalCount(
query: SelectQueryBuilder<ObjectLiteral>,
query: WorkspaceSelectQueryBuilder<ObjectLiteral>,
): Promise<number> {
const countQuery = query.clone();

8
packages/twenty-server/src/engine/core-modules/audit/jobs/audit-job.module.ts
View File

@ -2,16 +2,10 @@ import { Module } from '@nestjs/common';
import { AuditModule } from 'src/engine/core-modules/audit/audit.module';
import { CreateAuditLogFromInternalEvent } from 'src/engine/core-modules/audit/jobs/create-audit-log-from-internal-event';
import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
import { TimelineActivityModule } from 'src/modules/timeline/timeline-activity.module';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Module({
imports: [
ObjectMetadataRepositoryModule.forFeature([WorkspaceMemberWorkspaceEntity]),
TimelineActivityModule,
AuditModule,
],
imports: [TimelineActivityModule, AuditModule],
providers: [CreateAuditLogFromInternalEvent],
})
export class AuditJobModule {}

4
packages/twenty-server/src/engine/core-modules/record-position/record-position.module.ts
View File

@ -1,11 +1,11 @@
import { Module } from '@nestjs/common';
import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
import { RecordPositionService } from './services/record-position.service';
@Module({
imports: [WorkspaceDataSourceModule],
imports: [TwentyORMModule],
providers: [RecordPositionService],
exports: [RecordPositionService],
})

25
packages/twenty-server/src/engine/core-modules/record-position/services/__tests__/record-position.service.spec.ts
View File

@ -1,24 +1,31 @@
import { Test, TestingModule } from '@nestjs/testing';
import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
describe('RecordPositionService', () => {
let workspaceDataSourceService;
let twentyORMGlobalManager: jest.Mocked<TwentyORMGlobalManager>;
let mockRepository: any;
let service: RecordPositionService;
beforeEach(async () => {
workspaceDataSourceService = {
getSchemaName: jest.fn().mockReturnValue('schemaName'),
executeRawQuery: jest.fn().mockResolvedValue([{ position: 1 }]),
mockRepository = {
findOneBy: jest.fn(),
update: jest.fn(),
minimum: jest.fn().mockResolvedValue(1),
maximum: jest.fn().mockResolvedValue(1),
};
twentyORMGlobalManager = {
getRepositoryForWorkspace: jest.fn().mockResolvedValue(mockRepository),
} as unknown as jest.Mocked<TwentyORMGlobalManager>;
const module: TestingModule = await Test.createTestingModule({
providers: [
RecordPositionService,
{
provide: WorkspaceDataSourceService,
useValue: workspaceDataSourceService,
provide: TwentyORMGlobalManager,
useValue: twentyORMGlobalManager,
},
],
}).compile();
@ -30,7 +37,7 @@ describe('RecordPositionService', () => {
expect(service).toBeDefined();
});
describe('create', () => {
describe('buildRecordPosition', () => {
const objectMetadata = { isCustom: false, nameSingular: 'company' };
const workspaceId = 'workspaceId';

136
packages/twenty-server/src/engine/core-modules/record-position/services/record-position.service.ts
View File

@ -1,13 +1,6 @@
import { Injectable } from '@nestjs/common';
import { isDefined } from 'class-validator';
import {
RecordPositionQueryArgs,
RecordPositionQueryType,
} from 'src/engine/core-modules/record-position/types/record-position-query.type';
import { buildRecordPositionQuery } from 'src/engine/core-modules/record-position/utils/build-record-position-query.util';
import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
export type RecordPositionServiceCreateArgs = {
value: number | 'first' | 'last';
@ -19,7 +12,7 @@ export type RecordPositionServiceCreateArgs = {
@Injectable()
export class RecordPositionService {
constructor(
private readonly workspaceDataSourceService: WorkspaceDataSourceService,
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
) {}
async buildRecordPosition({
@ -28,62 +21,101 @@ export class RecordPositionService {
workspaceId,
index = 0,
}: RecordPositionServiceCreateArgs): Promise<number> {
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
if (typeof value === 'number') {
return value;
}
if (value === 'first') {
const recordWithMinPosition =
await this.createAndExecuteRecordPositionQuery(
{
recordPositionQueryType: RecordPositionQueryType.FIND_MIN_POSITION,
},
objectMetadata,
dataSourceSchema,
workspaceId,
);
return isDefined(recordWithMinPosition?.position)
? recordWithMinPosition.position - index - 1
: 1;
}
const recordWithMaxPosition =
await this.createAndExecuteRecordPositionQuery(
{
recordPositionQueryType: RecordPositionQueryType.FIND_MAX_POSITION,
},
const recordWithMinPosition = await this.findMinPosition(
objectMetadata,
dataSourceSchema,
workspaceId,
);
return isDefined(recordWithMaxPosition?.position)
? recordWithMaxPosition.position + index + 1
: 1;
}
return recordWithMinPosition !== null
? recordWithMinPosition - index - 1
: 1;
}
private async createAndExecuteRecordPositionQuery(
recordPositionQueryArgs: RecordPositionQueryArgs,
objectMetadata: { isCustom: boolean; nameSingular: string },
dataSourceSchema: string,
workspaceId: string,
) {
const [query, params] = buildRecordPositionQuery(
recordPositionQueryArgs,
const recordWithMaxPosition = await this.findMaxPosition(
objectMetadata,
dataSourceSchema,
);
const records = await this.workspaceDataSourceService.executeRawQuery(
query,
params,
workspaceId,
);
return records?.[0];
return recordWithMaxPosition !== null
? recordWithMaxPosition + index + 1
: 1;
}
async findByPosition(
positionValue: number | null,
objectMetadata: { isCustom: boolean; nameSingular: string },
workspaceId: string,
): Promise<{ id: string; position: number } | null> {
const repository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
objectMetadata.nameSingular,
{
shouldBypassPermissionChecks: true,
},
);
const record = await repository.findOneBy({
position: positionValue,
});
return record ? { id: record.id, position: record.position } : null;
}
async updatePosition(
recordId: string,
positionValue: number,
objectMetadata: { isCustom: boolean; nameSingular: string },
workspaceId: string,
): Promise<void> {
const repository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
objectMetadata.nameSingular,
{
shouldBypassPermissionChecks: true,
},
);
await repository.update(recordId, {
position: positionValue,
});
}
private async findMinPosition(
objectMetadata: { isCustom: boolean; nameSingular: string },
workspaceId: string,
): Promise<number | null> {
const repository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
objectMetadata.nameSingular,
{
shouldBypassPermissionChecks: true,
},
);
return repository.minimum('position');
}
private async findMaxPosition(
objectMetadata: { isCustom: boolean; nameSingular: string },
workspaceId: string,
): Promise<number | null> {
const repository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
objectMetadata.nameSingular,
{
shouldBypassPermissionChecks: true,
},
);
return repository.maximum('position');
}
}

72
packages/twenty-server/src/engine/core-modules/record-position/utils/__tests__/build-record-position-query.util.spec.ts
View File

@ -1,72 +0,0 @@
import { RecordPositionQueryType } from 'src/engine/core-modules/record-position/types/record-position-query.type';
import { buildRecordPositionQuery } from 'src/engine/core-modules/record-position/utils/build-record-position-query.util';
describe('buildRecordPositionQuery', () => {
const objectMetadataItem = {
isCustom: false,
nameSingular: 'company',
};
const dataSourceSchema = 'workspace_test';
it('should return query and params for FIND_BY_POSITION', async () => {
const positionValue = 1;
const queryType = RecordPositionQueryType.FIND_BY_POSITION;
const [query, params] = buildRecordPositionQuery(
{ positionValue, recordPositionQueryType: queryType },
objectMetadataItem,
dataSourceSchema,
);
expect(query).toEqual(
`SELECT id, position FROM ${dataSourceSchema}."${objectMetadataItem.nameSingular}"
WHERE "position" = $1`,
);
expect(params).toEqual([positionValue]);
});
it('should return query and params for FIND_MIN_POSITION', async () => {
const queryType = RecordPositionQueryType.FIND_MIN_POSITION;
const [query, params] = buildRecordPositionQuery(
{ recordPositionQueryType: queryType },
objectMetadataItem,
dataSourceSchema,
);
expect(query).toEqual(
`SELECT MIN(position) as position FROM ${dataSourceSchema}."${objectMetadataItem.nameSingular}"`,
);
expect(params).toEqual([]);
});
it('should return query and params for FIND_MAX_POSITION', async () => {
const queryType = RecordPositionQueryType.FIND_MAX_POSITION;
const [query, params] = buildRecordPositionQuery(
{ recordPositionQueryType: queryType },
objectMetadataItem,
dataSourceSchema,
);
expect(query).toEqual(
`SELECT MAX(position) as position FROM ${dataSourceSchema}."${objectMetadataItem.nameSingular}"`,
);
expect(params).toEqual([]);
});
it('should return query and params for UPDATE_POSITION', async () => {
const positionValue = 1;
const recordId = '1';
const queryType = RecordPositionQueryType.UPDATE_POSITION;
const [query, params] = buildRecordPositionQuery(
{ positionValue, recordId, recordPositionQueryType: queryType },
objectMetadataItem,
dataSourceSchema,
);
expect(query).toEqual(
`UPDATE ${dataSourceSchema}."${objectMetadataItem.nameSingular}"
SET "position" = $1
WHERE "id" = $2`,
);
expect(params).toEqual([positionValue, recordId]);
});
});

91
packages/twenty-server/src/engine/core-modules/record-position/utils/build-record-position-query.util.ts
View File

@ -1,91 +0,0 @@
import {
FindByPositionQueryArgs,
RecordPositionQueryArgs,
RecordPositionQueryType,
UpdatePositionQueryArgs,
} from 'src/engine/core-modules/record-position/types/record-position-query.type';
import { computeTableName } from 'src/engine/utils/compute-table-name.util';
type RecordPositionQuery = string;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
type RecordPositionQueryParams = any[];
export const buildRecordPositionQuery = (
recordPositionQueryArgs: RecordPositionQueryArgs,
objectMetadata: { isCustom: boolean; nameSingular: string },
dataSourceSchema: string,
): [RecordPositionQuery, RecordPositionQueryParams] => {
const tableName = computeTableName(
objectMetadata.nameSingular,
objectMetadata.isCustom,
);
switch (recordPositionQueryArgs.recordPositionQueryType) {
case RecordPositionQueryType.FIND_BY_POSITION:
return buildFindByPositionQuery(
recordPositionQueryArgs satisfies FindByPositionQueryArgs,
tableName,
dataSourceSchema,
);
case RecordPositionQueryType.FIND_MIN_POSITION:
return buildFindMinPositionQuery(tableName, dataSourceSchema);
case RecordPositionQueryType.FIND_MAX_POSITION:
return buildFindMaxPositionQuery(tableName, dataSourceSchema);
case RecordPositionQueryType.UPDATE_POSITION:
return buildUpdatePositionQuery(
recordPositionQueryArgs satisfies UpdatePositionQueryArgs,
tableName,
dataSourceSchema,
);
default:
throw new Error('Invalid RecordPositionQueryType');
}
};
const buildFindByPositionQuery = (
{ positionValue }: FindByPositionQueryArgs,
name: string,
dataSourceSchema: string,
): [RecordPositionQuery, RecordPositionQueryParams] => {
const positionStringParam = positionValue ? '= $1' : 'IS NULL';
return [
`SELECT id, position FROM ${dataSourceSchema}."${name}"
WHERE "position" ${positionStringParam}`,
positionValue ? [positionValue] : [],
];
};
const buildFindMaxPositionQuery = (
name: string,
dataSourceSchema: string,
): [RecordPositionQuery, RecordPositionQueryParams] => {
return [
`SELECT MAX(position) as position FROM ${dataSourceSchema}."${name}"`,
[],
];
};
const buildFindMinPositionQuery = (
name: string,
dataSourceSchema: string,
): [RecordPositionQuery, RecordPositionQueryParams] => {
return [
`SELECT MIN(position) as position FROM ${dataSourceSchema}."${name}"`,
[],
];
};
const buildUpdatePositionQuery = (
{ recordId, positionValue }: UpdatePositionQueryArgs,
name: string,
dataSourceSchema: string,
): [RecordPositionQuery, RecordPositionQueryParams] => {
return [
`UPDATE ${dataSourceSchema}."${name}"
SET "position" = $1
WHERE "id" = $2`,
[positionValue, recordId],
];
};

2
packages/twenty-server/src/engine/metadata-modules/permissions/permissions.exception.ts
View File

@ -31,6 +31,8 @@ export enum PermissionsExceptionCode {
ROLE_NOT_EDITABLE = 'ROLE_NOT_EDITABLE',
DEFAULT_ROLE_CANNOT_BE_DELETED = 'DEFAULT_ROLE_CANNOT_BE_DELETED',
NO_PERMISSIONS_FOUND_IN_DATASOURCE = 'NO_PERMISSIONS_FOUND_IN_DATASOURCE',
METHOD_NOT_ALLOWED = 'METHOD_NOT_ALLOWED',
RAW_SQL_NOT_ALLOWED = 'RAW_SQL_NOT_ALLOWED',
}
export enum PermissionsExceptionMessage {

2
packages/twenty-server/src/engine/metadata-modules/permissions/utils/permission-graphql-api-exception-handler.util.ts
View File

@ -38,6 +38,8 @@ export const permissionGraphqlApiExceptionHandler = (
case PermissionsExceptionCode.UNKNOWN_REQUIRED_PERMISSION:
case PermissionsExceptionCode.NO_ROLE_FOUND_FOR_USER_WORKSPACE:
case PermissionsExceptionCode.NO_PERMISSIONS_FOUND_IN_DATASOURCE:
case PermissionsExceptionCode.METHOD_NOT_ALLOWED:
case PermissionsExceptionCode.RAW_SQL_NOT_ALLOWED:
throw error;
default: {
const _exhaustiveCheck: never = error.code;

1
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-server.service.ts
View File

@ -271,6 +271,7 @@ export class RemoteServerService<T extends RemoteServerType> {
const [parameters, rawQuery] =
buildUpdateRemoteServerRawQuery(remoteServerToUpdate);
// TO DO: executeRawQuery is deprecated and will throw
const updateResult = await this.workspaceDataSourceService.executeRawQuery(
rawQuery,
parameters,

1
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-table/utils/fetch-table-columns.util.ts
View File

@ -8,6 +8,7 @@ export const fetchTableColumns = async (
): Promise<PostgresTableSchemaColumn[]> => {
const schemaName = workspaceDataSourceService.getSchemaName(workspaceId);
// TODO: executeRawQuery is deprecated and will throw
const res = await workspaceDataSourceService.executeRawQuery(
`SELECT column_name, data_type, udt_name
FROM information_schema.columns

3
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-table/utils/get-remote-table-local-name.util.ts
View File

@ -1,11 +1,11 @@
import { singular } from 'pluralize';
import { DataSource } from 'typeorm';
import { camelCase } from 'src/utils/camel-case';
import {
RemoteTableException,
RemoteTableExceptionCode,
} from 'src/engine/metadata-modules/remote-server/remote-table/remote-table.exception';
import { camelCase } from 'src/utils/camel-case';
const MAX_SUFFIX = 10;
@ -19,6 +19,7 @@ const isNameAvailable = async (
workspaceSchemaName: string,
workspaceDataSource: DataSource,
) => {
// TO DO workspaceDataSource.query method is not allowed, this will throw
const numberOfTablesWithSameName = +(
await workspaceDataSource.query(
`SELECT count(table_name) FROM information_schema.tables WHERE table_name LIKE '${tableName}' AND table_schema IN ('core', 'metadata', '${workspaceSchemaName}')`,

2
packages/twenty-server/src/engine/object-metadata-repository/metadata-to-repository.mapping.ts
View File

@ -1,9 +1,7 @@
import { BlocklistRepository } from 'src/modules/blocklist/repositories/blocklist.repository';
import { TimelineActivityRepository } from 'src/modules/timeline/repositiories/timeline-activity.repository';
import { WorkspaceMemberRepository } from 'src/modules/workspace-member/repositories/workspace-member.repository';
export const metadataToRepositoryMapping = {
BlocklistWorkspaceEntity: BlocklistRepository,
TimelineActivityWorkspaceEntity: TimelineActivityRepository,
WorkspaceMemberWorkspaceEntity: WorkspaceMemberRepository,
};

13
packages/twenty-server/src/engine/object-metadata-repository/object-metadata-repository.module.ts
View File

@ -3,8 +3,9 @@ import { DynamicModule, Global, Module, Provider } from '@nestjs/common';
import { capitalize } from 'twenty-shared/utils';
import { metadataToRepositoryMapping } from 'src/engine/object-metadata-repository/metadata-to-repository.mapping';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
import { convertClassNameToObjectMetadataName } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/convert-class-to-object-metadata-name.util';
@Global()
@ -25,18 +26,16 @@ export class ObjectMetadataRepositoryModule {
provide: `${capitalize(
convertClassNameToObjectMetadataName(objectMetadata.name),
)}Repository`,
useFactory: (
workspaceDataSourceService: WorkspaceDataSourceService,
) => {
return new repositoryClass(workspaceDataSourceService);
useFactory: (twentyORMGlobalManager: TwentyORMGlobalManager) => {
return new repositoryClass(twentyORMGlobalManager);
},
inject: [WorkspaceDataSourceService],
inject: [TwentyORMGlobalManager],
};
});
return {
module: ObjectMetadataRepositoryModule,
imports: [WorkspaceDataSourceModule],
imports: [WorkspaceDataSourceModule, TwentyORMModule],
providers: [...providers],
exports: providers,
};

24
packages/twenty-server/src/engine/twenty-orm/datasource/workspace.datasource.ts
View File

@ -11,6 +11,10 @@ import {
import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
import { WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';
import {
PermissionsException,
PermissionsExceptionCode,
} from 'src/engine/metadata-modules/permissions/permissions.exception';
import { WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
import { WorkspaceQueryRunner } from 'src/engine/twenty-orm/query-runner/workspace-query-runner';
import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
@ -79,6 +83,26 @@ export class WorkspaceDataSource extends DataSource {
return queryRunner as any as WorkspaceQueryRunner;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
override query<T = any>(
query: string,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
parameters?: any[],
queryRunner?: QueryRunner,
options?: {
shouldBypassPermissionChecks?: boolean;
},
): Promise<T> {
if (!options?.shouldBypassPermissionChecks) {
throw new PermissionsException(
'Method not allowed because permissions are not implemented at datasource level.',
PermissionsExceptionCode.METHOD_NOT_ALLOWED,
);
}
return super.query(query, parameters, queryRunner);
}
setRolesPermissionsVersion(rolesPermissionsVersion: string) {
this.rolesPermissionsVersion = rolesPermissionsVersion;
}

19
packages/twenty-server/src/engine/twenty-orm/entity-manager/workspace-entity-manager.ts
View File

@ -406,15 +406,6 @@ export class WorkspaceEntityManager extends EntityManager {
return this.connection.getMetadata(entity.constructor).name;
}
// Forbidden methods
// eslint-disable-next-line @typescript-eslint/no-explicit-any
override query<T = any>(_query: string, _parameters?: any[]): Promise<T> {
throw new Error('Method not allowed.');
}
// Not in use methods - duplicated from TypeORM's EntityManager to use our createQueryBuilder
override find<Entity extends ObjectLiteral>(
entityClass: EntityTarget<Entity>,
options?: FindManyOptions<Entity>,
@ -1098,4 +1089,14 @@ export class WorkspaceEntityManager extends EntityManager {
return super.decrement(target, criteria, propertyPath, value);
}
// Forbidden methods
// eslint-disable-next-line @typescript-eslint/no-explicit-any
override query<T = any>(_query: string, _parameters?: any[]): Promise<T> {
throw new PermissionsException(
'Method not allowed.',
PermissionsExceptionCode.RAW_SQL_NOT_ALLOWED,
);
}
}

9
packages/twenty-server/src/engine/twenty-orm/repository/workspace.repository.ts
View File

@ -24,6 +24,10 @@ import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/
import { WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';
import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
import {
PermissionsException,
PermissionsExceptionCode,
} from 'src/engine/metadata-modules/permissions/permissions.exception';
import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
import { getObjectMetadataMapItemByNameSingular } from 'src/engine/metadata-modules/utils/get-object-metadata-map-item-by-name-singular.util';
import { WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
@ -890,7 +894,10 @@ export class WorkspaceRepository<
* DEPRECATED AND RESTRICTED METHODS
*/
override async query(): Promise<unknown> {
throw new Error('Method not allowed.');
throw new PermissionsException(
'Method not allowed.',
PermissionsExceptionCode.RAW_SQL_NOT_ALLOWED,
);
}
override async findByIds(): Promise<T[]> {

28
packages/twenty-server/src/engine/workspace-datasource/workspace-datasource.service.ts
View File

@ -4,6 +4,10 @@ import { DataSource, EntityManager } from 'typeorm';
import { TypeORMService } from 'src/database/typeorm/typeorm.service';
import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
import {
PermissionsException,
PermissionsExceptionCode,
} from 'src/engine/metadata-modules/permissions/permissions.exception';
@Injectable()
export class WorkspaceDataSourceService {
@ -99,24 +103,16 @@ export class WorkspaceDataSourceService {
}
public async executeRawQuery(
query: string,
_query: string,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
parameters: any[] = [],
workspaceId: string,
transactionManager?: EntityManager,
_parameters: any[] = [],
_workspaceId: string,
_transactionManager?: EntityManager,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
): Promise<any> {
try {
if (transactionManager) {
return await transactionManager.query(query, parameters);
}
const dataSource = await this.connectToMainDataSource();
return await dataSource.query(query, parameters);
} catch (error) {
throw new Error(
`Error executing raw query for workspace ${workspaceId}: ${error.message}`,
);
}
throw new PermissionsException(
'Method not allowed as permissions are not handled at datasource level.',
PermissionsExceptionCode.METHOD_NOT_ALLOWED,
);
}
}

130
packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/commands/convert-record-positions-to-integers.command.ts
View File

@ -1,130 +0,0 @@
import { Logger } from '@nestjs/common';
import { InjectDataSource } from '@nestjs/typeorm';
import { Command, CommandRunner, Option } from 'nest-commander';
import { DataSource } from 'typeorm';
import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
interface RunCommandOptions {
workspaceId?: string;
}
@Command({
name: 'workspace:convert-record-positions-to-integers',
description: 'Convert record positions to integers',
})
export class ConvertRecordPositionsToIntegers extends CommandRunner {
private readonly logger = new Logger(ConvertRecordPositionsToIntegers.name);
constructor(
@InjectDataSource('metadata')
private readonly metadataDataSource: DataSource,
private readonly workspaceDataSourceService: WorkspaceDataSourceService,
) {
super();
}
async run(_passedParam: string[], options: RunCommandOptions): Promise<void> {
const queryRunner = this.metadataDataSource.createQueryRunner();
const workspaceId = options.workspaceId;
if (!workspaceId || typeof workspaceId !== 'string') {
this.logger.error('Workspace id is required');
return;
}
const customObjectMetadataCollection = await this.metadataDataSource
.getRepository(ObjectMetadataEntity)
.findBy({
workspaceId,
isCustom: true,
});
const customObjectTableNames = customObjectMetadataCollection.map(
(metadata) => metadata.nameSingular,
);
await queryRunner.connect();
await queryRunner.startTransaction();
const transactionManager = queryRunner.manager;
this.logger.log('Converting record positions to integers');
try {
await this.convertRecordPositionsToIntegers(
customObjectTableNames,
workspaceId,
transactionManager,
);
await queryRunner.commitTransaction();
} catch (error) {
await queryRunner.rollbackTransaction();
this.logger.error('Error converting record positions to integers', error);
} finally {
await queryRunner.release();
this.logger.log('Record positions converted to integers');
}
}
private async convertRecordPositionsToIntegers(
customObjectTableNames: string[],
workspaceId: string,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
transactionManager: any,
): Promise<void> {
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
for (const tableName of ['company', 'person', 'opportunity']) {
await this.convertRecordPositionsToIntegersForTable(
tableName,
dataSourceSchema,
workspaceId,
transactionManager,
);
}
for (const tableName of customObjectTableNames) {
await this.convertRecordPositionsToIntegersForTable(
`_${tableName}`,
dataSourceSchema,
workspaceId,
transactionManager,
);
}
}
private async convertRecordPositionsToIntegersForTable(
tableName: string,
dataSourceSchema: string,
workspaceId: string,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
transactionManager: any,
): Promise<void> {
await this.workspaceDataSourceService.executeRawQuery(
`UPDATE ${dataSourceSchema}."${tableName}" SET position = subquery.position
FROM (
SELECT id, ROW_NUMBER() OVER (ORDER BY position) as position
FROM ${dataSourceSchema}."${tableName}"
) as subquery
WHERE ${dataSourceSchema}."${tableName}".id = subquery.id`,
[],
workspaceId,
transactionManager,
);
}
@Option({
flags: '-w, --workspace-id [workspace_id]',
description: 'workspace id',
required: true,
})
parseWorkspaceId(value: string): string {
return value;
}
}

5
packages/twenty-server/src/engine/workspace-manager/workspace-sync-metadata/commands/workspace-sync-metadata-commands.module.ts
View File

@ -7,9 +7,8 @@ import { WorkspaceModule } from 'src/engine/core-modules/workspace/workspace.mod
import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
import { WorkspaceHealthModule } from 'src/engine/workspace-manager/workspace-health/workspace-health.module';
import { ConvertRecordPositionsToIntegers } from 'src/engine/workspace-manager/workspace-sync-metadata/commands/convert-record-positions-to-integers.command';
import { WorkspaceSyncMetadataModule } from 'src/engine/workspace-manager/workspace-sync-metadata/workspace-sync-metadata.module';
import { SyncWorkspaceLoggerModule } from 'src/engine/workspace-manager/workspace-sync-metadata/commands/services/sync-workspace-logger.module';
import { WorkspaceSyncMetadataModule } from 'src/engine/workspace-manager/workspace-sync-metadata/workspace-sync-metadata.module';
import { SyncWorkspaceMetadataCommand } from './sync-workspace-metadata.command';
@ -24,7 +23,7 @@ import { SyncWorkspaceMetadataCommand } from './sync-workspace-metadata.command'
TypeOrmModule.forFeature([Workspace], 'core'),
SyncWorkspaceLoggerModule,
],
providers: [SyncWorkspaceMetadataCommand, ConvertRecordPositionsToIntegers],
providers: [SyncWorkspaceMetadataCommand],
exports: [SyncWorkspaceMetadataCommand],
})
export class WorkspaceSyncMetadataCommandsModule {}