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));
}
}