Update dependencies

src/app/handler/AuthHandler.ts

@@ -22,7 +22,7 @@ import { AuthServiceProvider, JWTServiceProvider } from "midori/providers";
 import { Payload } from "midori/util/jwt.js";
 import { generateUUID } from "midori/util/uuid.js";
 
-import UserDAO from "@core/dao/UserDAO.js";
+import { prisma } from "@core/lib/Prisma.js";
 
 import { OpenIDServiceProvider } from "@app/providers/OpenIDServiceProvider.js";
 import OpenIDService from "@app/services/OpenIDService.js";
@@ -95,11 +95,13 @@ export class Callback extends Handler {
 
         const OauthUser = await identity_response.json();
 
-        const user = await UserDAO.create({
-            id: generateUUID(),
-            username: OauthUser.preferred_username,
-            password: null,
-            email: OauthUser.email,
+        const user = await prisma.user.create({
+            data: {
+                id: generateUUID(),
+                username: OauthUser.preferred_username,
+                password: null,
+                email: OauthUser.email,
+            }
         });
 
         const issuedAt = Date.now();

src/app/middleware/OauthScopeMiddleware.ts

@@ -16,13 +16,16 @@
 
 import { HTTPError } from "midori/errors";
 import { EStatusCode, Middleware, Request, Response } from "midori/http";
+import { AuthBearerMiddleware } from "midori/middlewares";
+import { Payload } from "midori/util/jwt.js";
 import { Constructor } from "midori/util/types.js";
 
 export default function OauthScopeMiddlewareFactory(options: { scopes: string[]; }): Constructor<Middleware> {
     return class extends Middleware {
-        async process(req: Request, next: (req: Request) => Promise<Response>): Promise<Response> {
-            if (req.container.get('::jwt')) {
-                const userScopes = (req.container.get('::jwt').scope ?? '').split(' ');
+        override async process(req: Request, next: (req: Request) => Promise<Response>): Promise<Response> {
+            const jwt = req.container.get(AuthBearerMiddleware.TokenKey) as (Payload & { username: string; scope: string; }) | undefined;
+            if (jwt) {
+                const userScopes = (jwt.scope ?? '').split(' ');
                 for (const scope of options.scopes) {
                     if (!userScopes.includes(scope)) {
                         throw new HTTPError(`Insufficient permissions: ${scope}`, EStatusCode.FORBIDDEN);

src/app/providers/GamesServiceProvider.ts

@@ -19,7 +19,7 @@ import { ServiceProvider, Application } from 'midori/app';
 import GamesService from '@app/services/GamesService.js';
 
 export default class GamesServiceProvider extends ServiceProvider<GamesService> {
-    static service: string = 'ChessGames';
+    static override service: symbol = Symbol('ChessGames');
 
     register(app: Application): GamesService {
         return new GamesService();

src/app/providers/OpenIDServiceProvider.ts

@@ -20,7 +20,7 @@ import { Constructor } from "midori/util/types.js";
 import OpenIDService from "@app/services/OpenIDService.js";
 
 export abstract class OpenIDServiceProvider extends ServiceProvider<OpenIDService> {
-    static service: string = 'OpenID';
+    static override service: symbol = Symbol('OpenID');
 }
 
 export default function (openIDService: OpenIDService): Constructor<OpenIDServiceProvider> & { [K in keyof typeof OpenIDServiceProvider]: typeof OpenIDServiceProvider[K] } {

src/app/services/PrismaUserService.ts

@@ -14,11 +14,10 @@
  * limitations under the License.
  */
 
+import { prisma } from "@core/lib/Prisma.js";
 import { User, UserService } from "midori/auth";
 import { Hash } from "midori/hash";
 
-import UserDAO from "@core/dao/UserDAO.js";
-
 export default class PrismaUserService extends UserService {
     #hash: Hash;
 
@@ -29,11 +28,11 @@ export default class PrismaUserService extends UserService {
     }
 
     async getUserById(id: string): Promise<User | null> {
-        return await UserDAO.get({ select: { id: true, username: true }, where: { id } });
+        return await prisma.user.findFirst({ select: { id: true, username: true }, where: { id } });
     }
 
     async getUserByCredentials(username: string, password: string): Promise<User | null> {
-        const user = await UserDAO.get({ select: { id: true, username: true, password: true }, where: { username } });
+        const user = await prisma.user.findFirst({ select: { id: true, username: true, password: true }, where: { username } });
 
         if (!user || !user.password) {
             return null;

src/config.ts

@@ -59,7 +59,6 @@ export default function config(server: Server): void {
             enc: process.env.JWE_ENCRYPTION || 'A256GCM',
             secret: process.env.JWE_SECRET,
             privateKeyFile: process.env.JWE_PRIVATE_KEY,
-            ephemeralPrivateKeyFile: process.env.JWE_EPHEMERAL_KEY,
         },
     }));
 

src/providers.ts

@@ -43,7 +43,7 @@ import OpenIDService from "@app/services/OpenIDService.js";
 
 export default function providers(server: Server): void {
     server.install(RouterServiceProviderFactory(router));
-    server.install(LoggerServiceProviderFactory(new ConsoleLogger({ colorsEnabled: true, minLevel: LogLevel.DEBUG })));
+    server.install(LoggerServiceProviderFactory(new ConsoleLogger({ formattingEnabled: true, minLevel: LogLevel.DEBUG })));
 
     // Add providers here
     // Recover the provider with app.services.get(ServiceProvider) in your handlers and middleware constructors

src/server.ts

@@ -38,14 +38,12 @@ config(server);
 providers(server);
 pipeline(server);
 cron(server);
-ws(server);
 
 const port = parseInt(process.env.PORT || '3000');
 
 await new Promise<void>((resolve, reject) => {
     server.listen(port).on('listening', async () => {
-        console.log(`Server is running on port ${port}`);
-
+        console.log(`Server is running on port ${port} in ${server.production ? 'production' : 'development'} mode`);
         await prisma.$connect();
         resolve();
     }).on('close', async () => {