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

Migrate view field to new data model - Part 2 (#2270)

Browse Source 
* Migrate view field to new data model

* Migrate view fields to new model
This commit is contained in:
Charles Bochet
2023-10-28 19:13:48 +02:00
committed by GitHub
parent b591023eb3
commit 685d342170
168 changed files with 960 additions and 4568 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
server/src/ability/ability.factory.ts
View File

@ -17,10 +17,6 @@ import {
RefreshToken,
User,
UserSettings,
View,
ViewField,
ViewFilter,
ViewSort,
WebHook,
Workspace,
WorkspaceMember,
@ -44,10 +40,7 @@ type SubjectsAbility = Subjects<{
RefreshToken: RefreshToken;
User: User;
UserSettings: UserSettings;
View: View;
ViewField: ViewField;
ViewFilter: ViewFilter;
ViewSort: ViewSort;
Workspace: Workspace;
WorkspaceMember: WorkspaceMember;
}>;
@ -175,29 +168,6 @@ export class AbilityFactory {
workspaceId: workspace.id,
});
// View
can(AbilityAction.Read, 'View', { workspaceId: workspace.id });
can(AbilityAction.Create, 'View', { workspaceId: workspace.id });
can(AbilityAction.Update, 'View', { workspaceId: workspace.id });
can(AbilityAction.Delete, 'View', { workspaceId: workspace.id });
// ViewField
can(AbilityAction.Read, 'ViewField', { workspaceId: workspace.id });
can(AbilityAction.Create, 'ViewField', { workspaceId: workspace.id });
can(AbilityAction.Update, 'ViewField', { workspaceId: workspace.id });
// ViewFilter
can(AbilityAction.Read, 'ViewFilter', { workspaceId: workspace.id });
can(AbilityAction.Create, 'ViewFilter', { workspaceId: workspace.id });
can(AbilityAction.Update, 'ViewFilter', { workspaceId: workspace.id });
can(AbilityAction.Delete, 'ViewFilter', { workspaceId: workspace.id });
// ViewSort
can(AbilityAction.Read, 'ViewSort', { workspaceId: workspace.id });
can(AbilityAction.Create, 'ViewSort', { workspaceId: workspace.id });
can(AbilityAction.Update, 'ViewSort', { workspaceId: workspace.id });
can(AbilityAction.Delete, 'ViewSort', { workspaceId: workspace.id });
// Favorite
can(AbilityAction.Read, 'Favorite', { workspaceId: workspace.id });
can(AbilityAction.Create, 'Favorite');

63
server/src/ability/ability.module.ts
View File

@ -99,35 +99,12 @@ import {
ReadAttachmentAbilityHandler,
UpdateAttachmentAbilityHandler,
} from './handlers/attachment.ability-handler';
import {
CreateViewFieldAbilityHandler,
ReadViewFieldAbilityHandler,
UpdateViewFieldAbilityHandler,
} from './handlers/view-field.ability-handler';
import {
CreateFavoriteAbilityHandler,
ReadFavoriteAbilityHandler,
DeleteFavoriteAbilityHandler,
UpdateFavoriteAbilityHandler,
} from './handlers/favorite.ability-handler';
import {
CreateViewSortAbilityHandler,
ReadViewSortAbilityHandler,
UpdateViewSortAbilityHandler,
DeleteViewSortAbilityHandler,
} from './handlers/view-sort.ability-handler';
import {
CreateViewAbilityHandler,
ReadViewAbilityHandler,
UpdateViewAbilityHandler,
DeleteViewAbilityHandler,
} from './handlers/view.ability-handler';
import {
CreateViewFilterAbilityHandler,
DeleteViewFilterAbilityHandler,
ReadViewFilterAbilityHandler,
UpdateViewFilterAbilityHandler,
} from './handlers/view-filter.ability-handler';
import {
CreateApiKeyAbilityHandler,
UpdateApiKeyAbilityHandler,
@ -222,25 +199,7 @@ import {
CreateFavoriteAbilityHandler,
UpdateFavoriteAbilityHandler,
DeleteFavoriteAbilityHandler,
// View
ReadViewAbilityHandler,
CreateViewAbilityHandler,
UpdateViewAbilityHandler,
DeleteViewAbilityHandler,
// ViewField
ReadViewFieldAbilityHandler,
CreateViewFieldAbilityHandler,
UpdateViewFieldAbilityHandler,
// ViewFilter
ReadViewFilterAbilityHandler,
CreateViewFilterAbilityHandler,
UpdateViewFilterAbilityHandler,
DeleteViewFilterAbilityHandler,
// ViewSort
ReadViewSortAbilityHandler,
CreateViewSortAbilityHandler,
UpdateViewSortAbilityHandler,
DeleteViewSortAbilityHandler,
// ApiKey
ReadApiKeyAbilityHandler,
ManageApiKeyAbilityHandler,
@ -335,25 +294,7 @@ import {
ReadFavoriteAbilityHandler,
CreateFavoriteAbilityHandler,
DeleteFavoriteAbilityHandler,
// View
ReadViewAbilityHandler,
CreateViewAbilityHandler,
UpdateViewAbilityHandler,
DeleteViewAbilityHandler,
// ViewField
ReadViewFieldAbilityHandler,
CreateViewFieldAbilityHandler,
UpdateViewFieldAbilityHandler,
// ViewFilter
ReadViewFilterAbilityHandler,
CreateViewFilterAbilityHandler,
UpdateViewFilterAbilityHandler,
DeleteViewFilterAbilityHandler,
// ViewSort
ReadViewSortAbilityHandler,
CreateViewSortAbilityHandler,
UpdateViewSortAbilityHandler,
DeleteViewSortAbilityHandler,
// ApiKey
ReadApiKeyAbilityHandler,
ManageApiKeyAbilityHandler,

87
server/src/ability/handlers/view-field.ability-handler.ts
View File

@ -1,87 +0,0 @@
import {
ExecutionContext,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';
import { subject } from '@casl/ability';
import { IAbilityHandler } from 'src/ability/interfaces/ability-handler.interface';
import { AbilityAction } from 'src/ability/ability.action';
import { AppAbility } from 'src/ability/ability.factory';
import { relationAbilityChecker } from 'src/ability/ability.util';
import { ViewFieldWhereInput } from 'src/core/@generated/view-field/view-field-where.input';
import { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
import { ViewFieldWhereUniqueInput } from 'src/core/@generated/view-field/view-field-where-unique.input';
class ViewFieldArgs {
where?: ViewFieldWhereInput;
[key: string]: any;
}
const isViewFieldWhereUniqueInput = (
input: ViewFieldWhereInput | ViewFieldWhereUniqueInput,
): input is ViewFieldWhereUniqueInput => 'viewId_key' in input;
@Injectable()
export class ReadViewFieldAbilityHandler implements IAbilityHandler {
handle(ability: AppAbility) {
return ability.can(AbilityAction.Read, 'ViewField');
}
}
@Injectable()
export class CreateViewFieldAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs();
const allowed = await relationAbilityChecker(
'ViewField',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Create, 'ViewField');
}
}
@Injectable()
export class UpdateViewFieldAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewFieldArgs>();
const viewField = await this.prismaService.client.viewField.findFirst({
where:
args.where && isViewFieldWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
});
assert(viewField, '', NotFoundException);
const allowed = await relationAbilityChecker(
'ViewField',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Update, subject('ViewField', viewField));
}
}

122
server/src/ability/handlers/view-filter.ability-handler.ts
View File

@ -1,122 +0,0 @@
import {
ExecutionContext,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';
import { subject } from '@casl/ability';
import { IAbilityHandler } from 'src/ability/interfaces/ability-handler.interface';
import { AbilityAction } from 'src/ability/ability.action';
import { AppAbility } from 'src/ability/ability.factory';
import {
convertToWhereInput,
relationAbilityChecker,
} from 'src/ability/ability.util';
import { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
import { ViewFilterWhereUniqueInput } from 'src/core/@generated/view-filter/view-filter-where-unique.input';
import { ViewFilterWhereInput } from 'src/core/@generated/view-filter/view-filter-where.input';
class ViewFilterArgs {
where?: ViewFilterWhereInput | ViewFilterWhereUniqueInput;
[key: string]: any;
}
const isViewFilterWhereUniqueInput = (
input: ViewFilterWhereInput | ViewFilterWhereUniqueInput,
): input is ViewFilterWhereUniqueInput => 'viewId_key' in input;
@Injectable()
export class ReadViewFilterAbilityHandler implements IAbilityHandler {
handle(ability: AppAbility) {
return ability.can(AbilityAction.Read, 'ViewFilter');
}
}
@Injectable()
export class CreateViewFilterAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs();
const allowed = await relationAbilityChecker(
'ViewFilter',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Create, 'ViewFilter');
}
}
@Injectable()
export class UpdateViewFilterAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewFilterArgs>();
const viewFilter = await this.prismaService.client.viewFilter.findFirst({
where:
args.where && isViewFilterWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
});
assert(viewFilter, '', NotFoundException);
const allowed = await relationAbilityChecker(
'ViewFilter',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Update, subject('ViewFilter', viewFilter));
}
}
@Injectable()
export class DeleteViewFilterAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewFilterArgs>();
const where = convertToWhereInput(
args.where && isViewFilterWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
);
const viewFilters = await this.prismaService.client.viewFilter.findMany({
where,
});
assert(viewFilters.length, '', NotFoundException);
for (const viewFilter of viewFilters) {
const allowed = ability.can(
AbilityAction.Delete,
subject('ViewFilter', viewFilter),
);
if (!allowed) {
return false;
}
}
return true;
}
}

