Removing Prisma and Grapql-nestjs-prisma resolvers (#2574)

* Some cleaning

* Fix seeds

* Fix all sign in, sign up flow and apiKey optimistic rendering

* Fix
This commit is contained in:
Charles Bochet
2023-11-19 18:25:47 +01:00
committed by GitHub
parent 18dac1a2b6
commit f5e1d7825a
616 changed files with 2220 additions and 23073 deletions
@@ -0,0 +1,26 @@
import { Field, InputType } from '@nestjs/graphql';
import { IsOptional, IsString } from 'class-validator';
@InputType()
export class UpdateWorkspaceInput {
@Field({ nullable: true })
@IsString()
@IsOptional()
domainName?: string;
@Field({ nullable: true })
@IsString()
@IsOptional()
displayName?: string;
@Field({ nullable: true })
@IsString()
@IsOptional()
logo?: string;
@Field({ nullable: true })
@IsString()
@IsOptional()
inviteHash?: string;
}
@@ -1,32 +0,0 @@
import { Test, TestingModule } from '@nestjs/testing';
import { WorkspaceMemberService } from 'src/core/workspace/services/workspace-member.service';
import { AbilityFactory } from 'src/ability/ability.factory';
import { WorkspaceMemberResolver } from './workspace-member.resolver';
describe('WorkspaceMemberResolver', () => {
let resolver: WorkspaceMemberResolver;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
WorkspaceMemberResolver,
{
provide: WorkspaceMemberService,
useValue: {},
},
{
provide: AbilityFactory,
useValue: {},
},
],
}).compile();
resolver = module.get<WorkspaceMemberResolver>(WorkspaceMemberResolver);
});
it('should be defined', () => {
expect(resolver).toBeDefined();
});
});
@@ -1,102 +0,0 @@
import { Args, Query, Resolver, Mutation } from '@nestjs/graphql';
import { UseGuards } from '@nestjs/common';
import { accessibleBy } from '@casl/prisma';
import { Prisma } from '@prisma/client';
import { WorkspaceMember } from 'src/core/@generated/workspace-member/workspace-member.model';
import { AbilityGuard } from 'src/guards/ability.guard';
import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
import {
DeleteWorkspaceMemberAbilityHandler,
ReadWorkspaceMemberAbilityHandler,
UpdateWorkspaceMemberAbilityHandler,
} from 'src/ability/handlers/workspace-member.ability-handler';
import { FindManyWorkspaceMemberArgs } from 'src/core/@generated/workspace-member/find-many-workspace-member.args';
import { UserAbility } from 'src/decorators/user-ability.decorator';
import { AppAbility } from 'src/ability/ability.factory';
import {
PrismaSelect,
PrismaSelector,
} from 'src/decorators/prisma-select.decorator';
import { WorkspaceMemberService } from 'src/core/workspace/services/workspace-member.service';
import { DeleteOneWorkspaceMemberArgs } from 'src/core/@generated/workspace-member/delete-one-workspace-member.args';
import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
import { AuthUser } from 'src/decorators/auth-user.decorator';
import { User } from 'src/core/@generated/user/user.model';
import { UpdateOneWorkspaceMemberArgs } from 'src/core/@generated/workspace-member/update-one-workspace-member.args';
@UseGuards(JwtAuthGuard)
@Resolver(() => WorkspaceMember)
export class WorkspaceMemberResolver {
constructor(
private readonly workspaceMemberService: WorkspaceMemberService,
) {}
@Query(() => [WorkspaceMember])
@UseGuards(AbilityGuard)
@CheckAbilities(ReadWorkspaceMemberAbilityHandler)
async findManyWorkspaceMember(
@Args() args: FindManyWorkspaceMemberArgs,
@UserAbility() ability: AppAbility,
@PrismaSelector({ modelName: 'WorkspaceMember' })
prismaSelect: PrismaSelect<'WorkspaceMember'>,
): Promise<Partial<WorkspaceMember>[]> {
return this.workspaceMemberService.findMany({
...args,
where: args.where
? {
AND: [args.where, accessibleBy(ability).WorkspaceMember],
}
: accessibleBy(ability).WorkspaceMember,
select: prismaSelect.value,
});
}
@Mutation(() => WorkspaceMember)
async allowImpersonation(
@Args('allowImpersonation') allowImpersonation: boolean,
@AuthUser() user: User,
@PrismaSelector({ modelName: 'WorkspaceMember' })
prismaSelect: PrismaSelect<'WorkspaceMember'>,
): Promise<Partial<WorkspaceMember>> {
return this.workspaceMemberService.update({
where: {
userId: user.id,
},
data: {
allowImpersonation,
},
select: prismaSelect.value,
});
}
@Mutation(() => WorkspaceMember)
@UseGuards(AbilityGuard)
@CheckAbilities(DeleteWorkspaceMemberAbilityHandler)
async deleteWorkspaceMember(
@Args() args: DeleteOneWorkspaceMemberArgs,
@PrismaSelector({ modelName: 'WorkspaceMember' })
prismaSelect: PrismaSelect<'WorkspaceMember'>,
): Promise<Partial<WorkspaceMember>> {
return this.workspaceMemberService.delete({
where: args.where,
select: prismaSelect.value,
});
}
@Mutation(() => WorkspaceMember)
@UseGuards(AbilityGuard)
@CheckAbilities(UpdateWorkspaceMemberAbilityHandler)
async UpdateOneWorkspaceMember(
@Args() args: UpdateOneWorkspaceMemberArgs,
@PrismaSelector({ modelName: 'WorkspaceMember' })
prismaSelect: PrismaSelect<'WorkspaceMember'>,
): Promise<Partial<WorkspaceMember>> {
return this.workspaceMemberService.update({
data: args.data,
where: args.where,
select: prismaSelect.value,
} as Prisma.WorkspaceMemberUpdateArgs);
}
}
@@ -1,28 +0,0 @@
import { Test, TestingModule } from '@nestjs/testing';
import { WorkspaceService } from 'src/core/workspace/services/workspace.service';
import { FileUploadService } from 'src/core/file/services/file-upload.service';
import { AbilityFactory } from 'src/ability/ability.factory';
import { WorkspaceResolver } from './workspace.resolver';
describe('WorkspaceResolver', () => {
let resolver: WorkspaceResolver;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
WorkspaceResolver,
{ provide: WorkspaceService, useValue: {} },
{ provide: AbilityFactory, useValue: {} },
{ provide: FileUploadService, useValue: {} },
],
}).compile();
resolver = module.get<WorkspaceResolver>(WorkspaceResolver);
});
it('should be defined', () => {
expect(resolver).toBeDefined();
});
});
@@ -1,115 +0,0 @@
import { Query, Args, Mutation, Resolver } from '@nestjs/graphql';
import { UseGuards } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { FileUpload, GraphQLUpload } from 'graphql-upload';
import { FileFolder } from 'src/core/file/interfaces/file-folder.interface';
import { Workspace } from 'src/core/@generated/workspace/workspace.model';
import { WorkspaceService } from 'src/core/workspace/services/workspace.service';
import {
PrismaSelect,
PrismaSelector,
} from 'src/decorators/prisma-select.decorator';
import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
import { WorkspaceUpdateInput } from 'src/core/@generated/workspace/workspace-update.input';
import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
import { assert } from 'src/utils/assert';
import { FileUploadService } from 'src/core/file/services/file-upload.service';
import { streamToBuffer } from 'src/utils/stream-to-buffer';
import { AbilityGuard } from 'src/guards/ability.guard';
import { CheckAbilities } from 'src/decorators/check-abilities.decorator';
import {
UpdateWorkspaceAbilityHandler,
DeleteWorkspaceAbilityHandler,
} from 'src/ability/handlers/workspace.ability-handler';
@UseGuards(JwtAuthGuard)
@Resolver(() => Workspace)
export class WorkspaceResolver {
constructor(
private readonly workspaceService: WorkspaceService,
private readonly fileUploadService: FileUploadService,
) {}
@Mutation(() => Workspace)
@UseGuards(AbilityGuard)
@CheckAbilities(UpdateWorkspaceAbilityHandler)
async updateWorkspace(
@Args('data') data: WorkspaceUpdateInput,
@AuthWorkspace() workspace: Workspace,
@PrismaSelector({ modelName: 'Workspace' })
prismaSelect: PrismaSelect<'Workspace'>,
) {
return this.workspaceService.update({
where: {
id: workspace.id,
},
data: {
...data,
},
select: prismaSelect.value,
} as Prisma.WorkspaceUpdateArgs);
}
@Query(() => Workspace)
async currentWorkspace(
@AuthWorkspace() workspace: Workspace,
@PrismaSelector({ modelName: 'Workspace' })
prismaSelect: PrismaSelect<'Workspace'>,
) {
const selectedWorkspace = await this.workspaceService.findUnique({
where: {
id: workspace.id,
},
select: prismaSelect.value,
});
assert(selectedWorkspace, 'User not found');
return selectedWorkspace;
}
@UseGuards(AbilityGuard)
@CheckAbilities(UpdateWorkspaceAbilityHandler)
@Mutation(() => String)
async uploadWorkspaceLogo(
@AuthWorkspace() workspace: Workspace,
@Args({ name: 'file', type: () => GraphQLUpload })
{ createReadStream, filename, mimetype }: FileUpload,
): Promise<string> {
const stream = createReadStream();
const buffer = await streamToBuffer(stream);
const fileFolder = FileFolder.WorkspaceLogo;
const { paths } = await this.fileUploadService.uploadImage({
file: buffer,
filename,
mimeType: mimetype,
fileFolder,
});
await this.workspaceService.update({
where: { id: workspace.id },
data: {
logo: paths[0],
},
});
return paths[0];
}
@UseGuards(AbilityGuard)
@CheckAbilities(DeleteWorkspaceAbilityHandler)
@Mutation(() => Workspace)
async deleteCurrentWorkspace(
@AuthWorkspace() { id: workspaceId }: Workspace,
@PrismaSelector({ modelName: 'Workspace' })
{ value: select }: PrismaSelect<'Workspace'>,
) {
return this.workspaceService.deleteWorkspace({
workspaceId,
select,
});
}
}
@@ -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 { WorkspaceMemberService } from './workspace-member.service';
describe('WorkspaceMemberService', () => {
let service: WorkspaceMemberService;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
WorkspaceMemberService,
{
provide: PrismaService,
useValue: prismaMock,
},
],
}).compile();
service = module.get<WorkspaceMemberService>(WorkspaceMemberService);
});
it('should be defined', () => {
expect(service).toBeDefined();
});
});
@@ -1,40 +0,0 @@
import { Injectable } from '@nestjs/common';
import { PrismaService } from 'src/database/prisma.service';
@Injectable()
export class WorkspaceMemberService {
constructor(private readonly prismaService: PrismaService) {}
// Find
findFirst = this.prismaService.client.workspaceMember.findFirst;
findFirstOrThrow = this.prismaService.client.workspaceMember.findFirstOrThrow;
findUnique = this.prismaService.client.workspaceMember.findUnique;
findUniqueOrThrow =
this.prismaService.client.workspaceMember.findUniqueOrThrow;
findMany = this.prismaService.client.workspaceMember.findMany;
// Create
create = this.prismaService.client.workspaceMember.create;
createMany = this.prismaService.client.workspaceMember.createMany;
// Update
update = this.prismaService.client.workspaceMember.update;
upsert = this.prismaService.client.workspaceMember.upsert;
updateMany = this.prismaService.client.workspaceMember.updateMany;
// Delete
delete = this.prismaService.client.workspaceMember.delete;
deleteMany = this.prismaService.client.workspaceMember.deleteMany;
// Aggregate
aggregate = this.prismaService.client.workspaceMember.aggregate;
// Count
count = this.prismaService.client.workspaceMember.count;
// GroupBy
groupBy = this.prismaService.client.workspaceMember.groupBy;
}
@@ -1,13 +1,7 @@
import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { PrismaService } from 'src/database/prisma.service';
import { prismaMock } from 'src/database/client-mock/jest-prisma-singleton';
import { PipelineService } from 'src/core/pipeline/services/pipeline.service';
import { PipelineStageService } from 'src/core/pipeline/services/pipeline-stage.service';
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 { WorkspaceManagerService } from 'src/workspace/workspace-manager/workspace-manager.service';
import { Workspace } from 'src/core/workspace/workspace.entity';
import { WorkspaceService } from './workspace.service';
@@ -19,31 +13,7 @@ describe('WorkspaceService', () => {
providers: [
WorkspaceService,
{
provide: PrismaService,
useValue: prismaMock,
},
{
provide: PipelineService,
useValue: {},
},
{
provide: PipelineStageService,
useValue: {},
},
{
provide: PersonService,
useValue: {},
},
{
provide: CompanyService,
useValue: {},
},
{
provide: PipelineProgressService,
useValue: {},
},
{
provide: WorkspaceManagerService,
provide: getRepositoryToken(Workspace),
useValue: {},
},
],
@@ -1,167 +1,27 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Prisma } from '@prisma/client';
import { v4 } from 'uuid';
import assert from 'assert';
import { TypeOrmQueryService } from '@ptc-org/nestjs-query-typeorm';
import { Repository } from 'typeorm';
import { CompanyService } from 'src/core/company/company.service';
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 { PrismaService } from 'src/database/prisma.service';
import { assert } from 'src/utils/assert';
import { WorkspaceManagerService } from 'src/workspace/workspace-manager/workspace-manager.service';
import { Workspace } from 'src/core/workspace/workspace.entity';
@Injectable()
export class WorkspaceService {
export class WorkspaceService extends TypeOrmQueryService<Workspace> {
constructor(
private readonly prismaService: PrismaService,
private readonly pipelineService: PipelineService,
private readonly companyService: CompanyService,
private readonly personService: PersonService,
private readonly pipelineStageService: PipelineStageService,
private readonly pipelineProgressService: PipelineProgressService,
@InjectRepository(Workspace)
private readonly workspaceRepository: Repository<Workspace>,
private readonly workspaceManagerService: WorkspaceManagerService,
) {}
// Find
findFirst = this.prismaService.client.workspace.findFirst;
findFirstOrThrow = this.prismaService.client.workspace.findFirstOrThrow;
findUnique = this.prismaService.client.workspace.findUnique;
findUniqueOrThrow = this.prismaService.client.workspace.findUniqueOrThrow;
findMany = this.prismaService.client.workspace.findMany;
// Create
create = this.prismaService.client.workspace.create;
createMany = this.prismaService.client.workspace.createMany;
// Update
update = this.prismaService.client.workspace.update;
upsert = this.prismaService.client.workspace.upsert;
updateMany = this.prismaService.client.workspace.updateMany;
// Delete
delete = this.prismaService.client.workspace.delete;
deleteMany = this.prismaService.client.workspace.deleteMany;
// Aggregate
aggregate = this.prismaService.client.workspace.aggregate;
// Count
count = this.prismaService.client.workspace.count;
// GroupBy
groupBy = this.prismaService.client.workspace.groupBy;
// Customs
async createDefaultWorkspace() {
const workspace = await this.create({
data: {
inviteHash: v4(),
},
});
// Create workspace schema
await this.workspaceManagerService.init(workspace.id);
// Create default companies
const companies = await this.companyService.createDefaultCompanies({
workspaceId: workspace.id,
});
// Create default people
await this.personService.createDefaultPeople({
workspaceId: workspace.id,
companies,
});
// Create default pipeline
const pipeline = await this.pipelineService.createDefaultPipeline({
workspaceId: workspace.id,
});
// Create default stages
await this.pipelineStageService.createDefaultPipelineStages({
pipelineId: pipeline.id,
workspaceId: workspace.id,
});
return workspace;
) {
super(workspaceRepository);
}
async deleteWorkspace({
workspaceId,
select = { id: true },
}: {
workspaceId: string;
select?: Prisma.WorkspaceSelect;
}) {
const workspace = await this.findUnique({
where: { id: workspaceId },
select,
});
async deleteWorkspace(id: string) {
const workspace = await this.workspaceRepository.findOneBy({ id });
assert(workspace, 'Workspace not found');
const where = { workspaceId };
const {
workspaceMember,
attachment,
comment,
activityTarget,
activity,
apiKey,
favorite,
webHook,
} = this.prismaService.client;
// We don't delete user or refresh tokens as they can belong to another workspace
await this.prismaService.client.$transaction([
this.pipelineProgressService.deleteMany({
where,
}),
this.companyService.deleteMany({
where,
}),
this.personService.deleteMany({
where,
}),
this.pipelineStageService.deleteMany({
where,
}),
this.pipelineService.deleteMany({
where,
}),
workspaceMember.deleteMany({
where,
}),
attachment.deleteMany({
where,
}),
comment.deleteMany({
where,
}),
activityTarget.deleteMany({
where,
}),
activity.deleteMany({
where,
}),
apiKey.deleteMany({
where,
}),
favorite.deleteMany({
where,
}),
webHook.deleteMany({
where,
}),
this.delete({ where: { id: workspaceId } }),
]);
await this.workspaceManagerService.delete(workspaceId);
await this.workspaceManagerService.delete(id);
return workspace;
}
@@ -0,0 +1,41 @@
import {
AutoResolverOpts,
PagingStrategies,
ReadResolverOpts,
} from '@ptc-org/nestjs-query-graphql';
import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
import { UpdateWorkspaceInput } from 'src/core/workspace/dtos/update-workspace-input';
import { Workspace } from './workspace.entity';
export const workspaceAutoResolverOpts: AutoResolverOpts<
any,
any,
unknown,
unknown,
ReadResolverOpts<any>,
PagingStrategies
>[] = [
{
EntityClass: Workspace,
DTOClass: Workspace,
UpdateDTOClass: UpdateWorkspaceInput,
enableTotalCount: true,
pagingStrategy: PagingStrategies.CURSOR,
read: {
many: { disabled: true },
one: { disabled: true },
},
create: {
many: { disabled: true },
one: { disabled: true },
},
update: {
one: { disabled: true },
many: { disabled: true },
},
delete: { many: { disabled: true }, one: { disabled: true } },
guards: [JwtAuthGuard],
},
];
@@ -0,0 +1,52 @@
import { Field, ID, ObjectType } from '@nestjs/graphql';
import { IDField } from '@ptc-org/nestjs-query-graphql';
import {
Column,
CreateDateColumn,
Entity,
OneToMany,
PrimaryGeneratedColumn,
UpdateDateColumn,
} from 'typeorm';
import { User } from 'src/core/user/user.entity';
@Entity({ name: 'workspace', schema: 'core' })
@ObjectType('Workspace')
export class Workspace {
@IDField(() => ID)
@PrimaryGeneratedColumn('uuid')
id: string;
@Field({ nullable: true })
@Column({ nullable: true })
domainName?: string;
@Field({ nullable: true })
@Column({ nullable: true })
displayName?: string;
@Field({ nullable: true })
@Column({ nullable: true })
logo?: string;
@Field({ nullable: true })
@Column({ nullable: true })
inviteHash?: string;
@Field({ nullable: true })
@Column({ nullable: true })
deletedAt?: Date;
@Field()
@CreateDateColumn({ type: 'timestamp with time zone' })
createdAt: Date;
@Field()
@UpdateDateColumn({ type: 'timestamp with time zone' })
updatedAt: Date;
@OneToMany(() => User, (user) => user.defaultWorkspace)
users: User[];
}
+24 -23
View File
@@ -1,34 +1,35 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
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 { NestjsQueryGraphQLModule } from '@ptc-org/nestjs-query-graphql';
import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm';
import { FileModule } from 'src/core/file/file.module';
import { WorkspaceManagerModule } from 'src/workspace/workspace-manager/workspace-manager.module';
import { AbilityModule } from 'src/ability/ability.module';
import { PrismaModule } from 'src/database/prisma.module';
import { WorkspaceResolver } from 'src/core/workspace/workspace.resolver';
// eslint-disable-next-line no-restricted-imports
import config from '../../../ormconfig';
import { Workspace } from './workspace.entity';
import { workspaceAutoResolverOpts } from './workspace.auto-resolver-opts';
import { WorkspaceService } from './services/workspace.service';
import { WorkspaceMemberService } from './services/workspace-member.service';
import { WorkspaceMemberResolver } from './resolvers/workspace-member.resolver';
import { WorkspaceResolver } from './resolvers/workspace.resolver';
@Module({
imports: [
AbilityModule,
PipelineModule,
CompanyModule,
PersonModule,
WorkspaceManagerModule,
PrismaModule,
TypeOrmModule.forRoot(config),
NestjsQueryGraphQLModule.forFeature({
imports: [
NestjsQueryTypeOrmModule.forFeature([Workspace]),
WorkspaceManagerModule,
FileModule,
],
services: [WorkspaceService],
resolvers: workspaceAutoResolverOpts,
}),
],
providers: [
WorkspaceService,
FileUploadService,
WorkspaceMemberService,
WorkspaceMemberResolver,
WorkspaceResolver,
],
exports: [WorkspaceService, WorkspaceMemberService],
exports: [WorkspaceService],
providers: [WorkspaceResolver, WorkspaceService],
})
export class WorkspaceModule {}
@@ -0,0 +1,70 @@
import { Resolver, Query, Args, Mutation } from '@nestjs/graphql';
import { UseGuards } from '@nestjs/common';
import { FileUpload, GraphQLUpload } from 'graphql-upload';
import { FileFolder } from 'src/core/file/interfaces/file-folder.interface';
import { streamToBuffer } from 'src/utils/stream-to-buffer';
import { FileUploadService } from 'src/core/file/services/file-upload.service';
import { AuthWorkspace } from 'src/decorators/auth-workspace.decorator';
import { assert } from 'src/utils/assert';
import { JwtAuthGuard } from 'src/guards/jwt.auth.guard';
import { UpdateWorkspaceInput } from 'src/core/workspace/dtos/update-workspace-input';
import { Workspace } from './workspace.entity';
import { WorkspaceService } from './services/workspace.service';
@UseGuards(JwtAuthGuard)
@Resolver(() => Workspace)
export class WorkspaceResolver {
constructor(
private readonly workspaceService: WorkspaceService,
private readonly fileUploadService: FileUploadService,
) {}
@Query(() => Workspace)
async currentWorkspace(@AuthWorkspace() { id }: Workspace) {
const workspace = await this.workspaceService.findById(id);
assert(workspace, 'User not found');
return workspace;
}
@Mutation(() => Workspace)
async updateWorkspace(
@Args('data') data: UpdateWorkspaceInput,
@AuthWorkspace() workspace: Workspace,
) {
return this.workspaceService.updateOne(workspace.id, data);
}
@Mutation(() => String)
async uploadWorkspaceLogo(
@AuthWorkspace() { id }: Workspace,
@Args({ name: 'file', type: () => GraphQLUpload })
{ createReadStream, filename, mimetype }: FileUpload,
): Promise<string> {
const stream = createReadStream();
const buffer = await streamToBuffer(stream);
const fileFolder = FileFolder.WorkspaceLogo;
const { paths } = await this.fileUploadService.uploadImage({
file: buffer,
filename,
mimeType: mimetype,
fileFolder,
});
await this.workspaceService.updateOne(id, {
logo: paths[0],
});
return paths[0];
}
@Mutation(() => Workspace)
async deleteCurrentWorkspace(@AuthWorkspace() { id }: Workspace) {
return this.workspaceService.deleteWorkspace(id);
}
}