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

feat: add new ACTOR field type and createdBy standard fields (#6324)

Browse Source 
This pull request introduces a new `FieldMetadataType` called `ACTOR`.
The primary objective of this new type is to add an extra column to the
following objects: `person`, `company`, `opportunity`, `note`, `task`,
and all custom objects.

This composite type contains three properties:

- `source`
    ```typescript
    export enum FieldActorSource {
      EMAIL = 'EMAIL',
      CALENDAR = 'CALENDAR',
      API = 'API',
      IMPORT = 'IMPORT',
      MANUAL = 'MANUAL',
    }
    ```
- `workspaceMemberId`
- This property can be `undefined` in some cases and refers to the
member who created the record.
- `name`
- Serves as a fallback if the `workspaceMember` is deleted and is used
for other source types like `API`.

### Functionality

The pre-hook system has been updated to allow real-time argument
updates. When a record is created, a pre-hook can now compute and update
the arguments accordingly. This enhancement enables the `createdBy`
field to be populated with the correct values based on the
`authContext`.

The `authContext` now includes:
- An optional User entity
- An optional ApiKey entity
- The workspace entity

This provides access to the necessary data for the `createdBy` field.

In the GraphQL API, only the `source` can be specified in the
`createdBy` input. This allows the front-end to specify the source when
creating records from a CSV file.

### Front-End Handling

On the front-end, `orderBy` and `filter` are only applied to the name
property of the `ACTOR` composite type. Currently, we are unable to
apply these operations to the workspace member relation. This means that
if a workspace member changes their first name or last name, there may
be a mismatch because the name will differ from the new one. The name
displayed on the screen is based on the workspace member entity when
available.

### Missing Components

Currently, this PR does not include a `createdBy` value for the `MAIL`
and `CALENDAR` sources. These records are created in a job, and at
present, we only have access to the workspaceId within the job. To
address this, we should use a function similar to
`loadServiceWithContext`, which was recently removed from `TwentyORM`.
This function would allow us to pass the `authContext` to the jobs
without disrupting existing jobs.
Another PR will be created to handle these cases.

### Related Issues

Fixes issue #5155.

### Additional Notes

This PR doesn't include the migrations of the current records and views.
Everything works properly when the database is reset but this part is
still missing for now. We'll add that in another PR.

- There is a minor issue: front-end tests are broken since this commit:
[80c0fc7ff1).

---------

Co-authored-by: Lucas Bordeau <bordeau.lucas@gmail.com>
Co-authored-by: Charles Bochet <charles@twenty.com>
This commit is contained in:
Jérémy M
2024-08-03 15:43:31 +02:00
committed by GitHub
parent 9cf08d912a
commit 6432ad39b9
152 changed files with 24425 additions and 14968 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
packages/twenty-server/src/engine/core-modules/auth/services/auth.service.ts
View File

@ -39,6 +39,7 @@ import {
AppToken,
AppTokenType,
} from 'src/engine/core-modules/app-token/app-token.entity';
import { WorkspaceMember } from 'src/engine/core-modules/user/dtos/workspace-member.dto';
import { TokenService } from './token.service';
@ -131,7 +132,7 @@ export class AuthService {
const workspaceMember = await this.userService.loadWorkspaceMember(user);
if (workspaceMember) {
user.workspaceMember = workspaceMember;
user.workspaceMember = workspaceMember as WorkspaceMember;
}
const accessToken = await this.tokenService.generateAccessToken(user.id);

8
packages/twenty-server/src/engine/core-modules/auth/services/token.service.ts
View File

@ -42,7 +42,7 @@ import { ValidatePasswordResetToken } from 'src/engine/core-modules/auth/dto/val
import { EmailService } from 'src/engine/integrations/email/email.service';
import { InvalidatePassword } from 'src/engine/core-modules/auth/dto/invalidate-password.entity';
import { EmailPasswordResetLink } from 'src/engine/core-modules/auth/dto/email-password-reset-link.entity';
import { JwtData } from 'src/engine/core-modules/auth/types/jwt-data.type';
import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
import { ExchangeAuthCodeInput } from 'src/engine/core-modules/auth/dto/exchange-auth-code.input';
import { ExchangeAuthCode } from 'src/engine/core-modules/auth/dto/exchange-auth-code.entity';
@ -208,7 +208,7 @@ export class TokenService {
return !!token;
}
async validateToken(request: Request): Promise<JwtData> {
async validateToken(request: Request): Promise<AuthContext> {
const token = ExtractJwt.fromAuthHeaderAsBearerToken()(request);
if (!token) {
@ -219,11 +219,11 @@ export class TokenService {
this.environmentService.get('ACCESS_TOKEN_SECRET'),
);
const { user, workspace } = await this.jwtStrategy.validate(
const { user, apiKey, workspace } = await this.jwtStrategy.validate(
decoded as JwtPayload,
);
return { user, workspace };
return { user, apiKey, workspace };
}
async verifyLoginToken(loginToken: string): Promise<string> {

24
packages/twenty-server/src/engine/core-modules/auth/strategies/jwt.auth.strategy.ts
View File

@ -15,9 +15,10 @@ import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
import { EnvironmentService } from 'src/engine/integrations/environment/environment.service';
import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
import { assert } from 'src/utils/assert';
import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
import { ApiKeyWorkspaceEntity } from 'src/modules/api-key/standard-objects/api-key.workspace-entity';
export type JwtPayload = { sub: string; workspaceId: string; jti?: string };
export type PassportUser = { user?: User; workspace: Workspace };
@Injectable()
export class JwtAuthStrategy extends PassportStrategy(Strategy, 'jwt') {
@ -37,15 +38,24 @@ export class JwtAuthStrategy extends PassportStrategy(Strategy, 'jwt') {
});
}
async validate(payload: JwtPayload): Promise<PassportUser> {
async validate(payload: JwtPayload): Promise<AuthContext> {
const workspace = await this.workspaceRepository.findOneBy({
id: payload.workspaceId ?? payload.sub,
});
let user: User | null = null;
let apiKey: ApiKeyWorkspaceEntity | null = null;
if (!workspace) {
throw new UnauthorizedException();
}
if (payload.jti) {
// TODO: Check why it's not working
// const apiKeyRepository =
// await this.twentyORMGlobalManager.getRepositoryForWorkspace<ApiKeyWorkspaceEntity>(
// workspace.id,
// 'apiKey',
// );
const dataSourceMetadata =
await this.dataSourceService.getLastDataSourceMetadataFromWorkspaceIdOrFail(
workspace.id,
@ -54,20 +64,20 @@ export class JwtAuthStrategy extends PassportStrategy(Strategy, 'jwt') {
const workspaceDataSource =
await this.typeORMService.connectToDataSource(dataSourceMetadata);
const apiKey = await workspaceDataSource?.query(
const res = await workspaceDataSource?.query(
`SELECT * FROM ${dataSourceMetadata.schema}."apiKey" WHERE id = $1`,
[payload.jti],
);
apiKey = res?.[0];
assert(
apiKey.length === 1 && !apiKey?.[0].revokedAt,
apiKey && !apiKey.revokedAt,
'This API Key is revoked',
ForbiddenException,
);
}
let user;
if (payload.workspaceId) {
user = await this.userRepository.findOne({
where: { id: payload.sub },
@ -78,6 +88,6 @@ export class JwtAuthStrategy extends PassportStrategy(Strategy, 'jwt') {
}
}
return { user, workspace };
return { user, apiKey, workspace };
}
}

9
packages/twenty-server/src/engine/core-modules/auth/types/auth-context.type.ts Normal file
View File

@ -0,0 +1,9 @@
import { User } from 'src/engine/core-modules/user/user.entity';
import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
import { ApiKeyWorkspaceEntity } from 'src/modules/api-key/standard-objects/api-key.workspace-entity';
export type AuthContext = {
user?: User | null | undefined;
apiKey?: ApiKeyWorkspaceEntity | null | undefined;
workspace: Workspace;
};

7
packages/twenty-server/src/engine/core-modules/auth/types/jwt-data.type.ts
View File

@ -1,7 +0,0 @@
import { User } from 'src/engine/core-modules/user/user.entity';
import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
export type JwtData = {
user?: User | undefined;
workspace: Workspace;
};

15
packages/twenty-server/src/engine/core-modules/open-api/utils/__tests__/components.utils.spec.ts
View File

@ -137,6 +137,21 @@ describe('computeSchemaComponents', () => {
fieldRichText: {
type: 'string',
},
fieldActor: {
properties: {
source: {
type: 'string',
},
workspaceMemberId: {
type: 'string',
format: 'uuid',
},
name: {
type: 'string',
},
},
type: 'object',
},
},
},
'ObjectName with Relations': {

1
packages/twenty-server/src/engine/core-modules/open-api/utils/components.utils.ts
View File

@ -71,6 +71,7 @@ const getSchemaComponentsProperties = (
case FieldMetadataType.CURRENCY:
case FieldMetadataType.FULL_NAME:
case FieldMetadataType.ADDRESS:
case FieldMetadataType.ACTOR:
itemProperty = {
type: 'object',
properties: compositeTypeDefintions

5
packages/twenty-server/src/engine/core-modules/user/services/__tests__/user.service.spec.ts
View File

@ -8,6 +8,7 @@ import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-
import { TypeORMService } from 'src/database/typeorm/typeorm.service';
import { UserWorkspace } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
import { WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
describe('UserService', () => {
let service: UserService;
@ -40,6 +41,10 @@ describe('UserService', () => {
provide: WorkspaceService,
useValue: {},
},
{
provide: TwentyORMGlobalManager,
useValue: {},
},
],
}).compile();

96
packages/twenty-server/src/engine/core-modules/user/services/user.service.ts
View File

@ -1,18 +1,22 @@
import { EventEmitter2 } from '@nestjs/event-emitter';
import { InjectRepository } from '@nestjs/typeorm';
import assert from 'assert';
import { TypeOrmQueryService } from '@ptc-org/nestjs-query-typeorm';
import { Repository } from 'typeorm';
import { TypeORMService } from 'src/database/typeorm/typeorm.service';
import { WorkspaceMember } from 'src/engine/core-modules/user/dtos/workspace-member.dto';
import { User } from 'src/engine/core-modules/user/user.entity';
import { WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
import {
Workspace,
WorkspaceActivationStatus,
} from 'src/engine/core-modules/workspace/workspace.entity';
import { ObjectRecordDeleteEvent } from 'src/engine/integrations/event-emitter/types/object-record-delete.event';
import { DataSourceEntity } from 'src/engine/metadata-modules/data-source/data-source.entity';
import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
import { assert } from 'src/utils/assert';
export class UserService extends TypeOrmQueryService<User> {
constructor(
@ -22,73 +26,46 @@ export class UserService extends TypeOrmQueryService<User> {
private readonly typeORMService: TypeORMService,
private readonly eventEmitter: EventEmitter2,
private readonly workspaceService: WorkspaceService,
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
) {
super(userRepository);
}
async loadWorkspaceMember(user: User) {
const dataSourcesMetadata =
await this.dataSourceService.getDataSourcesMetadataFromWorkspaceId(
user.defaultWorkspace.id,
if (
user.defaultWorkspace.activationStatus !==
WorkspaceActivationStatus.ACTIVE
) {
return null;
}
const workspaceMemberRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace<WorkspaceMemberWorkspaceEntity>(
user.defaultWorkspaceId,
'workspaceMember',
);
if (!dataSourcesMetadata.length) {
return;
}
const workspaceMember = await workspaceMemberRepository.findOne({
where: {
userId: user.id,
},
});
if (dataSourcesMetadata.length > 1) {
throw new Error(
`user '${user.id}' default workspace '${user.defaultWorkspace.id}' has multiple data source metadata`,
);
}
const dataSourceMetadata = dataSourcesMetadata[0];
const workspaceDataSource =
await this.typeORMService.connectToDataSource(dataSourceMetadata);
const workspaceMembers = await workspaceDataSource?.query(
`SELECT * FROM ${dataSourceMetadata.schema}."workspaceMember" WHERE "userId" = '${user.id}'`,
);
if (!workspaceMembers.length) {
return;
}
assert(
workspaceMembers.length === 1,
'WorkspaceMember not found or too many found',
);
const userWorkspaceMember = new WorkspaceMember();
userWorkspaceMember.id = workspaceMembers[0].id;
userWorkspaceMember.colorScheme = workspaceMembers[0].colorScheme;
userWorkspaceMember.locale = workspaceMembers[0].locale;
userWorkspaceMember.avatarUrl = workspaceMembers[0].avatarUrl;
userWorkspaceMember.name = {
firstName: workspaceMembers[0].nameFirstName,
lastName: workspaceMembers[0].nameLastName,
};
userWorkspaceMember.timeZone = workspaceMembers[0].timeZone;
userWorkspaceMember.dateFormat = workspaceMembers[0].dateFormat;
userWorkspaceMember.timeFormat = workspaceMembers[0].timeFormat;
return userWorkspaceMember;
return workspaceMember;
}
async loadWorkspaceMembers(dataSource: DataSourceEntity) {
const workspaceDataSource =
await this.typeORMService.connectToDataSource(dataSource);
async loadWorkspaceMembers(workspace: Workspace) {
if (workspace.activationStatus !== WorkspaceActivationStatus.ACTIVE) {
return [];
}
return await workspaceDataSource?.query(
`
SELECT *
FROM ${dataSource.schema}."workspaceMember" AS s
INNER JOIN core.user AS u
ON s."userId" = u.id
`,
);
const workspaceMemberRepository =
await this.twentyORMGlobalManager.getRepositoryForWorkspace<WorkspaceMemberWorkspaceEntity>(
workspace.id,
'workspaceMember',
);
return workspaceMemberRepository.find();
}
async deleteUser(userId: string): Promise<User> {
@ -136,6 +113,7 @@ export class UserService extends TypeOrmQueryService<User> {
payload.properties = {
before: workspaceMember,
};
payload.name = 'workspaceMember.deleted';
payload.recordId = workspaceMember.id;
this.eventEmitter.emit('workspaceMember.deleted', payload);

30
packages/twenty-server/src/engine/core-modules/user/user.resolver.ts
View File

@ -112,9 +112,7 @@ export class UserResolver {
@ResolveField(() => WorkspaceMember, {
nullable: true,
})
async workspaceMember(
@Parent() user: User,
): Promise<WorkspaceMember | undefined> {
async workspaceMember(@Parent() user: User): Promise<WorkspaceMember | null> {
const workspaceMember = await this.userService.loadWorkspaceMember(user);
if (workspaceMember && workspaceMember.avatarUrl) {
@ -126,7 +124,31 @@ export class UserResolver {
workspaceMember.avatarUrl = `${workspaceMember.avatarUrl}?token=${avatarUrlToken}`;
}
return workspaceMember;
// TODO: Fix typing disrepency between Entity and DTO
return workspaceMember as WorkspaceMember | null;
}
@ResolveField(() => [WorkspaceMember], {
nullable: true,
})
async workspaceMembers(@Parent() user: User): Promise<WorkspaceMember[]> {
const workspaceMembers = await this.userService.loadWorkspaceMembers(
user.defaultWorkspace,
);
for (const workspaceMember of workspaceMembers) {
if (workspaceMember.avatarUrl) {
const avatarUrlToken = await this.fileService.encodeFileToken({
workspace_member_id: workspaceMember.id,
workspace_id: user.defaultWorkspaceId,
});
workspaceMember.avatarUrl = `${workspaceMember.avatarUrl}?token=${avatarUrlToken}`;
}
}
// TODO: Fix typing disrepency between Entity and DTO
return workspaceMembers as WorkspaceMember[];
}
@ResolveField(() => String, {