122
server/src/ability/handlers/view-sort.ability-handler.ts
View File

@ -1,122 +0,0 @@
import {
ExecutionContext,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';
import { subject } from '@casl/ability';
import { IAbilityHandler } from 'src/ability/interfaces/ability-handler.interface';
import { AbilityAction } from 'src/ability/ability.action';
import { AppAbility } from 'src/ability/ability.factory';
import {
convertToWhereInput,
relationAbilityChecker,
} from 'src/ability/ability.util';
import { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
import { ViewSortWhereUniqueInput } from 'src/core/@generated/view-sort/view-sort-where-unique.input';
import { ViewSortWhereInput } from 'src/core/@generated/view-sort/view-sort-where.input';
class ViewSortArgs {
where?: ViewSortWhereInput | ViewSortWhereUniqueInput;
[key: string]: any;
}
const isViewSortWhereUniqueInput = (
input: ViewSortWhereInput | ViewSortWhereUniqueInput,
): input is ViewSortWhereUniqueInput => 'viewId_key' in input;
@Injectable()
export class ReadViewSortAbilityHandler implements IAbilityHandler {
handle(ability: AppAbility) {
return ability.can(AbilityAction.Read, 'ViewSort');
}
}
@Injectable()
export class CreateViewSortAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs();
const allowed = await relationAbilityChecker(
'ViewSort',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Create, 'ViewSort');
}
}
@Injectable()
export class UpdateViewSortAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewSortArgs>();
const viewSort = await this.prismaService.client.viewSort.findFirst({
where:
args.where && isViewSortWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
});
assert(viewSort, '', NotFoundException);
const allowed = await relationAbilityChecker(
'ViewSort',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Update, subject('ViewSort', viewSort));
}
}
@Injectable()
export class DeleteViewSortAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewSortArgs>();
const where = convertToWhereInput(
args.where && isViewSortWhereUniqueInput(args.where)
? args.where.viewId_key
: args.where,
);
const viewSorts = await this.prismaService.client.viewSort.findMany({
where,
});
assert(viewSorts.length, '', NotFoundException);
for (const viewSort of viewSorts) {
const allowed = ability.can(
AbilityAction.Delete,
subject('ViewSort', viewSort),
);
if (!allowed) {
return false;
}
}
return true;
}
}

95
server/src/ability/handlers/view.ability-handler.ts
View File

@ -1,95 +0,0 @@
import {
ExecutionContext,
Injectable,
NotFoundException,
} from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';
import { subject } from '@casl/ability';
import { IAbilityHandler } from 'src/ability/interfaces/ability-handler.interface';
import { AbilityAction } from 'src/ability/ability.action';
import { AppAbility } from 'src/ability/ability.factory';
import { relationAbilityChecker } from 'src/ability/ability.util';
import { ViewWhereInput } from 'src/core/@generated/view/view-where.input';
import { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
class ViewArgs {
where?: ViewWhereInput;
[key: string]: any;
}
@Injectable()
export class ReadViewAbilityHandler implements IAbilityHandler {
handle(ability: AppAbility) {
return ability.can(AbilityAction.Read, 'View');
}
}
@Injectable()
export class CreateViewAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs();
const allowed = await relationAbilityChecker(
'View',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Create, 'View');
}
}
@Injectable()
export class UpdateViewAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewArgs>();
const view = await this.prismaService.client.view.findFirst({
where: args.where,
});
assert(view, '', NotFoundException);
const allowed = await relationAbilityChecker(
'View',
ability,
this.prismaService.client,
args,
);
if (!allowed) {
return false;
}
return ability.can(AbilityAction.Update, subject('View', view));
}
}
@Injectable()
export class DeleteViewAbilityHandler implements IAbilityHandler {
constructor(private readonly prismaService: PrismaService) {}
async handle(ability: AppAbility, context: ExecutionContext) {
const gqlContext = GqlExecutionContext.create(context);
const args = gqlContext.getArgs<ViewArgs>();
const view = await this.prismaService.client.view.findFirst({
where: args.where,
});
assert(view, '', NotFoundException);
return ability.can(AbilityAction.Delete, subject('View', view));
}
}

2
server/src/core/core.module.ts
View File

@ -14,7 +14,6 @@ import { FileModule } from './file/file.module';
import { ClientConfigModule } from './client-config/client-config.module';
import { AttachmentModule } from './attachment/attachment.module';
import { ActivityModule } from './activity/activity.module';
import { ViewModule } from './view/view.module';
import { FavoriteModule } from './favorite/favorite.module';
import { ApiKeyModule } from './api-key/api-key.module';
@ -32,7 +31,6 @@ import { ApiKeyModule } from './api-key/api-key.module';
ClientConfigModule,
AttachmentModule,
ActivityModule,
ViewModule,
FavoriteModule,
ApiKeyModule,
WebHookModule,

6
server/src/core/pipeline/resolvers/pipeline-stage.resolver.ts
View File

