update ability types

Author: DylanBulmer

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codrjs/models",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

src/types/Ability.ts

@@ -12,41 +12,40 @@ import type { UserRoleType } from "./User";
 import type { Base } from "../entities/Base";
 
 // setup action and subject types for ability
-export type ActionType =
-  | "create"
-  | "delete"
-  | "read"
-  | "update"
+export type ActionType = "create" | "read" | "update" | "delete";
+export type ExtendedActionType =
+  | ActionType
   | "manage" // all CRUD ops
   | "edit" // all CRUD ops except delete
-  | "manipulate"; // all CRUD ops except read
+  | "manipulate"; // all CRUD ops except read;
 
 export interface IModelKind<K extends string = string> {
   kind: K;
 }
 
 // define what an ability is using the action and subject types
-export type Ability<Model extends IModelKind | Base> = MongoAbility<
-  [ActionType, InferSubjects<Model>],
-  MongoQuery<Omit<Model, "kind">>
+export type Ability<M extends IModelKind, C extends typeof Base> = MongoAbility<
+  [ExtendedActionType, InferSubjects<M | C>],
+  MongoQuery<Omit<M, "kind">>
 >;
 
 // define permissions; used to create an ability
-export type DefinePermissions<Model extends IModelKind | Base> = (
+export type DefinePermissions<M extends IModelKind, C extends typeof Base> = (
   user: JwtPayload,
-  builder: AbilityBuilder<Ability<Model>>,
+  builder: AbilityBuilder<Ability<M, C>>,
 ) => void;
 
-export type Permissions<Model extends IModelKind | Base> = Record<
+export type Permissions<M extends IModelKind, C extends typeof Base> = Record<
   UserRoleType,
-  DefinePermissions<Model>
+  DefinePermissions<M, C>
 >;
 
 // export a function for defining an ability using generics.
 export const DefineAbility = function DefineAbility<
-  Model extends IModelKind | Base,
->(user: JwtPayload, permissions: Permissions<Model>): Ability<Model> {
-  const builder = new AbilityBuilder<Ability<Model>>(createMongoAbility);
+  M extends IModelKind,
+  C extends typeof Base,
+>(user: JwtPayload, permissions: Permissions<M, C>): Ability<M, C> {
+  const builder = new AbilityBuilder<Ability<M, C>>(createMongoAbility);
 
   if (typeof permissions[user.role] === "function") {
     permissions[user.role](user, builder);
@@ -56,18 +55,12 @@ export const DefineAbility = function DefineAbility<
     );
   }
 
-  return builder.build({
-    resolveAction,
-    detectSubjectType: (obj: Model) => {
-      if (isModel(obj)) {
-        return obj.kind as ExtractSubjectType<Model>;
-      } else {
-        return obj.constructor.name as ExtractSubjectType<Model>;
-      }
-    },
-  });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  return builder.build({ resolveAction, detectSubjectType });
 };
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isModel(obj: any): obj is IModelKind {
   return typeof obj?.kind === "string";
 }
@@ -77,3 +70,14 @@ const resolveAction = createAliasResolver({
   edit: ["create", "read", "update"],
   manipulate: ["create", "update", "delete"],
 });
+
+const detectSubjectType = function detectSubjectType<
+  M extends IModelKind,
+  C extends typeof Base,
+>(subject: M | C) {
+  if (isModel(subject)) {
+    return subject.kind as ExtractSubjectType<M | C>;
+  } else {
+    return subject.constructor.name as ExtractSubjectType<M | C>;
+  }
+};