Merge pull request #65 from DouglasNeuroInformatics/v8

V8

Author: joshunrau

.bruno/Auth/Login.bru

@@ -1,32 +1,3 @@
 vars:pre-request {
   BASE_URL: http://localhost:5500
-}
-
-script:pre-request {
-  const axios = require("axios");
-  
-  const getVar = (key) => {
-    const value = bru.getVar(key);
-    if (value === undefined) {
-      throw new Error(`Could not get variable: ${key}`)
-    }
-    return value;
-  }
-  
-  if (!req.url.endsWith('/auth/login')) {
-    const baseUrl = 'http://localhost:5500';
-    const username = 'admin';
-    const password = 'password';
-    const response = await axios.post(`${baseUrl}/auth/login`, {
-      username,
-      password
-    });
-    req.setHeader('Authorization', `Bearer ${response.data.accessToken}`)
-  }
-  
-  
-  
-  
-  
-  
 }

.bruno/collection.bru

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": ["Bash(npm run lint)", "Bash(npm test)", "Bash(npm test:*)"],
+    "deny": [],
+    "ask": []
+  }
+}

.claude/settings.local.json

@@ -0,0 +1,32 @@
+import { Module } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+import { PrismaModule } from '../src/index.js';
+import { CatsModule } from './cats/cats.module.js';
+
+@Module({
+  imports: [
+    CatsModule,
+    PrismaModule.forRootAsync({
+      inject: ['MONGO_CONNECTION'],
+      provideInjectionTokensFrom: [
+        {
+          provide: 'MONGO_CONNECTION',
+          useFactory: async (): Promise<string> => {
+            const { MongoMemoryReplSet } = await import('mongodb-memory-server');
+            const replSet = await MongoMemoryReplSet.create({ replSet: { count: 1, name: 'rs0' } });
+            return new URL(replSet.getUri('test')).href;
+          }
+        }
+      ],
+      useFactory: (mongoConnection: string) => {
+        return {
+          client: new PrismaClient({
+            datasourceUrl: mongoConnection
+          })
+        };
+      }
+    })
+  ]
+})
+export class AppModule {}

deno.json

@@ -1,7 +1,4 @@
-import { randomBytes } from 'crypto';
-
-import { Document, Window } from 'happy-dom';
-import { afterAll, beforeAll, beforeEach, describe, expect, vi } from 'vitest';
+import { describe, expect, vi } from 'vitest';
 
 import { e2e } from '../src/testing/index.js';
 import app from './app.js';