@ -116,7 +116,7 @@ export class PipelineStageResolver {
const { pipelineId } = pipelineStageToDelete;
const remainingPipelineStages = await this.pipelineStageService.findMany({
orderBy: { index: 'asc' },
orderBy: { position: 'asc' },
where: {
pipelineId,
NOT: { id: pipelineStageToDelete.id },
@ -135,10 +135,10 @@ export class PipelineStageResolver {
await Promise.all(
remainingPipelineStages.map((pipelineStage, index) => {
if (pipelineStage.index === index) return;
if (pipelineStage.position === index) return;
return this.pipelineStageService.update({
data: { index },
data: { position: index },
where: { id: pipelineStage.id },
});
}),

32
server/src/core/view/resolvers/view-field.resolver.spec.ts
View File

@ -1,32 +0,0 @@
import { Test, TestingModule } from '@nestjs/testing';
import { ViewFieldService } from 'src/core/view/services/view-field.service';
import { AbilityFactory } from 'src/ability/ability.factory';
import { ViewFieldResolver } from './view-field.resolver';
describe('ViewFieldResolver', () => {
let resolver: ViewFieldResolver;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
ViewFieldResolver,
{
provide: ViewFieldService,
useValue: {},
},
{
provide: AbilityFactory,
useValue: {},
},
],
}).compile();
resolver = module.get<ViewFieldResolver>(ViewFieldResolver);
});
it('should be defined', () => {
expect(resolver).toBeDefined();
});
});

108
server/src/core/view/resolvers/view-field.resolver.ts
View File

@ -1,108 +0,0 @@
import { UseGuards } from '@nestjs/common';
import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
import { accessibleBy } from '@casl/prisma';
import { Prisma, Workspace } from '@prisma/client';
import { AppAbility } from 'src/ability/ability.factory';
import {
CreateViewFieldAbilityHandler,
ReadViewFieldAbilityHandler,
UpdateViewFieldAbilityHandler,
} from 'src/ability/handlers/view-field.ability-handler';
import { AffectedRows } from 'src/core/@generated/prisma/affected-rows.output';
import { CreateManyViewFieldArgs } from 'src/core/@generated/view-field/create-many-view-field.args';
import { FindManyViewFieldArgs } from 'src/core/@generated/view-field/find-many-view-field.args';
import { UpdateOneViewFieldArgs } from 'src/core/@generated/view-field/update-one-view-field.args';
import { ViewField } from 'src/core/@generated/view-field/view-field.model';
import { ViewFieldService } from 'src/core/view/services/view-field.service';
import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
import {
PrismaSelect,
PrismaSelector,
} from 'src/decorators/prisma-select.decorator';
import { UserAbility } from 'src/decorators/user-ability.decorator';
import { AbilityGuard } from 'src/guards/ability.guard';
import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
import { CreateOneViewFieldArgs } from 'src/core/@generated/view-field/create-one-view-field.args';
@UseGuards(JwtAuthGuard)
@Resolver(() => ViewField)
export class ViewFieldResolver {
constructor(private readonly viewFieldService: ViewFieldService) {}
@Mutation(() => ViewField, {
nullable: false,
})
@UseGuards(AbilityGuard)
@CheckAbilities(CreateViewFieldAbilityHandler)
async createOneViewField(
@Args() args: CreateOneViewFieldArgs,
@AuthWorkspace() workspace: Workspace,
@PrismaSelector({ modelName: 'ViewField' })
prismaSelect: PrismaSelect<'ViewField'>,
): Promise<Partial<ViewField>> {
return this.viewFieldService.create({
data: {
...(args.data as Prisma.ViewFieldCreateInput),
workspace: { connect: { id: workspace.id } },
},
select: prismaSelect.value,
});
}
@Mutation(() => AffectedRows)
@UseGuards(AbilityGuard)
@CheckAbilities(CreateViewFieldAbilityHandler)
async createManyViewField(
@Args() args: CreateManyViewFieldArgs,
@AuthWorkspace() workspace: Workspace,
): Promise<Prisma.BatchPayload> {
return this.viewFieldService.createMany({
data: args.data.map((dataItem) => ({
...dataItem,
workspaceId: workspace.id,
})),
});
}
@Query(() => [ViewField])
@UseGuards(AbilityGuard)
@CheckAbilities(ReadViewFieldAbilityHandler)
async findManyViewField(
@Args() args: FindManyViewFieldArgs,
@UserAbility() ability: AppAbility,
@PrismaSelector({ modelName: 'ViewField' })
prismaSelect: PrismaSelect<'ViewField'>,
): Promise<Partial<ViewField>[]> {
return this.viewFieldService.findMany({
where: args.where
? {
AND: [args.where, accessibleBy(ability).ViewField],
}
: accessibleBy(ability).ViewField,
orderBy: args.orderBy,
cursor: args.cursor,
take: args.take,
skip: args.skip,
distinct: args.distinct,
select: prismaSelect.value,
});
}
@Mutation(() => ViewField)
@UseGuards(AbilityGuard)
@CheckAbilities(UpdateViewFieldAbilityHandler)
async updateOneViewField(
@Args() args: UpdateOneViewFieldArgs,
@PrismaSelector({ modelName: 'ViewField' })
prismaSelect: PrismaSelect<'ViewField'>,
) {
return this.viewFieldService.update({
where: args.where,
data: args.data,
select: prismaSelect.value,
} as Prisma.ViewFieldUpdateArgs);
}
}

102
server/src/core/view/resolvers/view-filter.resolver.ts
View File

@ -1,102 +0,0 @@
import { UseGuards } from '@nestjs/common';
import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
import { accessibleBy } from '@casl/prisma';
import { Prisma, Workspace } from '@prisma/client';
import { AppAbility } from 'src/ability/ability.factory';
import {
CreateViewFilterAbilityHandler,
DeleteViewFilterAbilityHandler,
ReadViewFilterAbilityHandler,
UpdateViewFilterAbilityHandler,
} from 'src/ability/handlers/view-filter.ability-handler';
import { FindManyViewFilterArgs } from 'src/core/@generated/view-filter/find-many-view-filter.args';
import { ViewFilter } from 'src/core/@generated/view-filter/view-filter.model';
import { ViewFilterService } from 'src/core/view/services/view-filter.service';
import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
import {
PrismaSelect,
PrismaSelector,
} from 'src/decorators/prisma-select.decorator';
import { UserAbility } from 'src/decorators/user-ability.decorator';
import { AbilityGuard } from 'src/guards/ability.guard';
import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
import { UpdateOneViewFilterArgs } from 'src/core/@generated/view-filter/update-one-view-filter.args';
import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
import { AffectedRows } from 'src/core/@generated/prisma/affected-rows.output';
import { DeleteManyViewFilterArgs } from 'src/core/@generated/view-filter/delete-many-view-filter.args';
import { CreateManyViewFilterArgs } from 'src/core/@generated/view-filter/create-many-view-filter.args';
@UseGuards(JwtAuthGuard)
@Resolver(() => ViewFilter)
export class ViewFilterResolver {
constructor(private readonly viewFilterService: ViewFilterService) {}
@Mutation(() => AffectedRows)
@UseGuards(AbilityGuard)
@CheckAbilities(CreateViewFilterAbilityHandler)
async createManyViewFilter(
@Args() args: CreateManyViewFilterArgs,
@AuthWorkspace() workspace: Workspace,
): Promise<AffectedRows> {
return this.viewFilterService.createMany({
data: args.data.map((data) => ({
...data,
workspaceId: workspace.id,
})),
});
}
@Query(() => [ViewFilter])
@UseGuards(AbilityGuard)
@CheckAbilities(ReadViewFilterAbilityHandler)
async findManyViewFilter(
@Args() args: FindManyViewFilterArgs,
@UserAbility() ability: AppAbility,
@PrismaSelector({ modelName: 'ViewFilter' })
prismaSelect: PrismaSelect<'ViewFilter'>,
): Promise<Partial<ViewFilter>[]> {
return this.viewFilterService.findMany({
where: args.where
? {
AND: [args.where, accessibleBy(ability).ViewFilter],
}
: accessibleBy(ability).ViewFilter,
orderBy: args.orderBy,
cursor: args.cursor,
take: args.take,
skip: args.skip,
distinct: args.distinct,
select: prismaSelect.value,
});
}
@Mutation(() => ViewFilter)
@UseGuards(AbilityGuard)
@CheckAbilities(UpdateViewFilterAbilityHandler)
async updateOneViewFilter(
@Args() args: UpdateOneViewFilterArgs,
@PrismaSelector({ modelName: 'ViewFilter' })
prismaSelect: PrismaSelect<'ViewFilter'>,
): Promise<Partial<ViewFilter>> {
return this.viewFilterService.update({
data: args.data,
where: args.where,
select: prismaSelect.value,
} as Prisma.ViewFilterUpdateArgs);
}
@Mutation(() => AffectedRows, {
nullable: false,
})
@UseGuards(AbilityGuard)
@CheckAbilities(DeleteViewFilterAbilityHandler)
async deleteManyViewFilter(
@Args() args: DeleteManyViewFilterArgs,
): Promise<AffectedRows> {
return this.viewFilterService.deleteMany({
where: args.where,
});
}
}

32
server/src/core/view/resolvers/view-sort.resolver.spec.ts
View File

@ -1,32 +0,0 @@
import { Test, TestingModule } from '@nestjs/testing';
import { ViewSortService } from 'src/core/view/services/view-sort.service';
import { AbilityFactory } from 'src/ability/ability.factory';
import { ViewSortResolver } from './view-sort.resolver';
describe('ViewSortResolver', () => {
let resolver: ViewSortResolver;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
ViewSortResolver,
{
provide: ViewSortService,
useValue: {},
},
{
provide: AbilityFactory,
useValue: {},
},
],
}).compile();
resolver = module.get<ViewSortResolver>(ViewSortResolver);
});
it('should be defined', () => {
expect(resolver).toBeDefined();
});
});

102
server/src/core/view/resolvers/view-sort.resolver.ts
View File

