feat: add accessibleQuery function

example/app.ts

@@ -16,7 +16,7 @@ export default await AppContainer.create({
       inject: [CryptoService],
       useFactory: (cryptoService: CryptoService) => {
         return {
-          defineAbility: (ability, payload: { isAdmin: boolean }) => {
+          defineAbility: (ability, payload) => {
             if (payload.isAdmin) {
               ability.can('manage', 'all');
             }

src/index.ts

@@ -3,15 +3,15 @@ export { CurrentUser } from './decorators/current-user.decorator.js';
 export { RouteAccess } from './decorators/route-access.decorator.js';
 export { ValidationSchema } from './decorators/validation-schema.decorator.js';
 export { DataTransferObject } from './mixins/data-transfer-object.mixin.js';
-export type { AuthModuleOptions } from './modules/auth/auth.config.js';
+export type { AppAbility, AuthModuleOptions } from './modules/auth/auth.config.js';
 export { AuthModule } from './modules/auth/auth.module.js';
 export { ConfigService } from './modules/config/config.service.js';
 export { CryptoService } from './modules/crypto/crypto.service.js';
 export { LoggingService } from './modules/logging/logging.service.js';
 export { InjectModel } from './modules/prisma/prisma.decorators.js';
 export { PrismaService } from './modules/prisma/prisma.service.js';
 export type { Model } from './modules/prisma/prisma.types.js';
-export { getModelToken } from './modules/prisma/prisma.utils.js';
+export { accessibleQuery, getModelToken } from './modules/prisma/prisma.utils.js';
 export type { VirtualizationModuleOptions } from './modules/virtualization/virtualization.config.js';
 export { VirtualizationModule } from './modules/virtualization/virtualization.module.js';
 export { VirtualizationService } from './modules/virtualization/virtualization.service.js';

src/modules/prisma/__tests__/prisma.utils.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { accessibleQuery } from '../prisma.utils.js';
+
+const accessibleBy = vi.hoisted(() => vi.fn());
+
+vi.mock('@casl/prisma/runtime', () => ({
+  createAccessibleByFactory: () => accessibleBy
+}));
+
+describe('accessibleQuery', () => {
+  it('should return an empty object if ability is undefined', () => {
+    expect(accessibleQuery(undefined, 'manage', 'Cat')).toStrictEqual({});
+    expect(accessibleBy).not.toHaveBeenCalled();
+  });
+  it('should call accessibleBy with the correct parameters and return the result of accessibleBy for the model', () => {
+    accessibleBy.mockReturnValueOnce({
+      Cat: 'QUERY'
+    });
+    const ability = vi.fn();
+    expect(accessibleQuery(ability as any, 'manage', 'Cat')).toStrictEqual('QUERY');
+    expect(accessibleBy).toHaveBeenCalledExactlyOnceWith(ability, 'manage');
+  });
+});

src/modules/prisma/prisma.types.ts

@@ -1,5 +1,5 @@
 import type { SingleKeyMap } from '@douglasneuroinformatics/libjs';
 import type { Prisma, PrismaClient } from '@prisma/client';
 import type { IfNever, Simplify } from 'type-fest';
 
 import type { PrismaFactory } from './prisma.factory.js';
@@ -16,5 +16,13 @@
 
 export type PrismaModelToken<T extends PrismaModelName> = `${T}PrismaModel`;
 
+export type PrismaModelWhereInputMap = {
+  [K in PrismaModelName]: PrismaClientLike[PrismaModelKey<K>] extends {
+    findFirst: (args: { where: infer TWhereInput }) => any;
+  }
+    ? TWhereInput
+    : never;
+};
+
 export type Model<T extends PrismaModelName> =
   RuntimePrismaClient extends SingleKeyMap<`${Uncapitalize<T>}`, infer U> ? U : never;

src/modules/prisma/prisma.utils.ts

@@ -1,6 +1,10 @@
+import { createAccessibleByFactory } from '@casl/prisma/runtime';
 import { uncapitalize } from '@douglasneuroinformatics/libjs';
 
-import type { PrismaModelKey, PrismaModelName, PrismaModelToken } from './prisma.types.js';
+import type { AppAbility, AppAction, AppConditions } from '../auth/auth.config.js';
+import type { PrismaModelKey, PrismaModelName, PrismaModelToken, PrismaModelWhereInputMap } from './prisma.types.js';
+
+const accessibleBy = createAccessibleByFactory<PrismaModelWhereInputMap, AppConditions>();
 
 /**
  * Generates an injection token for a given Prisma model name.
@@ -15,3 +19,14 @@ export function getModelToken<T extends PrismaModelName>(modelName: T): PrismaMo
 export function getModelKey<T extends PrismaModelName>(modelName: T): PrismaModelKey<T> {
   return uncapitalize(modelName);
 }
+
+export function accessibleQuery<T extends PrismaModelName>(
+  ability: AppAbility | undefined,
+  action: AppAction,
+  modelName: T
+): NonNullable<PrismaModelWhereInputMap[T]> {
+  if (!ability) {
+    return {};
+  }
+  return accessibleBy(ability, action)[modelName]!;
+}