• Index
• Search by APIs
• Search by Words
• Project Search

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• nest-casl-master
  • .github
    • dependabot.yml
    • workflows
      • build.yml
      • publish.yml
      • codeql-analysis.yml
  • .eslintignore
  • src
    • casl.module.ts
    • actions.enum.ts
    • decorators
      • casl-conditions.ts
      • casl-user.ts
      • index.ts
      • use-ability.ts
      • casl-subject.ts
      • casl-query-authorize.ts
    • casl.constants.ts
    • index.ts
    • access.service.spec.ts
    • casl.config.spec.ts
    • __specs__
      • rest.e2e.spec.ts
      • graphql.e2e.spec.ts
      • app
        • user
          • user.service.ts
          • dtos
            • user.dto.ts
          • user.module.ts
          • user.hook.ts
        • post
          • post.service.ts
          • post.permissions.ts
          • post.resolver.ts
          • dtos
            • update-post-input.dto.ts
            • create-post-input.dto.ts
            • post.dto.ts
          • post.module.ts
          • post.hook.ts
          • post.controller.ts
        • app.module.ts
        • app.roles.ts
      • tsconfig.json
    • access.service.ts
    • proxies
      • user.proxy.ts
      • request.proxy.spec.ts
      • context.proxy.spec.ts
      • subject.proxy.spec.ts
      • user.proxy.spec.ts
      • conditions.proxy.spec.ts
      • context.proxy.ts
      • subject.proxy.ts
      • request.proxy.ts
      • conditions.proxy.ts
    • access.guard.ts
    • interfaces
      • permissions.interface.ts
      • ability-metadata.interface.ts
      • casl-request-cache.interface.ts
      • authorizable-user.interface.ts
      • hooks.interface.ts
      • options.interface.ts
      • request.interface.ts
    • factories
      • ability.factory.spec.ts
      • ability.factory.ts
      • user-hook.factory.spec.ts
      • subject-hook.factory.ts
      • user-hook.factory.ts
    • casl.config.ts
    • access.guard.spec.ts
  • jest.config.js
  • .npmignore
  • .prettierrc
  • LICENSE
  • .npmrc
  • .releaserc.yaml
  • tsconfig.build.json
  • README.md
  • package.json
  • .eslintrc.js
  • tsconfig.json
  • .gitignore
  • .prettierignore
  • .vscode
    • launch.json

import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
import { NotFoundException, UseGuards } from '@nestjs/common';
import {
  AccessService,
  AccessGuard,
  Actions,
  ConditionsProxy,
  CaslConditions,
  CaslSubject,
  CaslUser,
  UseAbility,
  UserProxy,
  SubjectProxy,
} from 'nest-casl';

import { User } from '../user/dtos/user.dto';
import { Post } from './dtos/post.dto';
import { PostHook } from './post.hook';
import { PostService } from './post.service';
import { CreatePostInput } from './dtos/create-post-input.dto';
import { UpdatePostInput } from './dtos/update-post-input.dto';

@Resolver(() => Post)
export class PostResolver {
  constructor(private postService: PostService, private accessService: AccessService) {}

  @Query(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.read, Post)
  async post(@Args('id') id: string) {
    return this.postService.findById(id);
  }

  @Query(() => [Post])
  @UseGuards(AccessGuard)
  @UseAbility(Actions.read, Post)
  async posts() {
    return this.postService.findAll();
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.create, Post)
  async createPost(@Args('input') input: CreatePostInput) {
    return this.postService.create(input);
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.delete, Post)
  async deletePost(@Args('id') id: string) {
    return this.postService.delete(id);
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.update, Post, PostHook)
  async updatePost(@Args('input') input: UpdatePostInput) {
    return this.postService.update(input);
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility<Post>(Actions.update, Post, [
    PostService,
    (service: PostService, { params }) => service.findById(params.input.id),
  ])
  async updatePostTupleHook(@Args('input') input: UpdatePostInput) {
    return this.postService.update(input);
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.update, Post)
  async updatePostNoHook(@Args('input') input: UpdatePostInput) {
    return this.postService.update(input);
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.update, Post, PostHook)
  async updatePostUserParam(@Args('input') input: UpdatePostInput, @CaslUser() user: UserProxy<User>) {
    this.postService.addUser(await user.get());
    return this.postService.update(input);
  }

  @Mutation(() => Post)
  async updatePostUserParamNoAbility(@Args('input') input: UpdatePostInput, @CaslUser() user: UserProxy<User>) {
    this.postService.addUser(await user.get());
    return this.postService.update(input);
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.update, Post, PostHook)
  async updatePostSubjectParam(@Args('input') input: UpdatePostInput, @CaslSubject() subjectProxy: SubjectProxy<Post>) {
    const post = await subjectProxy.get();
    if (!post) {
      throw new NotFoundException('Post not found');
    }
    return this.postService.update(post);
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility<Post>(Actions.update, Post, [
    PostService,
    (service: PostService, { params }) => service.findById(params.input.id),
  ])
  async updatePostSubjectParamTuple(
    @Args('input') input: UpdatePostInput,
    @CaslSubject() subjectProxy: SubjectProxy<Post>,
  ) {
    const post = await subjectProxy.get();
    if (!post) {
      throw new NotFoundException('Post not found');
    }
    return this.postService.update(post);
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.update, Post, PostHook)
  async updatePostConditionParam(@Args('input') input: UpdatePostInput, @CaslConditions() conditions: ConditionsProxy) {
    return this.postService.update(input, conditions.toSql());
  }

  @Mutation(() => Post)
  @UseGuards(AccessGuard)
  @UseAbility(Actions.update, Post)
  async updatePostConditionParamNoHook(
    @Args('input') input: UpdatePostInput,
    @CaslConditions() conditions: ConditionsProxy,
  ) {
    return this.postService.update(input, conditions.toSql());
  }
}