@ -1,102 +0,0 @@
import { UseGuards } from '@nestjs/common';
import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
import { accessibleBy } from '@casl/prisma';
import { Prisma, Workspace } from '@prisma/client';
import { AppAbility } from 'src/ability/ability.factory';
import {
CreateViewSortAbilityHandler,
DeleteViewSortAbilityHandler,
ReadViewSortAbilityHandler,
UpdateViewSortAbilityHandler,
} from 'src/ability/handlers/view-sort.ability-handler';
import { FindManyViewSortArgs } from 'src/core/@generated/view-sort/find-many-view-sort.args';
import { ViewSort } from 'src/core/@generated/view-sort/view-sort.model';
import { ViewSortService } from 'src/core/view/services/view-sort.service';
import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
import {
PrismaSelect,
PrismaSelector,
} from 'src/decorators/prisma-select.decorator';
import { UserAbility } from 'src/decorators/user-ability.decorator';
import { AbilityGuard } from 'src/guards/ability.guard';
import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
import { UpdateOneViewSortArgs } from 'src/core/@generated/view-sort/update-one-view-sort.args';
import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
import { AffectedRows } from 'src/core/@generated/prisma/affected-rows.output';
import { DeleteManyViewSortArgs } from 'src/core/@generated/view-sort/delete-many-view-sort.args';
import { CreateManyViewSortArgs } from 'src/core/@generated/view-sort/create-many-view-sort.args';
@UseGuards(JwtAuthGuard)
@Resolver(() => ViewSort)
export class ViewSortResolver {
constructor(private readonly viewSortService: ViewSortService) {}
@Mutation(() => AffectedRows)
@UseGuards(AbilityGuard)
@CheckAbilities(CreateViewSortAbilityHandler)
async createManyViewSort(
@Args() args: CreateManyViewSortArgs,
@AuthWorkspace() workspace: Workspace,
): Promise<AffectedRows> {
return this.viewSortService.createMany({
data: args.data.map((data) => ({
...data,
workspaceId: workspace.id,
})),
});
}
@Query(() => [ViewSort])
@UseGuards(AbilityGuard)
@CheckAbilities(ReadViewSortAbilityHandler)
async findManyViewSort(
@Args() args: FindManyViewSortArgs,
@UserAbility() ability: AppAbility,
@PrismaSelector({ modelName: 'ViewSort' })
prismaSelect: PrismaSelect<'ViewSort'>,
): Promise<Partial<ViewSort>[]> {
return this.viewSortService.findMany({
where: args.where
? {
AND: [args.where, accessibleBy(ability).ViewSort],
}
: accessibleBy(ability).ViewSort,
orderBy: args.orderBy,
cursor: args.cursor,
take: args.take,
skip: args.skip,
distinct: args.distinct,
select: prismaSelect.value,
});
}
@Mutation(() => ViewSort)
@UseGuards(AbilityGuard)
@CheckAbilities(UpdateViewSortAbilityHandler)
async updateOneViewSort(
@Args() args: UpdateOneViewSortArgs,
@PrismaSelector({ modelName: 'ViewSort' })
prismaSelect: PrismaSelect<'ViewSort'>,
): Promise<Partial<ViewSort>> {
return this.viewSortService.update({
data: args.data,
where: args.where,
select: prismaSelect.value,
} as Prisma.ViewSortUpdateArgs);
}
@Mutation(() => AffectedRows, {
nullable: false,
})
@UseGuards(AbilityGuard)
@CheckAbilities(DeleteViewSortAbilityHandler)
async deleteManyViewSort(
@Args() args: DeleteManyViewSortArgs,
): Promise<AffectedRows> {
return this.viewSortService.deleteMany({
where: args.where,
});
}
}

194
server/src/core/view/resolvers/view.resolver.ts
View File

@ -1,194 +0,0 @@
import {
BadRequestException,
ForbiddenException,
NotFoundException,
UseGuards,
} from '@nestjs/common';
import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
import { accessibleBy } from '@casl/prisma';
import { Prisma, Workspace } from '@prisma/client';
import { AppAbility } from 'src/ability/ability.factory';
import {
CreateViewAbilityHandler,
DeleteViewAbilityHandler,
ReadViewAbilityHandler,
UpdateViewAbilityHandler,
} from 'src/ability/handlers/view.ability-handler';
import { AffectedRows } from 'src/core/@generated/prisma/affected-rows.output';
import { CreateManyViewArgs } from 'src/core/@generated/view/create-many-view.args';
import { CreateOneViewArgs } from 'src/core/@generated/view/create-one-view.args';
import { DeleteManyViewArgs } from 'src/core/@generated/view/delete-many-view.args';
import { DeleteOneViewArgs } from 'src/core/@generated/view/delete-one-view.args';
import { FindManyViewArgs } from 'src/core/@generated/view/find-many-view.args';
import { UpdateOneViewArgs } from 'src/core/@generated/view/update-one-view.args';
import { View } from 'src/core/@generated/view/view.model';
import { ViewService } from 'src/core/view/services/view.service';
import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
import {
PrismaSelect,
PrismaSelector,
} from 'src/decorators/prisma-select.decorator';
import { UserAbility } from 'src/decorators/user-ability.decorator';
import { AbilityGuard } from 'src/guards/ability.guard';
import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
@UseGuards(JwtAuthGuard)
@Resolver(() => View)
export class ViewResolver {
constructor(private readonly viewService: ViewService) {}
@Mutation(() => View, {
nullable: false,
})
@UseGuards(AbilityGuard)
@CheckAbilities(CreateViewAbilityHandler)
async createOneView(
@Args() args: CreateOneViewArgs,
@AuthWorkspace() workspace: Workspace,
@PrismaSelector({ modelName: 'View' })
prismaSelect: PrismaSelect<'View'>,
): Promise<Partial<View>> {
return this.viewService.create({
data: {
...args.data,
workspace: { connect: { id: workspace.id } },
},
select: prismaSelect.value,
} as Prisma.ViewCreateArgs);
}
@Mutation(() => AffectedRows)
@UseGuards(AbilityGuard)
@CheckAbilities(CreateViewAbilityHandler)
async createManyView(
@Args() args: CreateManyViewArgs,
@AuthWorkspace() workspace: Workspace,
): Promise<AffectedRows> {
return this.viewService.createMany({
data: args.data.map((data) => ({
...data,
workspaceId: workspace.id,
})),
});
}
@Query(() => [View])
@UseGuards(AbilityGuard)
@CheckAbilities(ReadViewAbilityHandler)
async findManyView(
@Args() args: FindManyViewArgs,
@UserAbility() ability: AppAbility,
@PrismaSelector({ modelName: 'View' })
prismaSelect: PrismaSelect<'View'>,
): Promise<Partial<View>[]> {
return this.viewService.findMany({
where: args.where
? {
AND: [args.where, accessibleBy(ability).View],
}
: accessibleBy(ability).View,
orderBy: args.orderBy,
cursor: args.cursor,
take: args.take,
skip: args.skip,
distinct: args.distinct,
select: prismaSelect.value,
});
}
@Mutation(() => View)
@UseGuards(AbilityGuard)
@CheckAbilities(UpdateViewAbilityHandler)
async updateOneView(
@Args() args: UpdateOneViewArgs,
@PrismaSelector({ modelName: 'View' })
prismaSelect: PrismaSelect<'View'>,
): Promise<Partial<View>> {
return this.viewService.update({
data: args.data,
where: args.where,
select: prismaSelect.value,
} as Prisma.ViewUpdateArgs);
}
@Mutation(() => View, {
nullable: false,
})
@UseGuards(AbilityGuard)
@CheckAbilities(DeleteViewAbilityHandler)
async deleteOneView(
@Args() args: DeleteOneViewArgs,
@AuthWorkspace() workspace: Workspace,
): Promise<View> {
const viewToDelete = await this.viewService.findUnique({
where: args.where,
});
if (!viewToDelete) {
throw new NotFoundException();
}
const { objectId } = viewToDelete;
const viewsNb = await this.viewService.count({
where: {
objectId: { equals: objectId },
workspaceId: { equals: workspace.id },
},
});
if (viewsNb <= 1) {
throw new ForbiddenException(
`Deleting last '${objectId}' view is not allowed`,
);
}
return this.viewService.delete({
where: args.where,
});
}
@Mutation(() => AffectedRows, {
nullable: false,
})
@UseGuards(AbilityGuard)
@CheckAbilities(DeleteViewAbilityHandler)
async deleteManyView(
@Args() args: DeleteManyViewArgs,
@AuthWorkspace() workspace: Workspace,
): Promise<AffectedRows> {
const viewsToDelete = await this.viewService.findMany({
where: args.where,
});
if (!viewsToDelete.length) return { count: 0 };
const { objectId } = viewsToDelete[0];
if (viewsToDelete.some((view) => view.objectId !== objectId)) {
throw new BadRequestException(
`Views must have the same objectId '${objectId}'`,
);
}
const viewsNb = await this.viewService.count({
where: {
objectId: { equals: objectId },
workspaceId: { equals: workspace.id },
},
});
if (viewsNb - viewsToDelete.length <= 0) {
throw new ForbiddenException(
`Deleting last '${objectId}' view is not allowed`,
);
}
return this.viewService.deleteMany({
where: args.where,
});
}
}

