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

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,
],