refactor!: types (#23)

Author: zAlweNy26

README.md

@@ -108,7 +108,6 @@ export default defineNuxtPlugin({
 
 Nitro plugin:
 
-
 ```ts
 export default defineNitroPlugin((nitroApp) => {
   nitroApp.hooks.hook('request', async (event) => {
@@ -151,7 +150,7 @@ If you have many abilities, you could prefer to create a directory `utils/abilit
 By default, guests are not allowed to perform any action and the ability is not called. This behavior can be changed per ability:
 
 ```ts
-export const listPosts = defineAbility({ allowGuests: true }, (user: User | null) => true)
+export const listPosts = defineAbility({ allowGuest: true }, (user: User | null) => true)
 ```
 
 Now, unauthenticated users can list posts.

src/runtime/components/Bouncer.vue

@@ -1,12 +1,10 @@
 <script lang="ts" setup generic="Ability extends BouncerAbility<any>">
-import type { AuthorizerResponse, BouncerAbility } from '../../utils'
+import type { BouncerAbility, BouncerArgs } from '../../utils'
 import { allows, ref, watchEffect } from '#imports'
 
-type PropsArgs = Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never
-
 const props = defineProps<{
   bouncerAbility: Ability
-  args?: PropsArgs
+  args?: BouncerArgs<Ability>
 }>()
 
 const can = ref(await resolve())
@@ -17,7 +15,7 @@ watchEffect(async () => {
 })
 
 async function resolve() {
-  return await allows(props.bouncerAbility, ...(props.args ?? [] as unknown as PropsArgs))
+  return await allows(props.bouncerAbility, ...(props.args ?? [] as any))
 }
 </script>
 

src/runtime/components/Can.vue

@@ -1,12 +1,10 @@
 <script lang="ts" setup generic="Ability extends BouncerAbility<any>">
-import type { AuthorizerResponse, BouncerAbility } from '../../utils'
+import type { BouncerArgs, BouncerAbility } from '../../utils'
 import { allows, ref, watchEffect } from '#imports'
 
-type PropsArgs = Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never
-
 const props = defineProps<{
   bouncerAbility: Ability
-  args?: PropsArgs
+  args?: BouncerArgs<Ability>
 }>()
 
 const can = ref(await resolve())
@@ -17,14 +15,12 @@ watchEffect(async () => {
 })
 
 async function resolve() {
-  return await allows(props.bouncerAbility, ...(props.args ?? [] as unknown as PropsArgs))
+  return await allows(props.bouncerAbility, ...(props.args ?? [] as any))
 }
 </script>
 
 <template>
-  <template
-    v-if="can"
-  >
+  <template v-if="can">
     <slot />
   </template>
 </template>

src/runtime/components/Cannot.vue

@@ -1,12 +1,10 @@
 <script lang="ts" setup generic="Ability extends BouncerAbility<any>">
-import type { AuthorizerResponse, BouncerAbility } from '../../utils'
+import type { BouncerAbility, BouncerArgs } from '../../utils'
 import { denies, ref, watchEffect } from '#imports'
 
-type PropsArgs = Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never
-
 const props = defineProps<{
   bouncerAbility: Ability
-  args?: PropsArgs
+  args?: BouncerArgs<Ability>
 }>()
 
 const cannot = ref(await resolve())
@@ -17,14 +15,12 @@ watchEffect(async () => {
 })
 
 async function resolve() {
-  return await denies(props.bouncerAbility, ...(props.args ?? [] as unknown as PropsArgs))
+  return await denies(props.bouncerAbility, ...(props.args ?? [] as any))
 }
 </script>
 
 <template>
-  <template
-    v-if="cannot"
-  >
+  <template v-if="cannot">
     <slot />
   </template>
 </template>

src/runtime/nuxt.d.ts

@@ -1,15 +1,23 @@
 declare module '#app' {
   interface NuxtApp {
     $authorization: {
-      resolveClientUser: () => Promise<any>
+      resolveClientUser: <User extends Record<string, any>>() => Promise<User | null>
     }
   }
 }
 
 declare module 'vue' {
   interface ComponentCustomProperties {
     $authorization: {
-      resolveClientUser: () => Promise<any>
+      resolveClientUser: <User extends Record<string, any>>() => Promise<User | null>
+    }
+  }
+}
+
+declare module 'h3' {
+  interface H3EventContext {
+    $authorization: {
+      resolveServerUser: <User extends Record<string, any>>() => Promise<User | null>
     }
   }
 }

src/runtime/server/utils/bouncer.ts

@@ -1,12 +1,12 @@
 import type { H3Event } from 'h3'
-import type { AuthorizerResponse, BouncerAbility } from '../../../utils'
+import type { BouncerAbility, BouncerArgs } from '../../../utils'
 import { allows as _allows, denies as _denies, authorize as _authorize, AuthorizationError } from '../../../utils'
 import { createError } from '#imports'
 
 /**
  * Allows a user to perform an action based on their role and the data.
  */
-export async function allows<Ability extends BouncerAbility<any>>(event: H3Event, bouncerAbility: Ability, ...args: Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never): Promise<boolean> {
+export async function allows<Event extends H3Event, Ability extends BouncerAbility<any>>(event: Event, bouncerAbility: Ability, ...args: BouncerArgs<Ability>): Promise<boolean> {
   const user = await event.context.$authorization.resolveServerUser()
 
   return _allows(bouncerAbility, user, ...args)
@@ -15,7 +15,7 @@ export async function allows<Ability extends BouncerAbility<any>>(event: H3Event
 /**
  * Denies a user to perform an action based on their role and the data.
  */
-export async function denies<Ability extends BouncerAbility<any>>(event: H3Event, bouncerAbility: Ability, ...args: Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never): Promise<boolean> {
+export async function denies<Event extends H3Event, Ability extends BouncerAbility<any>>(event: Event, bouncerAbility: Ability, ...args: BouncerArgs<Ability>): Promise<boolean> {
   const user = await event.context.$authorization.resolveServerUser()
 
   return _denies(bouncerAbility, user, ...args)
@@ -24,7 +24,7 @@ export async function denies<Ability extends BouncerAbility<any>>(event: H3Event
 /**
  * Throws an error if the user is not allowed to perform an action.
  */
-export async function authorize<Ability extends BouncerAbility<any>>(event: H3Event, bouncerAbility: Ability, ...args: Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never): Promise<void> {
+export async function authorize<Event extends H3Event, Ability extends BouncerAbility<any>>(event: Event, bouncerAbility: Ability, ...args: BouncerArgs<Ability>): Promise<void> {
   try {
     const user = await event.context.$authorization.resolveServerUser()
 

src/runtime/utils/bouncer.ts

@@ -1,11 +1,11 @@
-import type { BouncerAbility, AuthorizerResponse } from '../../utils'
+import type { BouncerAbility, BouncerArgs } from '../../utils'
 import { allows as _allows, denies as _denies, authorize as _authorize, AuthorizationError } from '../../utils'
 import { useNuxtApp, createError } from '#imports'
 
 /**
  * Client side utility to check if a user can perform an action.
  */
-export async function allows<Ability extends BouncerAbility<any>>(bouncerAbility: Ability, ...args: Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never): Promise<boolean> {
+export async function allows<Ability extends BouncerAbility<any>>(bouncerAbility: Ability, ...args: BouncerArgs<Ability>): Promise<boolean> {
   const user = await useNuxtApp().$authorization.resolveClientUser()
 
   return _allows(bouncerAbility, user, ...args)
@@ -14,7 +14,7 @@ export async function allows<Ability extends BouncerAbility<any>>(bouncerAbility
 /**
  * Client side utility to check if a user cannot perform an action.
  */
-export async function denies<Ability extends BouncerAbility<any>>(bouncerAbility: Ability, ...args: Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never): Promise<boolean> {
+export async function denies<Ability extends BouncerAbility<any>>(bouncerAbility: Ability, ...args: BouncerArgs<Ability>): Promise<boolean> {
   const user = await useNuxtApp().$authorization.resolveClientUser()
 
   return _denies(bouncerAbility, user, ...args)
@@ -23,7 +23,7 @@ export async function denies<Ability extends BouncerAbility<any>>(bouncerAbility
 /**
  * Client side utility to throw an error if a user is not allowed to perform an action.
  */
-export async function authorize<Ability extends BouncerAbility<any>>(bouncerAbility: Ability, ...args: Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never): Promise<void> {
+export async function authorize<Ability extends BouncerAbility<any>>(bouncerAbility: Ability, ...args: BouncerArgs<Ability>): Promise<void> {
   try {
     const user = await useNuxtApp().$authorization.resolveClientUser()
 

src/utils/ability.ts

@@ -10,7 +10,7 @@ export type AuthorizerToAbility<Authorizer> = Authorizer extends (
   ? {
       allowGuest: boolean
       original: Authorizer
-      execute(user: User, ...args: Args): AuthorizerResponse
+      execute(user: User | null, ...args: Args): AuthorizerResponse
     }
   : never
 

src/utils/bouncer.ts

@@ -1,5 +1,5 @@
 import { createAuthorizationError } from './error'
-import type { AuthorizationResponse, AuthorizerResponse, BouncerAbility } from './types'
+import type { AuthorizationResponse, BouncerAbility, BouncerArgs } from './types'
 
 /**
  * Normalize the ability execution result to an authorization response.
@@ -15,23 +15,23 @@ export function normalizeAuthorizationResponse(result: boolean | AuthorizationRe
 /**
  * Check if a user can perform an action.
  */
-export async function allows<Ability extends BouncerAbility<any>, User>(bouncerAbility: Ability, user: User, ...args: Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never): Promise<boolean> {
+export async function allows<Ability extends BouncerAbility<any>, User extends Record<string, any> = Ability extends BouncerAbility<infer U> ? U : never>(bouncerAbility: Ability, user: User | null, ...args: BouncerArgs<Ability>): Promise<boolean> {
   const response = await bouncerAbility.execute(user, ...args)
   return normalizeAuthorizationResponse(response).authorized
 }
 
 /**
  * Check if a user cannot perform an action.
  */
-export async function denies<Ability extends BouncerAbility<any>, User>(bouncerAbility: Ability, user: User, ...args: Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never): Promise<boolean> {
+export async function denies<Ability extends BouncerAbility<any>, User extends Record<string, any> = Ability extends BouncerAbility<infer U> ? U : never>(bouncerAbility: Ability, user: User | null, ...args: BouncerArgs<Ability>): Promise<boolean> {
   const response = await bouncerAbility.execute(user, ...args)
   return !normalizeAuthorizationResponse(response).authorized
 }
 
 /**
  * Check if a user can perform an action and throws an error if not.
  */
-export async function authorize<Ability extends BouncerAbility<any>, User>(bouncerAbility: Ability, user: User, ...args: Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never): Promise<void> {
+export async function authorize<Ability extends BouncerAbility<any>, User extends Record<string, any> = Ability extends BouncerAbility<infer U> ? U : never>(bouncerAbility: Ability, user: User | null, ...args: BouncerArgs<Ability>): Promise<void> {
   const response = await bouncerAbility.execute(user, ...args)
   const normalized = normalizeAuthorizationResponse(response)
   if (!normalized.authorized) {

src/utils/types.ts

@@ -19,13 +19,18 @@ export type AuthorizerResponse =
 /**
  * Represents the authorizer function that will be executed to determine if a user is authorized to perform an action.
  */
-export type BouncerAuthorizer<User> = (user: User, ...args: any[]) => AuthorizerResponse
+export type BouncerAuthorizer<User extends Record<string, any>> = (user: User, ...args: any[]) => AuthorizerResponse
 
 /**
  * Represents an ability that can be used by a bouncer.
  */
-export type BouncerAbility<User> = {
+export type BouncerAbility<User extends Record<string, any>> = {
   original: BouncerAuthorizer<User>
   execute: (user: User | null, ...args: any[]) => AuthorizerResponse
   allowGuest: boolean
 }
+
+/**
+ * Represents the arguments that will be passed to the authorizer function.
+ */
+export type BouncerArgs<Ability extends BouncerAbility<any>> = Ability extends { original: (user: any, ...args: infer Args) => AuthorizerResponse } ? Args : never