124
server/src/core/view/seed-data/views.json
View File

@ -1,124 +0,0 @@
[
{
"name": "All Companies",
"objectId": "company",
"type": "Table",
"fields": [
{
"key": "name",
"name": "Name",
"size": 180
},
{
"key": "domainName",
"name": "URL",
"size": 100
},
{
"key": "accountOwner",
"name": "Account Owner",
"size": 150
},
{
"key": "createdAt",
"name": "Creation",
"size": 150
},
{
"key": "employees",
"name": "Employees",
"size": 150
},
{
"key": "linkedin",
"name": "LinkedIn",
"size": 170
},
{
"key": "address",
"name": "Address",
"size": 170
},
{
"key": "annualRecurringRevenue",
"name": "ARR",
"size": 150
}
]
},
{
"name": "All People",
"objectId": "person",
"type": "Table",
"fields": [
{
"key": "displayName",
"name": "People",
"size": 210
},
{
"key": "email",
"name": "Email",
"size": 150
},
{
"key": "company",
"name": "Company",
"size": 150
},
{
"key": "phone",
"name": "Phone",
"size": 150
},
{
"key": "createdAt",
"name": "Creation",
"size": 150
},
{
"key": "city",
"name": "City",
"size": 150
},
{
"key": "jobTitle",
"name": "Job title",
"size": 150
},
{
"key": "linkedin",
"name": "LinkedIn",
"size": 150
},
{
"key": "x",
"name": "Twitter",
"size": 150
}
]
},
{
"name": "All Opportunities",
"objectId": "company",
"type": "Pipeline",
"fields": [
{
"key": "closeDate",
"name": "Close Date"
},
{
"key": "amount",
"name": "Amount"
},
{
"key": "probability",
"name": "Probability"
},
{
"key": "pointOfContact",
"name": "Point of Contact"
}
]
}
]

28
server/src/core/view/services/view-field.service.spec.ts
View File

@ -1,28 +0,0 @@
import { Test, TestingModule } from '@nestjs/testing';
import { PrismaService } from 'src/database/prisma.service';
import { prismaMock } from 'src/database/client-mock/jest-prisma-singleton';
import { ViewFieldService } from './view-field.service';
describe('ViewFieldService', () => {
let service: ViewFieldService;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
ViewFieldService,
{
provide: PrismaService,
useValue: prismaMock,
},
],
}).compile();
service = module.get<ViewFieldService>(ViewFieldService);
});
it('should be defined', () => {
expect(service).toBeDefined();
});
});

39
server/src/core/view/services/view-field.service.ts
View File

@ -1,39 +0,0 @@
import { Injectable } from '@nestjs/common';
import { PrismaService } from 'src/database/prisma.service';
@Injectable()
export class ViewFieldService {
constructor(private readonly prismaService: PrismaService) {}
// Find
findFirst = this.prismaService.client.viewField.findFirst;
findFirstOrThrow = this.prismaService.client.viewField.findFirstOrThrow;
findUnique = this.prismaService.client.viewField.findUnique;
findUniqueOrThrow = this.prismaService.client.viewField.findUniqueOrThrow;
findMany = this.prismaService.client.viewField.findMany;
// Create
create = this.prismaService.client.viewField.create;
createMany = this.prismaService.client.viewField.createMany;
// Update
update = this.prismaService.client.viewField.update;
upsert = this.prismaService.client.viewField.upsert;
updateMany = this.prismaService.client.viewField.updateMany;
// Delete
delete = this.prismaService.client.viewField.delete;
deleteMany = this.prismaService.client.viewField.deleteMany;
// Aggregate
aggregate = this.prismaService.client.viewField.aggregate;
// Count
count = this.prismaService.client.viewField.count;
// GroupBy
groupBy = this.prismaService.client.viewField.groupBy;
}

39
server/src/core/view/services/view-filter.service.ts
View File

@ -1,39 +0,0 @@
import { Injectable } from '@nestjs/common';
import { PrismaService } from 'src/database/prisma.service';
@Injectable()
export class ViewFilterService {
constructor(private readonly prismaService: PrismaService) {}
// Find
findFirst = this.prismaService.client.viewFilter.findFirst;
findFirstOrThrow = this.prismaService.client.viewFilter.findFirstOrThrow;
findUnique = this.prismaService.client.viewFilter.findUnique;
findUniqueOrThrow = this.prismaService.client.viewFilter.findUniqueOrThrow;
findMany = this.prismaService.client.viewFilter.findMany;
// Create
create = this.prismaService.client.viewFilter.create;
createMany = this.prismaService.client.viewFilter.createMany;
// Update
update = this.prismaService.client.viewFilter.update;
upsert = this.prismaService.client.viewFilter.upsert;
updateMany = this.prismaService.client.viewFilter.updateMany;
// Delete
delete = this.prismaService.client.viewFilter.delete;
deleteMany = this.prismaService.client.viewFilter.deleteMany;
// Aggregate
aggregate = this.prismaService.client.viewFilter.aggregate;
// Count
count = this.prismaService.client.viewFilter.count;
// GroupBy
groupBy = this.prismaService.client.viewFilter.groupBy;
}

28
server/src/core/view/services/view-sort.service.spec.ts
View File

@ -1,28 +0,0 @@
import { Test, TestingModule } from '@nestjs/testing';
import { PrismaService } from 'src/database/prisma.service';
import { prismaMock } from 'src/database/client-mock/jest-prisma-singleton';
import { ViewSortService } from './view-sort.service';
describe('ViewSortService', () => {
let service: ViewSortService;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
ViewSortService,
{
provide: PrismaService,
useValue: prismaMock,
},
],
}).compile();
service = module.get<ViewSortService>(ViewSortService);
});
it('should be defined', () => {
expect(service).toBeDefined();
});
});

39
server/src/core/view/services/view-sort.service.ts
View File

@ -1,39 +0,0 @@
import { Injectable } from '@nestjs/common';
import { PrismaService } from 'src/database/prisma.service';
@Injectable()
export class ViewSortService {
constructor(private readonly prismaService: PrismaService) {}
// Find
findFirst = this.prismaService.client.viewSort.findFirst;
findFirstOrThrow = this.prismaService.client.viewSort.findFirstOrThrow;
findUnique = this.prismaService.client.viewSort.findUnique;
findUniqueOrThrow = this.prismaService.client.viewSort.findUniqueOrThrow;
findMany = this.prismaService.client.viewSort.findMany;
// Create
create = this.prismaService.client.viewSort.create;
createMany = this.prismaService.client.viewSort.createMany;
// Update
update = this.prismaService.client.viewSort.update;
upsert = this.prismaService.client.viewSort.upsert;
updateMany = this.prismaService.client.viewSort.updateMany;
// Delete
delete = this.prismaService.client.viewSort.delete;
deleteMany = this.prismaService.client.viewSort.deleteMany;
// Aggregate
aggregate = this.prismaService.client.viewSort.aggregate;
// Count
count = this.prismaService.client.viewSort.count;
// GroupBy
groupBy = this.prismaService.client.viewSort.groupBy;
}

68
server/src/core/view/services/view.service.ts
View File

