feat core

- server/client middlewares

browser/src/core/rpc.ts

@@ -1,7 +1,6 @@
 import { Rpc } from '@entityseven/rage-fw-rpc'
 
 export const rpc = new Rpc({
-    forceBrowserDevMode:
+    forceBrowserDevMode: process.env.RageFW_forceBrowserDevMode === 'true',
-        process.env.RageFW_forceBrowserDevMode === 'true' ?? false,
     debugLogs: false,
 })

client/src/core/client.ts

@@ -1,16 +1,24 @@
 import { rpc } from './rpc'
+import { Middleware } from './middleware'
 import type * as T from '../types'
 
 export class Client {
     public register<EventName extends T.RageFW_ClientEvent>(
         eventName: EventName,
         callback: T.RageFW_ClientCallback<EventName>,
+        options?: {
+            middlewares?: T.RageFW_MiddlewareOptions<EventName>
+        },
     ): Client {
         rpc.register<
             Parameters<typeof callback>,
-            ReturnType<typeof callback>,
+            ReturnType<typeof callback> | Promise<unknown>,
             EventName
-        >(eventName, async (...data) => await callback(...data))
+        >(eventName, async (...data) => {
+            if (!options?.middlewares) return await callback(...data)
+
+            await Middleware.process(options.middlewares, callback, data)
+        })
 
         return this
     }

client/src/core/index.ts

@@ -1,4 +1,5 @@
 export * from './client'
 export * from './logger'
+export * from './middleware'
 export * from './player'
 export * from './rpc'

client/src/core/middleware.ts

@@ -0,0 +1,54 @@
+import type * as T from '../types'
+
+export class Middleware {
+    constructor() {}
+
+    private static async execute<EventName extends T.RageFW_ClientEvent>(
+        middlewares: T.RageFW_MiddlewareFunction<EventName>[],
+        args: T.RageFW_ClientArgs<EventName>,
+    ): Promise<T.RageFW_MiddlewareResponseInternal> {
+        for (let i = 0; i < middlewares.length; i++) {
+            const result = await middlewares[i](...args)
+
+            if (typeof result === 'boolean' && !result)
+                return { success: result, id: i }
+            if (typeof result !== 'boolean' && !result.success)
+                return { ...result, id: i }
+        }
+
+        return {
+            success: true,
+        }
+    }
+
+    public static async process<EventName extends T.RageFW_ClientEvent>(
+        middlewareOptions: T.RageFW_MiddlewareOptions<EventName>,
+        callback: T.RageFW_ClientCallback<EventName>,
+        args: T.RageFW_ClientArgs<EventName>,
+    ) {
+        if (Array.isArray(middlewareOptions)) {
+            const middlewaresResponse = await Middleware.execute(
+                middlewareOptions,
+                args,
+            )
+
+            if (middlewaresResponse.success) return await callback(...args)
+        } else {
+            const middlewaresResponse = await Middleware.execute(
+                middlewareOptions.executables,
+                args,
+            )
+
+            if (middlewaresResponse.success) {
+                return await callback(...args)
+            } else {
+                middlewareOptions.onError(
+                    middlewaresResponse.message ??
+                        'Middleware with id ' +
+                            middlewaresResponse.id +
+                            ' failed',
+                )
+            }
+        }
+    }
+}

client/src/index.ts

@@ -1,5 +1,7 @@
 import { Client, Logger, Player, rpc } from './core'
 
+export type { RageFW_MiddlewareFunction } from './types'
+
 export const fw = {
     event: new Client(),
     player: new Player(),

client/src/types/index.ts

@@ -1,3 +1,4 @@
-export * from './client'
-export * from './server'
 export * from './browser'
+export * from './client'
+export * from './middleware'
+export * from './server'

client/src/types/middleware.ts

@@ -0,0 +1,26 @@
+import type * as T from './client'
+
+export type RageFW_MiddlewareResponse =
+    | {
+          success: boolean
+          message?: string
+      }
+    | boolean
+
+export type RageFW_MiddlewareResponseInternal = {
+    success: boolean
+    message?: string
+    id?: number
+}
+
+export type RageFW_MiddlewareFunction<EventName extends T.RageFW_ClientEvent> =
+    (
+        ...args: T.RageFW_ClientArgs<EventName>
+    ) => Promise<RageFW_MiddlewareResponse>
+
+export type RageFW_MiddlewareOptions<EventName extends T.RageFW_ClientEvent> =
+    | RageFW_MiddlewareFunction<EventName>[]
+    | {
+          executables: RageFW_MiddlewareFunction<EventName>[]
+          onError: (error: string) => unknown
+      }

server/src/core/index.ts

@@ -1,4 +1,5 @@
 export * from './logger'
+export * from './middleware'
 export * from './player'
 export * from './rpc'
 export * from './server'

server/src/core/middleware.ts

@@ -0,0 +1,54 @@
+import type * as T from '../types'
+
+export class Middleware {
+    constructor() {}
+
+    private static async execute<EventName extends T.RageFW_ServerEvent>(
+        middlewares: T.RageFW_MiddlewareFunction<EventName>[],
+        args: T.RageFW_ServerArgs<EventName>,
+    ): Promise<T.RageFW_MiddlewareResponseInternal> {
+        for (let i = 0; i < middlewares.length; i++) {
+            const result = await middlewares[i](...args)
+
+            if (typeof result === 'boolean' && !result)
+                return { success: result, id: i }
+            if (typeof result !== 'boolean' && !result.success)
+                return { ...result, id: i }
+        }
+
+        return {
+            success: true,
+        }
+    }
+
+    public static async process<EventName extends T.RageFW_ServerEvent>(
+        middlewareOptions: T.RageFW_MiddlewareOptions<EventName>,
+        callback: T.RageFW_ServerCallback<EventName>,
+        args: T.RageFW_ServerArgs<EventName>,
+    ) {
+        if (Array.isArray(middlewareOptions)) {
+            const middlewaresResponse = await Middleware.execute(
+                middlewareOptions,
+                args,
+            )
+
+            if (middlewaresResponse.success) return await callback(...args)
+        } else {
+            const middlewaresResponse = await Middleware.execute(
+                middlewareOptions.executables,
+                args,
+            )
+
+            if (middlewaresResponse.success) {
+                return await callback(...args)
+            } else {
+                middlewareOptions.onError(
+                    middlewaresResponse.message ??
+                        'Middleware with id ' +
+                            middlewaresResponse.id +
+                            ' failed',
+                )
+            }
+        }
+    }
+}

server/src/core/server.ts

@@ -1,16 +1,24 @@
 import { rpc } from './rpc'
+import { Middleware } from './middleware'
 import type * as T from '../types'
 
 export class Server {
     public register<EventName extends T.RageFW_ServerEvent>(
         eventName: EventName,
         callback: T.RageFW_ServerCallback<EventName>,
+        options?: {
+            middlewares?: T.RageFW_MiddlewareOptions<EventName>
+        },
     ): Server {
         rpc.register<
             Parameters<typeof callback>,
-            ReturnType<typeof callback>,
+            ReturnType<typeof callback> | Promise<unknown>,
             EventName
-        >(eventName, async (...data) => await callback(...data))
+        >(eventName, async (...data) => {
+            if (!options?.middlewares) return await callback(...data)
+
+            await Middleware.process(options.middlewares, callback, data)
+        })
 
         return this
     }

server/src/index.ts

@@ -1,5 +1,7 @@
 import { Logger, Player, Server, rpc } from './core'
 
+export type { RageFW_MiddlewareFunction } from './types'
+
 export const fw = {
     event: new Server(),
     player: new Player(),

server/src/types/index.ts

@@ -1,3 +1,4 @@
-export * from './client'
-export * from './server'
 export * from './browser'
+export * from './client'
+export * from './middleware'
+export * from './server'

server/src/types/middleware.ts

@@ -0,0 +1,26 @@
+import type * as T from './server'
+
+export type RageFW_MiddlewareResponse =
+    | {
+          success: boolean
+          message?: string
+      }
+    | boolean
+
+export type RageFW_MiddlewareResponseInternal = {
+    success: boolean
+    message?: string
+    id?: number
+}
+
+export type RageFW_MiddlewareFunction<EventName extends T.RageFW_ServerEvent> =
+    (
+        ...args: T.RageFW_ServerArgs<EventName>
+    ) => Promise<RageFW_MiddlewareResponse>
+
+export type RageFW_MiddlewareOptions<EventName extends T.RageFW_ServerEvent> =
+    | RageFW_MiddlewareFunction<EventName>[]
+    | {
+          executables: RageFW_MiddlewareFunction<EventName>[]
+          onError: (error: string) => unknown
+      }