@rbxts/tether 1.0.6 → 1.0.7

package/README.md

@@ -69,10 +69,14 @@ import { MessageEmitter, BuiltinMiddlewares } from "@rbxts/tether";
 
 export const messaging = MessageEmitter.create<MessageData>();
 messaging.middleware
-  .useUniversal(Message.Test, [BuiltinMiddlewares.rateLimit(5)]) // only allows requests every 5 seconds, drops any
-                                                                 // requests that occur within 5 seconds of each other
-  .useClient(Message.Test, [BuiltinMiddlewares.validateClient()]); // automatically validates that data sent through the remote
-                                                                   // matches the data associated with the message at runtime
+  // only allows requests to the server every 5 seconds,
+  // drops any requests that occur within 5 seconds of each other
+  .useServer(Message.Test, [BuiltinMiddlewares.rateLimit(5)]) 
+  // automatically validates that data sent through the remote
+  // matches the data associated with the message at runtime
+  .useShared(Message.Test, [BuiltinMiddlewares.validateClient()])
+  // rate limit every server remote (global)
+  .useServerGlobal([BuiltinMiddlewares.rateLimit(1)]);
 
 export const enum Message {
   Test

package/out/builtin-middlewares.d.ts

@@ -1,5 +1,5 @@
 import { Modding } from "@flamework/core";
-import { type UniversalMiddleware, type ServerMiddleware, type ClientMiddleware } from "./middleware";
+import { type SharedMiddleware, type ServerMiddleware, type ClientMiddleware } from "./middleware";
 type Guard<T> = (value: unknown) => value is T;
 export declare namespace BuiltinMiddlewares {
     /**
@@ -7,7 +7,7 @@ export declare namespace BuiltinMiddlewares {
      * @param interval The interval in seconds that the middleware should wait before allowing a new request.
      * @returns A middleware that will drop any message that occurs within the given interval.
      */
-    function rateLimit(interval: number): UniversalMiddleware;
+    function rateLimit(interval: number): SharedMiddleware;
     /**
      * Creates a server middleware that validates the data with the given guard (or a generated guard if none was provided).
      * If the guard fails, the middleware will drop the message.

package/out/builtin-middlewares.luau

@@ -3,7 +3,7 @@ local TS = _G[script]
 local DropRequest = TS.import(script, script.Parent, "middleware").DropRequest
 local noOp = function() end
 local validationGuardGenerationFailed = function(context)
-	return `[Tether]: Failed to generate guard for validate{context}<T> builtin middleware - skipping validation`
+	return `[@rbxts/tether]: Failed to generate guard for validate{context}<T> builtin middleware - skipping validation`
 end
 local BuiltinMiddlewares = {}
 do

package/out/message-emitter.luau

@@ -89,7 +89,7 @@ do
 	function MessageEmitter:create(metaForEachMessage)
 		local emitter = MessageEmitter.new()
 		if metaForEachMessage == nil then
-			warn("[Tether]: Failed to generate serializer metadata for MessageEmitter")
+			warn("[@rbxts/tether]: Failed to generate serializer metadata for MessageEmitter")
 			return emitter:initialize()
 		end
 		for kind, meta in pairs(metaForEachMessage) do

package/out/middleware.d.ts

@@ -4,17 +4,26 @@ type DropRequestSymbol = symbol & {
 export declare const DropRequest: DropRequestSymbol;
 export type ClientMiddleware<Data = unknown> = (player: Player, data: Readonly<Data> | undefined) => DropRequestSymbol | void;
 export type ServerMiddleware<Data = unknown> = (data: Readonly<Data> | undefined) => DropRequestSymbol | void;
-export type UniversalMiddleware = () => DropRequestSymbol | void;
+export type SharedMiddleware = () => DropRequestSymbol | void;
 export type Middleware<Data = unknown> = ServerMiddleware<Data> & ClientMiddleware<Data>;
 export declare class MiddlewareProvider<MessageData> {
+    private readonly clientGlobalMiddlewares;
+    private readonly serverGlobalMiddlewares;
     private readonly clientMiddlewares;
     private readonly serverMiddlewares;
     /** @hidden */
     getClient<Kind extends keyof MessageData>(message: Kind): ClientMiddleware<MessageData[Kind]>[];
     /** @hidden */
     getServer<Kind extends keyof MessageData>(message: Kind): ServerMiddleware<MessageData[Kind]>[];
-    useClient<Kind extends keyof MessageData>(message: Kind, middlewares: ClientMiddleware<MessageData[Kind]> | ClientMiddleware<MessageData[Kind]>[], order?: number): this;
-    useServer<Kind extends keyof MessageData>(message: Kind, middlewares: ServerMiddleware<MessageData[Kind]> | ServerMiddleware<MessageData[Kind]>[], order?: number): this;
-    useUniversal<Kind extends keyof MessageData>(message: Kind, middlewares: UniversalMiddleware | UniversalMiddleware[], order?: number): this;
+    /** @hidden */
+    getClientGlobal<Data>(): ClientMiddleware<Data>[];
+    /** @hidden */
+    getServerGlobal<Data>(): ServerMiddleware<Data>[];
+    useClient<Kind extends keyof MessageData>(message: Kind, middlewares: ClientMiddleware<MessageData[Kind]> | readonly ClientMiddleware<MessageData[Kind]>[], order?: number): this;
+    useServer<Kind extends keyof MessageData>(message: Kind, middlewares: ServerMiddleware<MessageData[Kind]> | readonly ServerMiddleware<MessageData[Kind]>[], order?: number): this;
+    useShared<Kind extends keyof MessageData>(message: Kind, middlewares: SharedMiddleware | readonly SharedMiddleware[], order?: number): this;
+    useClientGlobal<Data>(middlewares: ClientMiddleware<Data> | readonly ClientMiddleware<Data>[], order?: number): this;
+    useServerGlobal<Data>(middlewares: ServerMiddleware<Data> | readonly ServerMiddleware<Data>[], order?: number): this;
+    useSharedGlobal(middlewares: SharedMiddleware | readonly SharedMiddleware[], order?: number): this;
 }
 export {};

package/out/middleware.luau

@@ -13,6 +13,8 @@ do
 		return self:constructor(...) or self
 	end
 	function MiddlewareProvider:constructor()
+		self.clientGlobalMiddlewares = {}
+		self.serverGlobalMiddlewares = {}
 		self.clientMiddlewares = {}
 		self.serverMiddlewares = {}
 	end
@@ -28,6 +30,12 @@ do
 		end
 		return self.serverMiddlewares[message]
 	end
+	function MiddlewareProvider:getClientGlobal()
+		return self.clientGlobalMiddlewares
+	end
+	function MiddlewareProvider:getServerGlobal()
+		return self.serverGlobalMiddlewares
+	end
 	function MiddlewareProvider:useClient(message, middlewares, order)
 		local messageMiddleware = self:getClient(message)
 		local _middlewares = middlewares
@@ -40,7 +48,7 @@ do
 			table.insert(messageMiddleware, _condition + 1, _middlewares_1)
 		else
 			for _, middleware in middlewares do
-				self:useClient(message, middleware)
+				self:useClient(message, middleware, order)
 			end
 		end
 		return self
@@ -57,16 +65,55 @@ do
 			table.insert(messageMiddleware, _condition + 1, _middlewares_1)
 		else
 			for _, middleware in middlewares do
-				self:useServer(message, middleware)
+				self:useServer(message, middleware, order)
 			end
 		end
 		return self
 	end
-	function MiddlewareProvider:useUniversal(message, middlewares, order)
+	function MiddlewareProvider:useShared(message, middlewares, order)
 		self:useClient(message, middlewares, order)
 		self:useServer(message, middlewares, order)
 		return self
 	end
+	function MiddlewareProvider:useClientGlobal(middlewares, order)
+		local globalMiddleware = self:getClientGlobal()
+		local _middlewares = middlewares
+		if typeof(_middlewares) == "function" then
+			local _condition = order
+			if _condition == nil then
+				_condition = #globalMiddleware - 1
+			end
+			local _middlewares_1 = middlewares
+			table.insert(globalMiddleware, _condition + 1, _middlewares_1)
+		else
+			for _, middleware in middlewares do
+				self:useClientGlobal(middleware, order)
+			end
+		end
+		return self
+	end
+	function MiddlewareProvider:useServerGlobal(middlewares, order)
+		local globalMiddleware = self:getServerGlobal()
+		local _middlewares = middlewares
+		if typeof(_middlewares) == "function" then
+			local _condition = order
+			if _condition == nil then
+				_condition = #globalMiddleware - 1
+			end
+			local _middlewares_1 = middlewares
+			table.insert(globalMiddleware, _condition + 1, _middlewares_1)
+		else
+			for _, middleware in middlewares do
+				self:useServerGlobal(middleware, order)
+			end
+		end
+		return self
+	end
+	function MiddlewareProvider:useSharedGlobal(middlewares, order)
+		self:useClientGlobal(middlewares, order)
+		self:useServerGlobal(middlewares, order)
+		return self
+	end
 end
 return {
 	DropRequest = DropRequest,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbxts/tether",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "main": "out/init.lua",
   "scripts": {
     "build": "rbxtsc",