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

8
packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/blocklist-validation-manager.module.ts
View File

@ -1,16 +1,14 @@
import { Module } from '@nestjs/common';
import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
import { BlocklistValidationService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
import { BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Module({
imports: [
ObjectMetadataRepositoryModule.forFeature([
BlocklistWorkspaceEntity,
WorkspaceMemberWorkspaceEntity,
]),
ObjectMetadataRepositoryModule.forFeature([BlocklistWorkspaceEntity]),
TwentyORMModule,
],
providers: [BlocklistValidationService],
exports: [BlocklistValidationService],

24
packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service.ts
View File

@ -8,10 +8,10 @@ import {
} from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { isDomain } from 'src/engine/utils/is-domain';
import { BlocklistRepository } from 'src/modules/blocklist/repositories/blocklist.repository';
import { BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
import { WorkspaceMemberRepository } from 'src/modules/workspace-member/repositories/workspace-member.repository';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
export type BlocklistItem = Omit<
@ -28,8 +28,7 @@ export class BlocklistValidationService {
constructor(
@InjectObjectMetadataRepository(BlocklistWorkspaceEntity)
private readonly blocklistRepository: BlocklistRepository,
@InjectObjectMetadataRepository(WorkspaceMemberWorkspaceEntity)
private readonly workspaceMemberRepository: WorkspaceMemberRepository,
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
) {}
public async validateBlocklistForCreateMany(
@ -84,8 +83,15 @@ export class BlocklistValidationService {
userId: string,
workspaceId: string,
) {
const workspaceMemberRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
WorkspaceMemberWorkspaceEntity,
);
const currentWorkspaceMember =
await this.workspaceMemberRepository.getByIdOrFail(userId, workspaceId);
await workspaceMemberRepository.findOneByOrFail({
userId,
});
const currentBlocklist =
await this.blocklistRepository.getByWorkspaceMemberId(
@ -126,8 +132,16 @@ export class BlocklistValidationService {
return;
}
const workspaceMemberRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
WorkspaceMemberWorkspaceEntity,
);
const currentWorkspaceMember =
await this.workspaceMemberRepository.getByIdOrFail(userId, workspaceId);
await workspaceMemberRepository.findOneByOrFail({
userId,
});
const currentBlocklist =
await this.blocklistRepository.getByWorkspaceMemberId(

45
packages/twenty-server/src/modules/blocklist/repositories/blocklist.repository.ts
View File

@ -1,46 +1,49 @@
import { Injectable } from '@nestjs/common';
import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
@Injectable()
export class BlocklistRepository {
constructor(
private readonly workspaceDataSourceService: WorkspaceDataSourceService,
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
) {}
public async getById(
id: string,
workspaceId: string,
): Promise<BlocklistWorkspaceEntity | null> {
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
const blocklistItems =
await this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."blocklist" WHERE "id" = $1`,
[id],
const blockListRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
BlocklistWorkspaceEntity,
{
shouldBypassPermissionChecks: true,
},
);
if (!blocklistItems || blocklistItems.length === 0) {
return null;
}
return blocklistItems[0];
return blockListRepository.findOneBy({
id,
});
}
public async getByWorkspaceMemberId(
workspaceMemberId: string,
workspaceId: string,
): Promise<BlocklistWorkspaceEntity[]> {
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
const blockListRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
BlocklistWorkspaceEntity,
{
shouldBypassPermissionChecks: true,
},
);
return await this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."blocklist" WHERE "workspaceMemberId" = $1`,
[workspaceMemberId],
workspaceId,
);
return blockListRepository.find({
where: {
workspaceMemberId,
},
});
}
}

6
packages/twenty-server/src/modules/calendar/calendar-event-import-manager/calendar-event-import-manager.module.ts
View File

@ -31,14 +31,10 @@ import { CalendarCommonModule } from 'src/modules/calendar/common/calendar-commo
import { CalendarChannelSyncStatusService } from 'src/modules/calendar/common/services/calendar-channel-sync-status.service';
import { ConnectedAccountModule } from 'src/modules/connected-account/connected-account.module';
import { RefreshTokensManagerModule } from 'src/modules/connected-account/refresh-tokens-manager/connected-account-refresh-tokens-manager.module';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Module({
imports: [
ObjectMetadataRepositoryModule.forFeature([
BlocklistWorkspaceEntity,
WorkspaceMemberWorkspaceEntity,
]),
ObjectMetadataRepositoryModule.forFeature([BlocklistWorkspaceEntity]),
CalendarEventParticipantManagerModule,
TypeOrmModule.forFeature([FeatureFlag, Workspace], 'core'),
TypeOrmModule.forFeature([DataSourceEntity], 'metadata'),

5
packages/twenty-server/src/modules/calendar/common/query-hooks/calendar-query-hook.module.ts
View File

@ -1,15 +1,10 @@
import { Module } from '@nestjs/common';
import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
import { CalendarEventFindManyPostQueryHook } from 'src/modules/calendar/common/query-hooks/calendar-event/calendar-event-find-many.post-query.hook';
import { CalendarEventFindOnePostQueryHook } from 'src/modules/calendar/common/query-hooks/calendar-event/calendar-event-find-one.post-query.hook';
import { ApplyCalendarEventsVisibilityRestrictionsService } from 'src/modules/calendar/common/query-hooks/calendar-event/services/apply-calendar-events-visibility-restrictions.service';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Module({
imports: [
ObjectMetadataRepositoryModule.forFeature([WorkspaceMemberWorkspaceEntity]),
],
providers: [
ApplyCalendarEventsVisibilityRestrictionsService,
CalendarEventFindOnePostQueryHook,

3
packages/twenty-server/src/modules/contact-creation-manager/contact-creation-manager.module.ts
View File

@ -4,18 +4,15 @@ import { TypeOrmModule } from '@nestjs/typeorm';
import { FeatureFlag } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
import { AutoCompaniesAndContactsCreationCalendarChannelListener } from 'src/modules/contact-creation-manager/listeners/auto-companies-and-contacts-creation-calendar-channel.listener';
import { AutoCompaniesAndContactsCreationMessageChannelListener } from 'src/modules/contact-creation-manager/listeners/auto-companies-and-contacts-creation-message-channel.listener';
import { CreateCompanyAndContactService } from 'src/modules/contact-creation-manager/services/create-company-and-contact.service';
import { CreateCompanyService } from 'src/modules/contact-creation-manager/services/create-company.service';
import { CreateContactService } from 'src/modules/contact-creation-manager/services/create-contact.service';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Module({
imports: [
ObjectMetadataRepositoryModule.forFeature([WorkspaceMemberWorkspaceEntity]),
WorkspaceDataSourceModule,
TypeOrmModule.forFeature([FeatureFlag], 'core'),
TypeOrmModule.forFeature(

18
packages/twenty-server/src/modules/contact-creation-manager/services/create-company-and-contact.service.ts
View File

@ -3,13 +3,12 @@ import { InjectRepository } from '@nestjs/typeorm';
import chunk from 'lodash.chunk';
import compact from 'lodash.compact';
import { Any, Repository } from 'typeorm';
import { Any, DeepPartial, Repository } from 'typeorm';
import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
import { ExceptionHandlerService } from 'src/engine/core-modules/exception-handler/exception-handler.service';
import { FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
@ -22,7 +21,6 @@ import { filterOutSelfAndContactsFromCompanyOrWorkspace } from 'src/modules/cont
import { getDomainNameFromHandle } from 'src/modules/contact-creation-manager/utils/get-domain-name-from-handle.util';
import { getUniqueContactsAndHandles } from 'src/modules/contact-creation-manager/utils/get-unique-contacts-and-handles.util';
import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
import { WorkspaceMemberRepository } from 'src/modules/workspace-member/repositories/workspace-member.repository';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
import { isWorkDomain, isWorkEmail } from 'src/utils/is-work-email';
@ -31,8 +29,6 @@ export class CreateCompanyAndContactService {
constructor(
private readonly createContactService: CreateContactService,
private readonly createCompaniesService: CreateCompanyService,
@InjectObjectMetadataRepository(WorkspaceMemberWorkspaceEntity)
private readonly workspaceMemberRepository: WorkspaceMemberRepository,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
@InjectRepository(ObjectMetadataEntity, 'metadata')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
@ -59,8 +55,16 @@ export class CreateCompanyAndContactService {
},
);
const workspaceMembers =
await this.workspaceMemberRepository.getAllByWorkspaceId(workspaceId);
const workspaceMemberRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
WorkspaceMemberWorkspaceEntity,
{
shouldBypassPermissionChecks: true,
},
);
const workspaceMembers = await workspaceMemberRepository.find();
const contactsToCreateFromOtherCompanies =
filterOutSelfAndContactsFromCompanyOrWorkspace(

6
packages/twenty-server/src/modules/messaging/common/query-hooks/messaging-query-hook.module.ts
View File

@ -1,15 +1,11 @@
import { Module } from '@nestjs/common';
import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
import { ApplyMessagesVisibilityRestrictionsService } from 'src/modules/messaging/common/query-hooks/message/apply-messages-visibility-restrictions.service';
import { MessageFindManyPostQueryHook } from 'src/modules/messaging/common/query-hooks/message/message-find-many.post-query.hook';
import { MessageFindOnePostQueryHook } from 'src/modules/messaging/common/query-hooks/message/message-find-one.post-query.hook';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Module({
imports: [
ObjectMetadataRepositoryModule.forFeature([WorkspaceMemberWorkspaceEntity]),
],
imports: [],
providers: [
ApplyMessagesVisibilityRestrictionsService,
MessageFindOnePostQueryHook,

9
packages/twenty-server/src/modules/timeline/jobs/timeline-job.module.ts
View File

@ -1,17 +1,12 @@
import { Module } from '@nestjs/common';
import { AuditModule } from 'src/engine/core-modules/audit/audit.module';
import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
import { UpsertTimelineActivityFromInternalEvent } from 'src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job';
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, TwentyORMModule],
providers: [UpsertTimelineActivityFromInternalEvent],
})
export class TimelineJobModule {}

21
packages/twenty-server/src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job.ts
View File

@ -2,18 +2,16 @@ import { ObjectRecordNonDestructiveEvent } from 'src/engine/core-modules/event-e
import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event.type';
import { TimelineActivityService } from 'src/modules/timeline/services/timeline-activity.service';
import { WorkspaceMemberRepository } from 'src/modules/workspace-member/repositories/workspace-member.repository';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Processor(MessageQueue.entityEventsToDbQueue)
export class UpsertTimelineActivityFromInternalEvent {
constructor(
@InjectObjectMetadataRepository(WorkspaceMemberWorkspaceEntity)
private readonly workspaceMemberService: WorkspaceMemberRepository,
private readonly timelineActivityService: TimelineActivityService,
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
) {}
@Process(UpsertTimelineActivityFromInternalEvent.name)
@ -22,9 +20,18 @@ export class UpsertTimelineActivityFromInternalEvent {
): Promise<void> {
for (const eventData of workspaceEventBatch.events) {
if (eventData.userId) {
const workspaceMember = await this.workspaceMemberService.getByIdOrFail(
eventData.userId,
workspaceEventBatch.workspaceId,
const workspaceMemberRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceEventBatch.workspaceId,
WorkspaceMemberWorkspaceEntity,
{
shouldBypassPermissionChecks: true,
},
);
const workspaceMember = await workspaceMemberRepository.findOneByOrFail(
{
userId: eventData.userId,
},
);
eventData.workspaceMemberId = workspaceMember.id;

155
packages/twenty-server/src/modules/timeline/repositiories/timeline-activity.repository.ts
View File

@ -1,14 +1,16 @@
import { Injectable } from '@nestjs/common';
import { MoreThan } from 'typeorm';
import { ObjectRecord } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
import { objectRecordDiffMerge } from 'src/engine/core-modules/event-emitter/utils/object-record-diff-merge';
import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
@Injectable()
export class TimelineActivityRepository {
constructor(
private readonly workspaceDataSourceService: WorkspaceDataSourceService,
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
) {}
async upsertOne(
@ -22,11 +24,7 @@ export class TimelineActivityRepository {
linkedRecordId?: string,
linkedObjectMetadataId?: string,
) {
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
const recentTimelineActivity = await this.findRecentTimelineActivity(
dataSourceSchema,
name,
objectName,
recordId,
@ -53,7 +51,6 @@ export class TimelineActivityRepository {
);
return this.updateTimelineActivity(
dataSourceSchema,
recentTimelineActivity[0].id,
newProps,
workspaceMemberId,
@ -62,7 +59,6 @@ export class TimelineActivityRepository {
}
return this.insertTimelineActivity(
dataSourceSchema,
name,
properties,
objectName,
@ -76,7 +72,6 @@ export class TimelineActivityRepository {
}
private async findRecentTimelineActivity(
dataSourceSchema: string,
name: string,
objectName: string,
recordId: string,
@ -84,40 +79,59 @@ export class TimelineActivityRepository {
linkedRecordId: string | undefined,
workspaceId: string,
) {
return this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."timelineActivity"
WHERE "${objectName}Id" = $1
AND "name" = $2
AND "workspaceMemberId" = $3
AND ${
linkedRecordId ? `"linkedRecordId" = $4` : `"linkedRecordId" IS NULL`
}
AND "createdAt" >= NOW() - interval '10 minutes'`,
linkedRecordId
? [recordId, name, workspaceMemberId, linkedRecordId]
: [recordId, name, workspaceMemberId],
workspaceId,
);
const timelineActivityTypeORMRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
'timelineActivity',
{
shouldBypassPermissionChecks: true,
},
);
const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000);
const whereConditions: Record<string, unknown> = {
[objectName + 'Id']: recordId,
name: name,
workspaceMemberId: workspaceMemberId,
createdAt: MoreThan(tenMinutesAgo),
};
if (linkedRecordId) {
whereConditions.linkedRecordId = linkedRecordId;
} else {
whereConditions.linkedRecordId = null;
}
return timelineActivityTypeORMRepository.find({
where: whereConditions,
order: { createdAt: 'DESC' },
take: 1,
});
}
private async updateTimelineActivity(
dataSourceSchema: string,
id: string,
properties: Partial<ObjectRecord>,
workspaceMemberId: string | undefined,
workspaceId: string,
) {
return this.workspaceDataSourceService.executeRawQuery(
`UPDATE ${dataSourceSchema}."timelineActivity"
SET "properties" = $2, "workspaceMemberId" = $3
WHERE "id" = $1`,
[id, properties, workspaceMemberId],
workspaceId,
);
const timelineActivityTypeORMRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
'timelineActivity',
{
shouldBypassPermissionChecks: true,
},
);
return timelineActivityTypeORMRepository.update(id, {
properties: properties,
workspaceMemberId: workspaceMemberId,
});
}
private async insertTimelineActivity(
dataSourceSchema: string,
name: string,
properties: Partial<ObjectRecord>,
objectName: string,
@ -128,21 +142,24 @@ export class TimelineActivityRepository {
linkedObjectMetadataId: string | undefined,
workspaceId: string,
) {
return this.workspaceDataSourceService.executeRawQuery(
`INSERT INTO ${dataSourceSchema}."timelineActivity"
("name", "properties", "workspaceMemberId", "${objectName}Id", "linkedRecordCachedName", "linkedRecordId", "linkedObjectMetadataId")
VALUES ($1, $2, $3, $4, $5, $6, $7)`,
[
name,
properties,
workspaceMemberId,
recordId,
linkedRecordCachedName ?? '',
linkedRecordId,
linkedObjectMetadataId,
],
workspaceId,
);
const timelineActivityTypeORMRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
'timelineActivity',
{
shouldBypassPermissionChecks: true,
},
);
return timelineActivityTypeORMRepository.insert({
name: name,
properties: properties,
workspaceMemberId: workspaceMemberId,
[objectName + 'Id']: recordId,
linkedRecordCachedName: linkedRecordCachedName ?? '',
linkedRecordId: linkedRecordId,
linkedObjectMetadataId: linkedObjectMetadataId,
});
}
public async insertTimelineActivitiesForObject(
@ -161,33 +178,25 @@ export class TimelineActivityRepository {
if (activities.length === 0) {
return;
}
const timelineActivityTypeORMRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
'timelineActivity',
{
shouldBypassPermissionChecks: true,
},
);
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
return this.workspaceDataSourceService.executeRawQuery(
`INSERT INTO ${dataSourceSchema}."timelineActivity"
("name", "properties", "workspaceMemberId", "${objectName}Id", "linkedRecordCachedName", "linkedRecordId", "linkedObjectMetadataId")
VALUES ${activities
.map(
(_, index) =>
`($${index * 7 + 1}, $${index * 7 + 2}, $${index * 7 + 3}, $${
index * 7 + 4
}, $${index * 7 + 5}, $${index * 7 + 6}, $${index * 7 + 7})`,
)
.join(',')}`,
activities
.map((activity) => [
activity.name,
activity.properties,
activity.workspaceMemberId,
activity.recordId,
activity.linkedRecordCachedName ?? '',
activity.linkedRecordId,
activity.linkedObjectMetadataId,
])
.flat(),
workspaceId,
return timelineActivityTypeORMRepository.insert(
activities.map((activity) => ({
name: activity.name,
properties: activity.properties,
workspaceMemberId: activity.workspaceMemberId,
[objectName + 'Id']: activity.recordId,
linkedRecordCachedName: activity.linkedRecordCachedName ?? '',
linkedRecordId: activity.linkedRecordId,
linkedObjectMetadataId: activity.linkedObjectMetadataId,
})),
);
}
}

153
packages/twenty-server/src/modules/timeline/services/timeline-activity.service.ts
View File

@ -1,9 +1,11 @@
import { Injectable } from '@nestjs/common';
import { isDefined } from 'twenty-shared/utils';
import { ObjectRecordNonDestructiveEvent } from 'src/engine/core-modules/event-emitter/types/object-record-non-destructive-event';
import { ObjectRecordBaseEvent } from 'src/engine/core-modules/event-emitter/types/object-record.base.event';
import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { TimelineActivityRepository } from 'src/modules/timeline/repositiories/timeline-activity.repository';
import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';
@ -22,7 +24,7 @@ export class TimelineActivityService {
constructor(
@InjectObjectMetadataRepository(TimelineActivityWorkspaceEntity)
private readonly timelineActivityRepository: TimelineActivityRepository,
private readonly workspaceDataSourceService: WorkspaceDataSourceService,
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
) {}
private targetObjects: Record<string, string> = {
@ -110,14 +112,10 @@ export class TimelineActivityService {
workspaceId: string;
eventName: string;
}): Promise<TimelineActivity[] | undefined> {
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
switch (event.objectMetadata.nameSingular) {
case 'noteTarget':
return this.computeActivityTargets({
event,
dataSourceSchema,
activityType: 'note',
eventName,
workspaceId,
@ -125,7 +123,6 @@ export class TimelineActivityService {
case 'taskTarget':
return this.computeActivityTargets({
event,
dataSourceSchema,
activityType: 'task',
eventName,
workspaceId,
@ -134,7 +131,6 @@ export class TimelineActivityService {
case 'task':
return this.computeActivities({
event,
dataSourceSchema,
activityType: event.objectMetadata.nameSingular,
eventName,
workspaceId,
@ -146,100 +142,119 @@ export class TimelineActivityService {
private async computeActivities({
event,
dataSourceSchema,
activityType,
eventName,
workspaceId,
}: {
event: ObjectRecordBaseEvent;
dataSourceSchema: string;
activityType: string;
eventName: string;
workspaceId: string;
}) {
const activityTargets =
await this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."${this.targetObjects[activityType]}"
WHERE "${activityType}Id" = $1`,
[event.recordId],
const activityTargetRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
this.targetObjects[activityType],
{
shouldBypassPermissionChecks: true,
},
);
const activity = await this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."${activityType}"
WHERE "id" = $1`,
[event.recordId],
workspaceId,
);
const activityTargets = await activityTargetRepository.find({
where: {
[activityType + 'Id']: event.recordId,
},
});
const activityRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
activityType,
{
shouldBypassPermissionChecks: true,
},
);
const activity = await activityRepository.findOneBy({
id: event.recordId,
});
if (activityTargets.length === 0) return;
if (activity.length === 0) return;
if (!isDefined(activity)) return;
return (
activityTargets
return activityTargets
.map((activityTarget) => {
const targetColumn: string[] = Object.entries(activityTarget)
.map(([columnName, columnValue]: [string, string]) => {
if (
columnName === activityType + 'Id' ||
!columnName.endsWith('Id')
)
return;
if (columnValue === null) return;
return columnName;
})
.filter((column): column is string => column !== undefined);
if (targetColumn.length === 0) return;
return {
...event,
name: 'linked-' + eventName,
objectName: targetColumn[0].replace(/Id$/, ''),
recordId: activityTarget[targetColumn[0]],
linkedRecordCachedName: activity.title,
linkedRecordId: activity.id,
linkedObjectMetadataId: event.objectMetadata.id,
} satisfies TimelineActivity;
})
.filter(
// @ts-expect-error legacy noImplicitAny
.map((activityTarget) => {
const targetColumn: string[] = Object.entries(activityTarget)
.map(([columnName, columnValue]: [string, string]) => {
if (
columnName === activityType + 'Id' ||
!columnName.endsWith('Id')
)
return;
if (columnValue === null) return;
return columnName;
})
.filter((column): column is string => column !== undefined);
if (targetColumn.length === 0) return;
return {
...event,
name: 'linked-' + eventName,
objectName: targetColumn[0].replace(/Id$/, ''),
recordId: activityTarget[targetColumn[0]],
linkedRecordCachedName: activity[0].title,
linkedRecordId: activity[0].id,
linkedObjectMetadataId: event.objectMetadata.id,
} satisfies TimelineActivity;
})
// @ts-expect-error legacy noImplicitAny
.filter((event): event is TimelineActivity => event !== undefined)
);
(event): event is TimelineActivity => event !== undefined,
) as TimelineActivity[];
}
private async computeActivityTargets({
event,
dataSourceSchema,
activityType,
eventName,
workspaceId,
}: {
event: ObjectRecordBaseEvent;
dataSourceSchema: string;
activityType: string;
activityType: 'task' | 'note';
eventName: string;
workspaceId: string;
}): Promise<TimelineActivity[] | undefined> {
const activityTarget =
await this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."${this.targetObjects[activityType]}"
WHERE "id" = $1`,
[event.recordId],
const activityTargetRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
this.targetObjects[activityType],
{
shouldBypassPermissionChecks: true,
},
);
if (activityTarget.length === 0) return;
const activityTarget = await activityTargetRepository.findOneBy({
id: event.recordId,
});
const activity = await this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."${activityType}"
WHERE "id" = $1`,
[activityTarget[0].activityId],
workspaceId,
);
if (!isDefined(activityTarget)) return;
if (activity.length === 0) return;
const activityRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace(
workspaceId,
activityType,
{
shouldBypassPermissionChecks: true,
},
);
const activity = await activityRepository.findOneBy({
id: activityTarget.activityId,
});
if (!isDefined(activity)) return;
const activityObjectMetadataId = event.objectMetadata.fields.find(
(field) => field.name === activityType,

4
packages/twenty-server/src/modules/timeline/timeline-activity.module.ts
View File

@ -1,16 +1,16 @@
import { Module } from '@nestjs/common';
import { ObjectMetadataRepositoryModule } from 'src/engine/object-metadata-repository/object-metadata-repository.module';
import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
import { TwentyORMModule } from 'src/engine/twenty-orm/twenty-orm.module';
import { TimelineActivityService } from 'src/modules/timeline/services/timeline-activity.service';
import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';
@Module({
imports: [
WorkspaceDataSourceModule,
ObjectMetadataRepositoryModule.forFeature([
TimelineActivityWorkspaceEntity,
]),
TwentyORMModule,
],
providers: [TimelineActivityService],
exports: [TimelineActivityService],

64
packages/twenty-server/src/modules/workspace-member/repositories/workspace-member.repository.ts
View File

@ -1,64 +0,0 @@
import { Injectable, NotFoundException } from '@nestjs/common';
import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
@Injectable()
export class WorkspaceMemberRepository {
constructor(
private readonly workspaceDataSourceService: WorkspaceDataSourceService,
) {}
public async find(workspaceMemberId: string, workspaceId: string) {
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
const workspaceMembers =
await this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."workspaceMember" WHERE "id" = $1`,
[workspaceMemberId],
workspaceId,
);
return workspaceMembers?.[0];
}
public async getByIdOrFail(
userId: string,
workspaceId: string,
): Promise<WorkspaceMemberWorkspaceEntity> {
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
const workspaceMembers =
await this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."workspaceMember" WHERE "userId" = $1`,
[userId],
workspaceId,
);
if (!workspaceMembers || workspaceMembers.length === 0) {
throw new NotFoundException(
`No workspace member found for user ${userId} in workspace ${workspaceId}`,
);
}
return workspaceMembers[0];
}
public async getAllByWorkspaceId(
workspaceId: string,
): Promise<WorkspaceMemberWorkspaceEntity[]> {
const dataSourceSchema =
this.workspaceDataSourceService.getSchemaName(workspaceId);
const workspaceMembers =
await this.workspaceDataSourceService.executeRawQuery(
`SELECT * FROM ${dataSourceSchema}."workspaceMember"`,
[],
workspaceId,
);
return workspaceMembers;
}
}