@@ -11,48 +8,6 @@ import type { $Cat, $CreateCatData } from './cats/schemas/cat.schema.js';
 vi.unmock('@prisma/client');
 
 e2e(app, ({ api }) => {
-  describe('/', (it) => {
-    let document: Document;
-    let window: Window;
-
-    beforeAll(() => {
-      window = new Window({
-        innerHeight: 768,
-        innerWidth: 1024,
-        url: 'http://localhost:5500'
-      });
-      document = window.document as any;
-
-      window.console.error = (...args) => {
-        console.error(...args);
-      };
-    });
-
-    afterAll(async () => {
-      await window.happyDOM.close();
-    });
-
-    it('should render html', async () => {
-      const response = await api.get('/');
-      expect(response.type).toBe('text/html');
-    });
-
-    it('should render an interactive UI', async () => {
-      const response = await api.get('/');
-      document.write(response.text);
-      await window.happyDOM.waitUntilComplete();
-      const h1 = document.querySelector('h1')!;
-      expect(h1.innerText).toBe('Welcome to the Example App');
-      const ul = document.querySelector('ul')!;
-      expect(ul.style.display).toBe('none');
-      const button = document.querySelector('button')!;
-      button.click();
-      await window.happyDOM.waitUntilComplete();
-
-      // expect(ul.style.display).toBe('block');
-    });
-  });
-
   describe('/docs', (it) => {
     it('should configure the documentation spec', async () => {
       const response = await api.get('/docs/spec.json');
@@ -65,67 +20,14 @@ e2e(app, ({ api }) => {
     });
   });
 
-  describe('/auth/login', (it) => {
-    it('should return status code 400 if the request body does not include credentials', async () => {
-      const response = await api.post('/auth/login');
-      expect(response.status).toBe(400);
-    });
-    it('should return status code 400 if the request body does not include a username', async () => {
-      const response = await api.post('/auth/login').send({ username: 'admin' });
-      expect(response.status).toBe(400);
-    });
-    it('should return status code 400 if the request body does not include a password', async () => {
-      const response = await api.post('/auth/login').send({ password: 'password' });
-      expect(response.status).toBe(400);
-    });
-    it('should return status code 400 if username and password are empty strings', async () => {
-      const response = await api.post('/auth/login').send({ password: '', username: '' });
-      expect(response.status).toBe(400);
-    });
-    it('should return status code 400 if password is a number', async () => {
-      const response = await api.post('/auth/login').send({ password: 123, username: 'admin' });
-      expect(response.status).toBe(400);
-    });
-    it('should return status code 401 if the user does not exist', async () => {
-      const response = await api.post('/auth/login').send({ password: 'password', username: 'user' });
-      expect(response.status).toBe(401);
-    });
-    it('should return status code 200 and an access token if the credentials are correct', async () => {
-      const response = await api.post('/auth/login').send({ password: 'password', username: 'admin' });
-      expect(response.status).toBe(200);
-      expect(response.body).toStrictEqual({
-        accessToken: expect.stringMatching(/^[A-Za-z0-9-_]+\.([A-Za-z0-9-_]+)\.[A-Za-z0-9-_]+$/)
-      });
-    });
-  });
-
   describe('/cats', (it) => {
-    let accessToken: string;
     let createdCat: $Cat;
 
-    beforeEach(async () => {
-      const response = await api.post('/auth/login').send({ password: 'password', username: 'admin' });
-      accessToken = response.body.accessToken;
-    });
-
-    it('should return status code 401 if there is no access token provided', async () => {
-      const response = await api.get('/cats');
-      expect(response.status).toBe(401);
-    });
-
-    it('should return status code 401 if there is an invalid access token provided', async () => {
-      const response = await api.get('/cats').set('Authorization', `Bearer ${randomBytes(12).toString('base64')}`);
-      expect(response.status).toBe(401);
-    });
-
     it('should allow a POST request', async () => {
-      const response = await api
-        .post('/cats')
-        .set('Authorization', `Bearer ${accessToken}`)
-        .send({
-          age: 1,
-          name: 'Winston'
-        } satisfies $CreateCatData);
+      const response = await api.post('/cats').send({
+        age: 1,
+        name: 'Winston'
+      } satisfies $CreateCatData);
       expect(response.status).toBe(201);
       expect(response.body).toMatchObject({
         _id: expect.any(String),
@@ -136,7 +38,7 @@ e2e(app, ({ api }) => {
     });
 
     it('should allow a GET request', async () => {
-      const response = await api.get('/cats').set('Authorization', `Bearer ${accessToken}`);
+      const response = await api.get('/cats');
       expect(response.status).toBe(200);
       expect(response.body).toStrictEqual([createdCat]);
     });

example/app.controller.ts

@@ -1,64 +1,16 @@
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
-
-import { PrismaClient } from '@prisma/client';
-import { z } from 'zod/v4';
-
-import { $BaseEnv, AppFactory, AuthModule, CryptoService } from '../src/index.js';
-import { AppController } from './app.controller.js';
-import { CatsModule } from './cats/cats.module.js';
+import { $BaseEnv, acceptLanguage, AppFactory } from '../src/index.js';
+import { AppModule } from './app.module.js';
 
 export default AppFactory.create({
-  controllers: [AppController],
+  configureMiddleware: (consumer) => {
+    const middleware = acceptLanguage({ fallbackLanguage: 'en', supportedLanguages: ['en', 'fr'] });
+    consumer.apply(middleware).forRoutes('*');
+  },
   docs: {
     path: '/docs',
     title: 'Example API'
   },
   envSchema: $BaseEnv,
-  imports: [
-    AuthModule.forRootAsync({
-      inject: [CryptoService],
-      useFactory: (cryptoService: CryptoService) => {
-        return {
-          defineAbility: (ability, payload) => {
-            // We cannot correctly declare UserTypes here until we migrate to a monorepo setup
-            if ((payload as { isAdmin: true }).isAdmin) {
-              ability.can('manage', 'all');
-            }
-          },
-          schemas: {
-            loginCredentials: z.object({
-              password: z.string().min(1),
-              username: z.string().min(1)
-            })
-          },
-          userQuery: async ({ username }) => {
-            if (username !== 'admin') {
-              return null;
-            }
-            return {
-              hashedPassword: await cryptoService.hashPassword('password'),
-              tokenPayload: {
-                isAdmin: true
-              }
-            };
-          }
-        };
-      }
-    }),
-    CatsModule
-  ],
-  jsx: {
-    baseDir: import.meta.dirname,
-    importMap: {
-      index: () => import('./pages/index.js')
-    }
-  },
-  prisma: {
-    client: {
-      constructor: PrismaClient
-    },
-    dbPrefix: 'libnest-example',
-    useInMemoryDbForTesting: true
-  },
+  imports: [AppModule],
   version: null
 });

example/app.module.ts

@@ -1,7 +1,6 @@
 import { Body, Controller, Get, Post } from '@nestjs/common';
 import { ApiOperation } from '@nestjs/swagger';
 
-import { RouteAccess } from '../../src/index.js';
 import { CatsService } from './cats.service.js';
 import { $Cat, $CreateCatData } from './schemas/cat.schema.js';
 
@@ -11,14 +10,12 @@ export class CatsController {
 
   @ApiOperation({ summary: 'Create Cat' })
   @Post()
-  @RouteAccess({ action: 'create', subject: 'Cat' })
   async create(@Body() data: $CreateCatData): Promise<$Cat> {
     return this.catsService.create(data);
   }
 
   @ApiOperation({ summary: 'Get All Cats' })
   @Get()
-  @RouteAccess({ action: 'read', subject: 'Cat' })
   async findAll(): Promise<$Cat[]> {
     return this.catsService.findAll();
   }

example/app.test.ts

@@ -1,15 +1,15 @@
 /* eslint-disable perfectionist/sort-objects */
 
 import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import type { PrismaClient } from '@prisma/client';
 
 import { InjectPrismaClient } from '../../src/index.js';
 
-import type { PrismaClientLike } from '../../src/index.js';
 import type { $Cat } from './schemas/cat.schema.js';
 
 @Injectable()
 export class CatsService {
-  constructor(@InjectPrismaClient() private readonly prismaClient: PrismaClientLike) {}
+  constructor(@InjectPrismaClient() private readonly prismaClient: PrismaClient) {}
 
   async create(cat: Omit<$Cat, '_id'>): Promise<$Cat> {
     const id = crypto.randomUUID();