@ -1,68 +0,0 @@
import { Injectable } from '@nestjs/common';
import { ViewType } from '@prisma/client';
import { PrismaService } from 'src/database/prisma.service';
import seedViews from 'src/core/view/seed-data/views.json';
@Injectable()
export class ViewService {
constructor(private readonly prismaService: PrismaService) {}
// Find
findFirst = this.prismaService.client.view.findFirst;
findFirstOrThrow = this.prismaService.client.view.findFirstOrThrow;
findUnique = this.prismaService.client.view.findUnique;
findUniqueOrThrow = this.prismaService.client.view.findUniqueOrThrow;
findMany = this.prismaService.client.view.findMany;
// Create
create = this.prismaService.client.view.create;
createMany = this.prismaService.client.view.createMany;
// Update
update = this.prismaService.client.view.update;
upsert = this.prismaService.client.view.upsert;
updateMany = this.prismaService.client.view.updateMany;
// Delete
delete = this.prismaService.client.view.delete;
deleteMany = this.prismaService.client.view.deleteMany;
// Aggregate
aggregate = this.prismaService.client.view.aggregate;
// Count
count = this.prismaService.client.view.count;
// GroupBy
groupBy = this.prismaService.client.view.groupBy;
// Custom
createDefaultViews({ workspaceId }: { workspaceId: string }) {
return Promise.all(
seedViews.map(async ({ fields, ...viewInput }) => {
const view = await this.create({
data: {
...viewInput,
type: viewInput.type as ViewType,
workspace: { connect: { id: workspaceId } },
},
});
await this.prismaService.client.viewField.createMany({
data: fields.map((viewField, index) => ({
...viewField,
index,
isVisible: true,
objectId: view.objectId,
viewId: view.id,
workspaceId,
})),
});
}),
);
}
}

29
server/src/core/view/view.module.ts
View File

@ -1,29 +0,0 @@
import { Module } from '@nestjs/common';
import { AbilityModule } from 'src/ability/ability.module';
import { PrismaModule } from 'src/database/prisma.module';
import { ViewFieldService } from './services/view-field.service';
import { ViewFieldResolver } from './resolvers/view-field.resolver';
import { ViewSortService } from './services/view-sort.service';
import { ViewSortResolver } from './resolvers/view-sort.resolver';
import { ViewService } from './services/view.service';
import { ViewResolver } from './resolvers/view.resolver';
import { ViewFilterService } from './services/view-filter.service';
import { ViewFilterResolver } from './resolvers/view-filter.resolver';
@Module({
imports: [AbilityModule, PrismaModule],
providers: [
ViewService,
ViewFieldService,
ViewFilterService,
ViewSortService,
ViewResolver,
ViewFieldResolver,
ViewFilterResolver,
ViewSortResolver,
],
exports: [ViewService],
})
export class ViewModule {}

5
server/src/core/workspace/services/workspace.service.spec.ts
View File

@ -7,7 +7,6 @@ import { PipelineStageService } from 'src/core/pipeline/services/pipeline-stage.
import { PersonService } from 'src/core/person/person.service';
import { CompanyService } from 'src/core/company/company.service';
import { PipelineProgressService } from 'src/core/pipeline/services/pipeline-progress.service';
import { ViewService } from 'src/core/view/services/view.service';
import { TenantInitialisationService } from 'src/metadata/tenant-initialisation/tenant-initialisation.service';
import { WorkspaceService } from './workspace.service';
@ -43,10 +42,6 @@ describe('WorkspaceService', () => {
provide: PipelineProgressService,
useValue: {},
},
{
provide: ViewService,
useValue: {},
},
{
provide: TenantInitialisationService,
useValue: {},

11
server/src/core/workspace/services/workspace.service.ts
View File

@ -8,7 +8,6 @@ import { PersonService } from 'src/core/person/person.service';
import { PipelineProgressService } from 'src/core/pipeline/services/pipeline-progress.service';
import { PipelineStageService } from 'src/core/pipeline/services/pipeline-stage.service';
import { PipelineService } from 'src/core/pipeline/services/pipeline.service';
import { ViewService } from 'src/core/view/services/view.service';
import { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
import { TenantInitialisationService } from 'src/metadata/tenant-initialisation/tenant-initialisation.service';
@ -22,7 +21,6 @@ export class WorkspaceService {
private readonly personService: PersonService,
private readonly pipelineStageService: PipelineStageService,
private readonly pipelineProgressService: PipelineProgressService,
private readonly viewService: ViewService,
private readonly tenantInitialisationService: TenantInitialisationService,
) {}
@ -90,11 +88,6 @@ export class WorkspaceService {
workspaceId: workspace.id,
});
// Create default views
await this.viewService.createDefaultViews({
workspaceId: workspace.id,
});
return workspace;
}
@ -123,7 +116,6 @@ export class WorkspaceService {
comment,
activityTarget,
activity,
view,
} = this.prismaService.client;
const activitys = await activity.findMany({
@ -163,9 +155,6 @@ export class WorkspaceService {
activity.deleteMany({
where,
}),
view.deleteMany({
where,
}),
refreshToken.deleteMany({
where: { userId },
}),

2
server/src/core/workspace/workspace.module.ts
View File

@ -4,7 +4,6 @@ import { FileUploadService } from 'src/core/file/services/file-upload.service';
import { PipelineModule } from 'src/core/pipeline/pipeline.module';
import { CompanyModule } from 'src/core/company/company.module';
import { PersonModule } from 'src/core/person/person.module';
import { ViewModule } from 'src/core/view/view.module';
import { TenantInitialisationModule } from 'src/metadata/tenant-initialisation/tenant-initialisation.module';
import { AbilityModule } from 'src/ability/ability.module';
import { PrismaModule } from 'src/database/prisma.module';
@ -20,7 +19,6 @@ import { WorkspaceResolver } from './resolvers/workspace.resolver';
PipelineModule,
CompanyModule,
PersonModule,
ViewModule,
TenantInitialisationModule,
PrismaModule,
],

52
server/src/database/migrations/20231028153754_refactor_views_positions/migration.sql Normal file
View File

@ -0,0 +1,52 @@
/*
Warnings:
- You are about to drop the column `index` on the `pipeline_stages` table. All the data in the column will be lost.
- You are about to drop the `viewFields` table. If the table is not empty, all the data it contains will be lost.
- You are about to drop the `viewFilters` table. If the table is not empty, all the data it contains will be lost.
- You are about to drop the `viewSorts` table. If the table is not empty, all the data it contains will be lost.
- You are about to drop the `views` table. If the table is not empty, all the data it contains will be lost.
*/
-- DropForeignKey
ALTER TABLE "viewFields" DROP CONSTRAINT "viewFields_viewId_fkey";
-- DropForeignKey
ALTER TABLE "viewFields" DROP CONSTRAINT "viewFields_workspaceId_fkey";
-- DropForeignKey
ALTER TABLE "viewFilters" DROP CONSTRAINT "viewFilters_viewId_fkey";
-- DropForeignKey
ALTER TABLE "viewFilters" DROP CONSTRAINT "viewFilters_workspaceId_fkey";
-- DropForeignKey
ALTER TABLE "viewSorts" DROP CONSTRAINT "viewSorts_viewId_fkey";
-- DropForeignKey
ALTER TABLE "viewSorts" DROP CONSTRAINT "viewSorts_workspaceId_fkey";
-- DropForeignKey
ALTER TABLE "views" DROP CONSTRAINT "views_workspaceId_fkey";
-- AlterTable
ALTER TABLE "pipeline_stages" DROP COLUMN "index",
ADD COLUMN "position" INTEGER;
-- DropTable
DROP TABLE "viewFields";
-- DropTable
DROP TABLE "viewFilters";
-- DropTable
DROP TABLE "viewSorts";
-- DropTable
DROP TABLE "views";
-- DropEnum
DROP TYPE "ViewFilterOperand";
-- DropEnum
DROP TYPE "ViewSortDirection";

117
server/src/database/schema.prisma
View File

@ -174,10 +174,6 @@ model Workspace {
pipelineStages PipelineStage[]
pipelineProgresses PipelineProgress[]
activityTargets ActivityTarget[]
viewFields ViewField[]
viewFilters ViewFilter[]
views View[]
viewSorts ViewSort[]
apiKeys ApiKey[]
webHooks WebHook[]
@ -657,19 +653,19 @@ model Pipeline {
model PipelineStage {
/// @Validator.IsString()
/// @Validator.IsOptional()
id String @id @default(uuid())
id String @id @default(uuid())
/// @Validator.IsString()
/// @Validator.IsOptional()
name String
name String
/// @Validator.IsString()
/// @Validator.IsOptional()
type String
type String
/// @Validator.IsOptional()
/// @Validator.IsString()
color String
color String
/// @Validator.IsNumber()
/// @Validator.IsOptional()
index Int?
position Int?
pipelineProgresses PipelineProgress[]
///
@ -799,97 +795,6 @@ enum ViewType {
Pipeline
}
model View {
/// @Validator.IsString()
/// @Validator.IsOptional()
id String @id @default(uuid())
fields ViewField[]
filters ViewFilter[]
name String
objectId String
sorts ViewSort[]
type ViewType
/// @TypeGraphQL.omit(input: true, output: true)
workspace Workspace @relation(fields: [workspaceId], references: [id])
/// @TypeGraphQL.omit(input: true, output: true)
workspaceId String
@@map("views")
}
enum ViewFilterOperand {
Contains
DoesNotContain
GreaterThan
LessThan
Is
IsNot
IsNotNull
}
model ViewFilter {
displayValue String
key String
name String
operand ViewFilterOperand
value String
view View @relation(fields: [viewId], references: [id], onDelete: Cascade)
viewId String
/// @TypeGraphQL.omit(input: true, output: true)
workspace Workspace @relation(fields: [workspaceId], references: [id])
/// @TypeGraphQL.omit(input: true, output: true)
workspaceId String
@@id([viewId, key])
@@map("viewFilters")
}
enum ViewSortDirection {
asc
desc
}
model ViewSort {
direction ViewSortDirection
key String
name String
view View @relation(fields: [viewId], references: [id], onDelete: Cascade)
viewId String
/// @TypeGraphQL.omit(input: true, output: true)
workspace Workspace @relation(fields: [workspaceId], references: [id])
/// @TypeGraphQL.omit(input: true, output: true)
workspaceId String
@@id([viewId, key])
@@map("viewSorts")
}
model ViewField {
index Float
isVisible Boolean
key String
name String
objectId String
size Int?
view View @relation(fields: [viewId], references: [id], onDelete: Cascade)
viewId String
/// @TypeGraphQL.omit(input: true, output: true)
workspace Workspace @relation(fields: [workspaceId], references: [id])
/// @TypeGraphQL.omit(input: true, output: true)
workspaceId String
@@id([viewId, key])
@@map("viewFields")
}
model ApiKey {
/// @Validator.IsString()
/// @Validator.IsOptional()
@ -913,17 +818,17 @@ model ApiKey {
model WebHook {
/// @Validator.IsString()
/// @Validator.IsOptional()
id String @id @default(uuid())
id String @id @default(uuid())
/// @TypeGraphQL.omit(input: true, output: true)
workspace Workspace @relation(fields: [workspaceId], references: [id])
/// @TypeGraphQL.omit(input: true, output: true)
workspaceId String
targetUrl String
operation String
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
targetUrl String
operation String
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
/// @TypeGraphQL.omit(input: true, output: true)
deletedAt DateTime?
deletedAt DateTime?
@@map("web_hooks")
}

2
server/src/database/seeds/index.ts
View File

@ -6,7 +6,6 @@ import { seedPeople } from './people';
import { seedComments } from './comments';
import { seedUsers } from './users';
import { seedPipelines } from './pipelines';
import { seedViews } from './views';
import { seedMetadata } from './metadata';
const seed = async () => {
@ -17,7 +16,6 @@ const seed = async () => {
await seedPeople(prisma);
await seedComments(prisma);
await seedPipelines(prisma);
await seedViews(prisma);
await seedMetadata(prisma);
await prisma.$disconnect();
};

22
server/src/database/seeds/pipelines.ts
View File

@ -19,7 +19,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-fe256b39-3ec3-4fe3-8998-b76aa0bfb600',
name: 'New',
color: 'red',
index: 0,
position: 0,
type: 'open',
pipelineId: 'twenty-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-7ed9d212-1c25-4d02-bf25-6aeccf7ea419',
@ -33,7 +33,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-fe256b39-3ec3-4fe4-8998-b76aa0bfb600',
name: 'Screening',
color: 'purple',
index: 1,
position: 1,
type: 'ongoing',
pipelineId: 'twenty-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-7ed9d212-1c25-4d02-bf25-6aeccf7ea419',
@ -47,7 +47,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-fe256b39-3ec3-4fe5-8998-b76aa0bfb600',
name: 'Meeting',
color: 'sky',
index: 2,
position: 2,
type: 'ongoing',
pipelineId: 'twenty-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-7ed9d212-1c25-4d02-bf25-6aeccf7ea419',
@ -61,7 +61,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-fe256b39-3ec3-4fe6-8998-b76aa0bfb600',
name: 'Proposal',
color: 'turquoise',
index: 3,
position: 3,
type: 'ongoing',
pipelineId: 'twenty-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-7ed9d212-1c25-4d02-bf25-6aeccf7ea419',
@ -75,7 +75,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-fe256b39-3ec3-4fe7-8998-b76aa0bfb600',
name: 'Customer',
color: 'yellow',
index: 4,
position: 4,
type: 'won',
pipelineId: 'twenty-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-7ed9d212-1c25-4d02-bf25-6aeccf7ea419',
@ -149,7 +149,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-fe256b39-3ec3-4fe3-8998-a76aa0bfb600',
name: 'New',
color: 'red',
index: 1,
position: 1,
type: 'open',
pipelineId: 'twenty-fe256b39-3ec3-4fe3-8997-b74aa0bfb400',
workspaceId: 'twenty-7ed9d212-1c25-4d02-bf25-6aeccf7ea419',
@ -186,7 +186,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-dev-fe256b39-3ec3-4fe3-8998-b76aa0bfb600',
name: 'New',
color: 'red',
index: 0,
position: 0,
type: 'open',
pipelineId: 'twenty-dev-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-dev-7ed9d212-1c25-4d02-bf25-6aeccf7ea420',
@ -200,7 +200,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-dev-fe256b39-3ec3-4fe4-8998-b76aa0bfb600',
name: 'Screening',
color: 'purple',
index: 1,
position: 1,
type: 'ongoing',
pipelineId: 'twenty-dev-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-dev-7ed9d212-1c25-4d02-bf25-6aeccf7ea420',
@ -214,7 +214,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-dev-fe256b39-3ec3-4fe5-8998-b76aa0bfb600',
name: 'Meeting',
color: 'sky',
index: 2,
position: 2,
type: 'ongoing',
pipelineId: 'twenty-dev-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-dev-7ed9d212-1c25-4d02-bf25-6aeccf7ea420',
@ -228,7 +228,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-dev-fe256b39-3ec3-4fe6-8998-b76aa0bfb600',
name: 'Proposal',
color: 'turquoise',
index: 3,
position: 3,
type: 'ongoing',
pipelineId: 'twenty-dev-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-dev-7ed9d212-1c25-4d02-bf25-6aeccf7ea420',
@ -242,7 +242,7 @@ export const seedPipelines = async (prisma: PrismaClient) => {
id: 'twenty-dev-fe256b39-3ec3-4fe7-8998-b76aa0bfb600',
name: 'Customer',
color: 'yellow',
index: 4,
position: 4,
type: 'won',
pipelineId: 'twenty-dev-fe256b39-3ec3-4fe3-8997-b75aa0bfb400',
workspaceId: 'twenty-dev-7ed9d212-1c25-4d02-bf25-6aeccf7ea420',

201
server/src/database/seeds/views.ts
View File

@ -1,201 +0,0 @@
import { PrismaClient } from '@prisma/client';
export const seedViews = async (prisma: PrismaClient) => {
const workspaceId = 'twenty-7ed9d212-1c25-4d02-bf25-6aeccf7ea419';
const companyViewId = 'twenty-5e924b69-a619-41bf-bd31-a9e8551fc9d1';
const personViewId = 'twenty-db9e6c85-c091-4fd6-88b1-c1830f5e90d1';
const opportunitiesViewId = 'twenty-6abb47a2-7a91-4679-a538-59946f0c06a9';
await prisma.view.upsert({
where: { id: companyViewId },
update: {},
create: {
id: companyViewId,
name: 'All Companies',
objectId: 'company',
type: 'Table',
workspaceId,
},
});
await Promise.all(
[
{
key: 'name',
name: 'Name',
size: 180,
},
{
key: 'domainName',
name: 'URL',
size: 100,
},
{
key: 'accountOwner',
name: 'Account Owner',
size: 150,
},
{
key: 'createdAt',
name: 'Creation',
size: 150,
},
{
key: 'employees',
name: 'Employees',
size: 150,
},
{
key: 'linkedin',
name: 'LinkedIn',
size: 170,
},
{
key: 'address',
name: 'Address',
size: 170,
},
{
key: 'annualRecurringRevenue',
name: 'ARR',
size: 150,
},
].map((viewField, index) =>
prisma.viewField.upsert({
where: { viewId_key: { key: viewField.key, viewId: companyViewId } },
update: {},
create: {
...viewField,
index,
isVisible: true,
objectId: 'company',
viewId: companyViewId,
workspaceId,
},
}),
),
);
await prisma.view.upsert({
where: { id: personViewId },
update: {},
create: {
id: personViewId,
name: 'All People',
objectId: 'person',
type: 'Table',
workspaceId,
},
});
await Promise.all(
[
{
key: 'displayName',
name: 'People',
size: 210,
},
{
key: 'email',
name: 'Email',
size: 150,
},
{
key: 'company',
name: 'Company',
size: 150,
},
{
key: 'phone',
name: 'Phone',
size: 150,
},
{
key: 'createdAt',
name: 'Creation',
size: 150,
},
{
key: 'city',
name: 'City',
size: 150,
},
{
key: 'jobTitle',
name: 'Job title',
size: 150,
},
{
key: 'linkedin',
name: 'LinkedIn',
size: 150,
},
{
key: 'x',
name: 'Twitter',
size: 150,
},
].map((viewField, index) =>
prisma.viewField.upsert({
where: { viewId_key: { key: viewField.key, viewId: personViewId } },
update: {},
create: {
...viewField,
index,
isVisible: true,
objectId: 'person',
viewId: personViewId,
workspaceId,
},
}),
),
);
await prisma.view.upsert({
where: { id: opportunitiesViewId },
update: {},
create: {
id: opportunitiesViewId,
name: 'All Opportunities',
objectId: 'company',
type: 'Pipeline',
workspaceId,
},
});
await Promise.all(
[
{
key: 'closeDate',
name: 'Close Date',
},
{
key: 'amount',
name: 'Amount',
},
{
key: 'probability',
name: 'Probability',
},
{
key: 'pointOfContact',
name: 'Point of Contact',
},
].map((viewField, index) =>
prisma.viewField.upsert({
where: {
viewId_key: { key: viewField.key, viewId: opportunitiesViewId },
},
update: {},
create: {
...viewField,
index,
isVisible: true,
objectId: 'company',
viewId: opportunitiesViewId,
workspaceId,
},
}),
),
);
};

11
server/src/metadata/tenant-initialisation/standard-objects/view-fields/view-fields.metadata.json
View File

@ -7,17 +7,6 @@
"description": "(System) View Fields",
"icon": "arrows-sort",
"fields": [
{
"type": "text",
"name": "objectId",
"label": "Object Id",
"targetColumnMap": {
"value": "objectId"
},
"description": "View Field target object",
"icon": null,
"isNullable": false
},
{
"type": "text",
"name": "fieldId",

90
server/src/metadata/tenant-initialisation/standard-objects/view-fields/view-fields.seeds.json
View File

@ -1,6 +1,5 @@
[
{
"objectId": "1a8487a0-480c-434e-b4c7-e22408b97047",
"fieldId": "name",
"viewId": "10bec73c-0aea-4cc4-a3b2-8c2186f29b43",
"position": 0,
@ -9,7 +8,6 @@
},
{
"objectId": "company",
"fieldId": "name",
"viewId": "37a8a866-eb17-4e76-9382-03143a2f6a80",
"position": 0,
@ -17,7 +15,6 @@
"size": 180
},
{
"objectId": "company",
"fieldId": "domainName",
"viewId": "37a8a866-eb17-4e76-9382-03143a2f6a80",
"position": 1,
@ -25,7 +22,6 @@
"size": 100
},
{
"objectId": "company",
"fieldId": "accountOwner",
"viewId": "37a8a866-eb17-4e76-9382-03143a2f6a80",
"position": 2,
@ -33,11 +29,95 @@
"size": 150
},
{
"objectId": "company",
"fieldId": "createdAt",
"viewId": "37a8a866-eb17-4e76-9382-03143a2f6a80",
"position": 3,
"isVisible": true,
"size": 150
},
{
"fieldId": "employees",
"viewId": "37a8a866-eb17-4e76-9382-03143a2f6a80",
"position": 4,
"isVisible": true,
"size": 150
},
{
"fieldId": "linkedin",
"viewId": "37a8a866-eb17-4e76-9382-03143a2f6a80",
"position": 5,
"isVisible": true,
"size": 170
},
{
"fieldId": "address",
"viewId": "37a8a866-eb17-4e76-9382-03143a2f6a80",
"position": 6,
"isVisible": true,
"size": 170
},
{
"fieldId": "displayName",
"viewId": "6095799e-b48f-4e00-b071-10818083593a",
"position": 0,
"isVisible": true,
"size": 210
},
{
"fieldId": "email",
"viewId": "6095799e-b48f-4e00-b071-10818083593a",
"position": 1,
"isVisible": true,
"size": 150
},
{
"fieldId": "company",
"viewId": "6095799e-b48f-4e00-b071-10818083593a",
"position": 2,
"isVisible": true,
"size": 150
},
{
"fieldId": "phone",
"viewId": "6095799e-b48f-4e00-b071-10818083593a",
"position": 3,
"isVisible": true,
"size": 150
},
{
"fieldId": "createdAt",
"viewId": "6095799e-b48f-4e00-b071-10818083593a",
"position": 4,
"isVisible": true,
"size": 150
},
{
"fieldId": "city",
"viewId": "6095799e-b48f-4e00-b071-10818083593a",
"position": 5,
"isVisible": true,
"size": 150
},
{
"fieldId": "jobTitle",
"viewId": "6095799e-b48f-4e00-b071-10818083593a",
"position": 6,
"isVisible": true,
"size": 150
},
{
"fieldId": "linkedin",
"viewId": "6095799e-b48f-4e00-b071-10818083593a",
"position": 7,
"isVisible": true,
"size": 150
},
{
"fieldId": "x",
"viewId": "6095799e-b48f-4e00-b071-10818083593a",
"position": 8,
"isVisible": true,
"size": 150
}
]

12
server/src/metadata/tenant-initialisation/standard-objects/views/views.seeds.json
View File

@ -3,24 +3,24 @@
"id": "37a8a866-eb17-4e76-9382-03143a2f6a80",
"name": "All companies",
"objectId": "company",
"type": "Table"
"type": "table"
},
{
"id": "6095799e-b48f-4e00-b071-10818083593a",
"name": "All companies",
"name": "All people",
"objectId": "person",
"type": "Table"
"type": "table"
},
{
"id": "e26f66b7-f890-4a5c-b4d2-ec09987b5308",
"name": "All Opportunities",
"name": "All opportunities",
"objectId": "company",
"type": "Pipeline"
"type": "kanban"
},
{
"id": "10bec73c-0aea-4cc4-a3b2-8c2186f29b43",
"name": "All Companies (V2)",
"objectId": "1a8487a0-480c-434e-b4c7-e22408b97047",
"type": "Table"
"type": "table"
}
]

5
server/src/metadata/tenant-migration/migrations/1697618012-addViewFieldTable.ts
View File

@ -9,11 +9,6 @@ export const addViewFieldTable: TenantMigrationTableAction[] = [
name: 'viewField',
action: 'alter',
columns: [
{
name: 'objectId',
type: 'varchar',
action: 'create',
},
{
name: 'fieldId',
type: 'varchar',

4
server/src/utils/prisma-select/model-select-map.ts
View File

@ -17,10 +17,6 @@ export type ModelSelectMap = {
PipelineProgress: Prisma.PipelineProgressSelect;
Attachment: Prisma.AttachmentSelect;
Favorite: Prisma.FavoriteSelect;
View: Prisma.ViewSelect;
ViewFilter: Prisma.ViewFilterSelect;
ViewSort: Prisma.ViewSortSelect;
ViewField: Prisma.ViewFieldSelect;
ApiKey: Prisma.ApiKeySelect;
WebHook: Prisma.WebHookSelect;
};