@quenty/remoting 6.5.0 → 6.6.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [6.6.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/remoting@6.5.0...@quenty/remoting@6.6.0) (2023-06-17)
+
+
+### Features
+
+* Add forward declaration ([40bb41e](https://github.com/Quenty/NevermoreEngine/commit/40bb41ebabe889faefda9aac11f03834bb1d4286))
+* Add Remoting class which accelerators remoting logic in Roblox ([50e3581](https://github.com/Quenty/NevermoreEngine/commit/50e358185e52fcc280d850d7f397264f8b31bff9))
+
+
+
+
+
 # [6.5.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/remoting@6.4.1...@quenty/remoting@6.5.0) (2023-04-10)
 
 **Note:** Version bump only for package @quenty/remoting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/remoting",
-  "version": "6.5.0",
+  "version": "6.6.0",
   "description": "Global remoting retrieval system for Roblox (RemoteFunctions/RemoteEvents)",
   "keywords": [
     "Roblox",
@@ -26,12 +26,17 @@
     "Quenty"
   ],
   "dependencies": {
+    "@quenty/brio": "^8.14.0",
+    "@quenty/instanceutils": "^7.15.0",
     "@quenty/loader": "^6.2.1",
-    "@quenty/promise": "^6.5.0",
+    "@quenty/maid": "^2.5.0",
+    "@quenty/promise": "^6.6.0",
+    "@quenty/remotefunctionutils": "^6.7.0",
+    "@quenty/rx": "^7.12.0",
     "@quenty/table": "^3.2.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3306212248c310731931ad45d8b86dc7247f2a5d"
+  "gitHead": "dc77d6de09e9eb9d3fd6dafd790c052d8393d38f"
 }

package/src/Shared/Interface/Remoting.lua

@@ -0,0 +1,532 @@
+--[=[
+	Offers a thin wrapper around Roblox remoting instances and events. Designed to reduce
+	the amount of code needed to construct a large set of RemoteFunction/RemoteEvent instances.
+
+	@class Remoting
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RunService = game:GetService("RunService")
+
+local Maid = require("Maid")
+local Promise = require("Promise")
+local promiseChild = require("promiseChild")
+local PromiseUtils = require("PromiseUtils")
+local RemoteFunctionUtils = require("RemoteFunctionUtils")
+local RemotingMember = require("RemotingMember")
+local RxBrioUtils = require("RxBrioUtils")
+local RxInstanceUtils = require("RxInstanceUtils")
+
+local RAW_MEMBERS = {
+	_name = true;
+	_maid = true;
+	_instance = true;
+	_remoteObjects = true;
+	_remoteFolder = true;
+}
+
+local REMOTE_EVENT_SUFFIX = "Event"
+local REMOTE_FUNCTION_SUFFIX = "Function"
+
+local Remoting = {}
+Remoting.ClassName = "Remoting"
+Remoting.__index = Remoting
+
+--[=[
+	Creates a new remoting instance
+
+	@param instance Instance
+	@param name string
+	@return Remoting
+]=]
+function Remoting.new(instance, name)
+	assert(typeof(instance) == "Instance", "Bad instance")
+	assert(type(name) == "string", "Bad name")
+
+	local self = setmetatable({}, Remoting)
+
+	self._maid = Maid.new()
+
+	self._instance = assert(instance, "No instance")
+	self._name = assert(name, "No name")
+
+	self._remoteFolderName = string.format("%sRemotes", self._name)
+	self._remoteObjects = {}
+
+	return self
+end
+
+function Remoting:__index(index)
+	if Remoting[index] then
+		return Remoting[index]
+	elseif RAW_MEMBERS[index] then
+		return rawget(self, index)
+	else
+		return RemotingMember.new(self, index)
+	end
+end
+
+--[=[
+	Connects to a given remote event.
+
+	@param memberName string
+	@param callback string
+	@return MaidTask
+]=]
+function Remoting:Connect(memberName, callback)
+	assert(type(memberName) == "string", "Bad memberName")
+	assert(type(callback) == "function", "Bad callback")
+
+	local connectMaid = Maid.new()
+
+	if RunService:IsServer() then
+		local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
+		connectMaid:GiveTask(remoteEvent.OnServerEvent:Connect(callback))
+
+		-- TODO: Cleanup if nothing else is expecting this
+	elseif RunService:IsClient() then
+		connectMaid:GiveTask(self:_observeRemoteEventBrio(memberName):Subscribe(function(brio)
+			if brio:IsDead() then
+				return
+			end
+
+			local remoteEvent = brio:GetValue()
+			local maid = brio:ToMaid()
+
+			maid:GiveTask(remoteEvent.OnClientEvent:Connect(callback))
+		end))
+
+		-- TODO: Warn if remote event doesn't exist
+	else
+		error("[Remoting.Connect] - Unknown RunService state")
+	end
+
+	self._maid[connectMaid] = connectMaid
+	connectMaid:GiveTask(function()
+		self._maid[connectMaid] = nil
+	end)
+
+	return connectMaid
+end
+
+--[=[
+	If on the server, creates a new [RemoteFunction] with the name `memberName` and binds the
+	invoke. On the client, it waits for the event to exist and then binds to it.
+
+	@param memberName string
+	@param callback any
+]=]
+function Remoting:Bind(memberName, callback)
+	assert(type(memberName) == "string", "Bad memberName")
+	assert(type(callback) == "function", "Bad callback")
+
+	local bindMaid = Maid.new()
+
+	if RunService:IsServer() then
+		local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
+		remoteFunction.OnServerInvoke = self:_translateCallback(bindMaid, memberName, callback)
+
+		-- TODO: Cleanup if nothing else is expecting this
+	elseif RunService:IsClient() then
+		bindMaid:GiveTask(self:_observeRemoteFunctionBrio():Subscribe(function(brio)
+			if brio:IsDead() then
+				return
+			end
+
+			local remoteFunction = brio:GetValue()
+			local maid = brio:ToMaid()
+
+			remoteFunction.OnClientInvoke = self:_translateCallback(maid, memberName, callback)
+		end))
+
+		-- TODO: Warn if remote function doesn't exist
+	else
+		error("[Remoting.Bind] - Unknown RunService state")
+	end
+
+	self._maid[bindMaid] = bindMaid
+	bindMaid:GiveTask(function()
+		self._maid[bindMaid] = nil
+	end)
+
+	return bindMaid
+end
+
+--[=[
+	Forward declares an event on the remoting object
+
+	@param memberName string
+]=]
+function Remoting:DeclareEvent(memberName)
+	assert(type(memberName) == "string", "Bad memberName")
+
+	if RunService:IsServer() then
+		self:_getOrCreateRemoteEvent(memberName)
+	end
+end
+
+--[=[
+	Forward declares an event on the remoting object
+
+	@param memberName string
+]=]
+function Remoting:DeclareMethod(memberName)
+	assert(type(memberName) == "string", "Bad memberName")
+
+	if RunService:IsServer() then
+		self:_getOrCreateRemoteFunction(memberName)
+	end
+end
+
+function Remoting:_translateCallback(maid, memberName, callback)
+	local alive = true
+	maid:GiveTask(function()
+		alive = false
+	end)
+
+	return function(...)
+		if not alive then
+			error(string.format("[Remoting] - Function for %s is disconnected and can't be called", memberName))
+			return
+		end
+
+		local results = table.pack(callback(...))
+
+		local hasPromise = false
+		for i=1, results.n do
+			if Promise.isPromise(results[i]) then
+				hasPromise = true
+				break
+			end
+		end
+
+		if hasPromise then
+			local promise
+			if results.n == 1 then
+				promise = results[1]
+			else
+				local data = {}
+				for i=1, results.n do
+					table.insert(data, results[i])
+				end
+
+				promise = PromiseUtils.combine(data)
+			end
+
+			promise = maid:GivePromise(promise)
+
+			local yielded = table.pack(promise:Wait())
+			return table.unpack(yielded, 1, yielded.n)
+		else
+			return ...
+		end
+	end
+end
+
+--[=[
+	Fires the client with the individual request. Should consider this syntax instead.
+
+	```lua
+	local remoting = Remoting.new(workspace, "Test")
+	remoting.Event:FireClient(otherPlayer, ...)
+	```
+
+	Equivalent of [RemoteFunction.FireClient].
+
+
+	@param memberName string
+	@param player Player
+	@param ... any
+]=]
+function Remoting:FireClient(memberName, player, ...)
+	assert(type(memberName) == "string", "Bad memberName")
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(RunService:IsServer(), "FireClient must be called on server")
+
+	local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
+	remoteEvent:FireClient(player, ...)
+end
+
+--[=[
+	Invokes the client, yielding as needed
+
+	Equivalent of [RemoteFunction.InvokeClient].
+
+	@server
+	@param memberName string
+	@param player Player
+	@param ... any
+]=]
+function Remoting:InvokeClient(memberName, player, ...)
+	assert(type(memberName) == "string", "Bad memberName")
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(RunService:IsServer(), "InvokeClient must be called on server")
+
+	local remoteEvent = self:_getOrCreateRemoteFunction(memberName)
+	remoteEvent:InvokeClient(player, ...)
+end
+
+--[=[
+	Fires all clients with the event.
+
+	Equivalent of [RemoteEvent.FireAllClients].
+
+	@server
+	@param memberName string
+	@param ... any
+]=]
+function Remoting:FireAllClients(memberName, ...)
+	assert(type(memberName) == "string", "Bad memberName")
+	assert(RunService:IsServer(), "FireAllClients must be called on server")
+
+	local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
+	remoteEvent:FireAllClients(memberName, ...)
+end
+
+--[=[
+	Fires the server
+
+	@client
+	@param memberName string
+	@param ... any
+]=]
+function Remoting:FireServer(memberName, ...)
+	assert(type(memberName) == "string", "Bad memberName")
+	assert(RunService:IsClient(), "FireServer must be called on server")
+
+	self:PromiseFireServer(memberName, ...)
+end
+
+--[=[
+	Fires the server, resolving the promise once it is fired.
+
+	@client
+	@param memberName string
+	@param ... any
+	@return Promise
+]=]
+function Remoting:PromiseFireServer(memberName, ...)
+	assert(type(memberName) == "string", "Bad memberName")
+	assert(RunService:IsClient(), "PromiseFireServer must be called on server")
+
+	local fireMaid = Maid.new()
+	local args = table.pack(...)
+
+	local promise = self:_promiseRemoteEvent(fireMaid, memberName)
+		:Then(function(remoteEvent)
+			remoteEvent:FireServer(table.unpack(args, 1, args.n))
+		end)
+
+	promise:Finally(function()
+		self._maid[fireMaid] = nil
+	end)
+	self._maid[fireMaid] = fireMaid
+	fireMaid:GiveTask(function()
+		self._maid[fireMaid] = nil
+	end)
+
+	-- TODO: Warn if remote event doesn't exist
+
+	return promise
+end
+
+--[=[
+	Invokes the server from the client
+
+	@client
+	@param memberName string
+	@param ... any
+	@return any
+]=]
+function Remoting:InvokeServer(memberName, ...)
+	assert(type(memberName) == "string", "Bad memberName")
+
+	return self:PromiseInvokeServer(memberName, ...):Wait()
+end
+
+--[=[
+	Invokes the server from the client
+
+	@client
+	@param memberName string
+	@param ... any
+	@return Promise<any>
+]=]
+function Remoting:PromiseInvokeServer(memberName, ...)
+	assert(type(memberName) == "string", "Bad memberName")
+
+	local invokeMaid = Maid.new()
+	local args = table.pack(...)
+
+	local promise = self:_promiseRemoteFunction(invokeMaid, memberName)
+		:Then(function(remoteFunction)
+			return invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeServer(remoteFunction, table.unpack(args, 1, args.n)))
+		end)
+
+	promise:Finally(function()
+		self._maid[invokeMaid] = nil
+	end)
+	self._maid[invokeMaid] = invokeMaid
+	invokeMaid:GiveTask(function()
+		self._maid[invokeMaid] = nil
+	end)
+
+	-- TODO: Warn if remote function doesn't exist
+
+	return promise
+end
+
+--[=[
+	Invokes the client from the server
+
+	@server
+	@param memberName string
+	@param player Player
+	@param ... any
+	@return Promise<any>
+]=]
+function Remoting:PromiseInvokeClient(memberName, player, ...)
+	assert(type(memberName) == "string", "Bad memberName")
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+
+	local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
+
+	local invokeMaid = Maid.new()
+
+	local promise = invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeClient(remoteFunction, player, ...))
+	promise:Finally(function()
+		self._maid[invokeMaid] = nil
+	end)
+
+	self._maid[invokeMaid] = invokeMaid
+	invokeMaid:GiveTask(function()
+		self._maid[invokeMaid] = nil
+	end)
+
+	return promise
+end
+
+function Remoting:_ensureFolder()
+	assert(RunService:IsServer(), "Folder should only be created on server")
+
+	if self._remoteFolder then
+		return self._remoteFolder
+	end
+
+	self._remoteFolder = Instance.new("Folder")
+	self._remoteFolder.Name = self._remoteFolderName
+	self._remoteFolder.Archivable = false
+	self._remoteFolder.Parent = self._instance
+
+	return self._remoteFolder
+end
+
+function Remoting:_observeRemoteFunctionBrio(memberName)
+	assert(type(memberName) == "string", "Bad memberName")
+
+	local remoteFunctionName = self:_getMemberName(memberName, REMOTE_FUNCTION_SUFFIX)
+
+	return self:_observeFolderBrio():Pipe({
+		RxBrioUtils.switchMapBrio(function(item)
+			return RxInstanceUtils.observeLastNamedChildBrio(item, "RemoteFunction", remoteFunctionName)
+		end)
+	})
+end
+
+function Remoting:_observeRemoteEventBrio(memberName)
+	assert(type(memberName) == "string", "Bad memberName")
+
+	local remoteFunctionName = self:_getMemberName(memberName, REMOTE_EVENT_SUFFIX)
+
+	return self:_observeFolderBrio():Pipe({
+		RxBrioUtils.switchMapBrio(function(item)
+			return RxInstanceUtils.observeLastNamedChildBrio(item, "RemoteEvent", remoteFunctionName)
+		end)
+	})
+end
+
+function Remoting:_promiseFolder(maid)
+	return maid:GivePromise(promiseChild(self._instance, self._remoteFolderName, 5))
+end
+
+function Remoting:_promiseRemoteEvent(maid, memberName)
+	local remoteEventName = self:_getMemberName(memberName, REMOTE_EVENT_SUFFIX)
+	return self:_promiseFolder(maid)
+		:Then(function(folder)
+			return maid:GivePromise(promiseChild(folder, remoteEventName, 5))
+		end)
+end
+
+function Remoting:_promiseRemoteFunction(maid, memberName)
+	local remoteEventName = self:_getMemberName(memberName, REMOTE_FUNCTION_SUFFIX)
+	return self:_promiseFolder(maid)
+		:Then(function(folder)
+			return maid:GivePromise(promiseChild(folder, remoteEventName, 5))
+		end)
+end
+
+
+function Remoting:_observeFolderBrio()
+	assert(self._instance, "Not initialized")
+
+	return RxInstanceUtils.observeLastNamedChildBrio(self._instance, "Folder", self._remoteFolderName)
+end
+
+function Remoting:_getOrCreateRemoteFunction(memberName)
+	assert(type(memberName) == "string", "Bad memberName")
+
+	local remoteFunctionName = self:_getMemberName(memberName, REMOTE_FUNCTION_SUFFIX)
+
+	if self._remoteObjects[remoteFunctionName] then
+		return self._remoteObjects[remoteFunctionName]
+	end
+
+	local folder = self:_ensureFolder()
+
+	local remoteFunction = Instance.new("RemoteFunction")
+	remoteFunction.Name = remoteFunctionName
+	remoteFunction.Archivable = false
+	remoteFunction.Parent = folder
+
+	self._remoteObjects[remoteFunctionName] = remoteFunction
+	self._maid[remoteFunction] = remoteFunction
+
+	return remoteFunction
+end
+
+function Remoting:_getOrCreateRemoteEvent(memberName)
+	assert(type(memberName) == "string", "Bad memberName")
+
+	local remoteEventName = self:_getMemberName(memberName, REMOTE_EVENT_SUFFIX)
+
+	if self._remoteObjects[remoteEventName] then
+		return self._remoteObjects[remoteEventName]
+	end
+
+	local folder = self:_ensureFolder()
+
+	local remoteEvent = Instance.new("RemoteEvent")
+	remoteEvent.Name = remoteEventName
+	remoteEvent.Archivable = false
+	remoteEvent.Parent = folder
+
+	self._maid[remoteEvent] = remoteEvent
+	self._remoteObjects[remoteEventName] = remoteEvent
+
+	return remoteEvent
+end
+
+function Remoting:_getMemberName(memberName, objectType)
+	return memberName .. objectType
+end
+
+--[=[
+	Cleans up the remoting object
+]=]
+function Remoting:Destroy()
+	self._maid:DoCleaning()
+	setmetatable(self, nil)
+end
+
+return Remoting

package/src/Shared/Interface/RemotingMember.lua

@@ -0,0 +1,189 @@
+--[=[
+	Helper class for the [Remoting] object which allows more natural syntax
+	to be used against the remoting API surface.
+
+	@class RemotingMember
+]=]
+
+local RunService = game:GetService("RunService")
+
+local RemotingMember = {}
+RemotingMember.ClassName = "RemotingMember"
+RemotingMember.__index = RemotingMember
+
+--[=[
+	Constructs a new RemotingMember
+
+	@param remoting Remoting
+	@param memberName string
+	@return RemotingMember
+]=]
+function RemotingMember.new(remoting, memberName)
+	local self = setmetatable({}, RemotingMember)
+
+	self._remoting = assert(remoting, "No remoting")
+	self._memberName = assert(memberName, "No memberName")
+
+	return self
+end
+
+--[=[
+	Binds to the member.
+
+	On the server this will create the remote function. On the client
+	this will connect to the remote event once it's created.
+
+	@param callback function
+	@return MaidTask
+]=]
+function RemotingMember:Bind(callback)
+	assert(type(callback) == "function", "Bad callback")
+
+	return self._remoting:Bind(self._memberName, callback)
+end
+
+--[=[
+	Connects to the equivalent of a RemoteEvent for this member.
+
+	On the server this will create the remote event. On the client
+	this will connect to the remote event once it's created.
+
+	See [Remoting.Connect] for additional details.
+
+	@param callback function
+	@return MaidTask
+]=]
+function RemotingMember:Connect(callback)
+	assert(type(callback) == "function", "Bad callback")
+
+	return self._remoting:Connect(self._memberName, callback)
+end
+
+--[=[
+	Forward declares an event on the remoting object
+]=]
+function RemotingMember:DeclareEvent()
+	return self._remoting:DeclareEvent(self._memberName)
+end
+
+--[=[
+	Forward declares a method on the remoting object
+]=]
+function RemotingMember:DeclareMethod()
+	return self._remoting:DeclareMethod(self._memberName)
+end
+
+--[=[
+	Fires the remote event on the server
+
+	@client
+	@param ... any
+]=]
+function RemotingMember:FireServer(...)
+	assert(RunService:IsClient(), "FireServer must be called on client")
+	self._remoting:FireServer(self._memberName, ...)
+end
+
+--[=[
+	Invokes the server from the client
+
+	@client
+	@param ... any
+]=]
+function RemotingMember:InvokeServer(...)
+	assert(RunService:IsClient(), "InvokeServer must be called on client")
+
+	return self._remoting:InvokeServer(self._memberName, ...)
+end
+
+--[=[
+	Invokes the client from the server.
+
+	@client
+	@param ... any
+]=]
+function RemotingMember:PromiseInvokeServer(...)
+	assert(RunService:IsClient(), "PromiseInvokeServer must be called on client")
+
+	return self._remoting:PromiseInvokeServer(self._memberName, ...)
+end
+
+--[=[
+	Fires the server from the client. Promise resolves once the event is sent.
+
+	@client
+	@param ... any
+	@return Promise
+]=]
+function RemotingMember:PromiseFireServer(...)
+	assert(RunService:IsClient(), "PromiseInvokeServer must be called on client")
+
+	return self._remoting:PromiseFireServer(self._memberName, ...)
+end
+
+
+--[=[
+	Invokes the client from the server.
+
+	See [Remoting.PromiseInvokeClient].
+
+	@server
+	@param player Player
+	@param ... any
+	@return Promise<any>
+]=]
+function RemotingMember:PromiseInvokeClient(player, ...)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(RunService:IsServer(), "PromiseInvokeClient must be called on client")
+
+	return self._remoting:PromiseInvokeClient(self._memberName, player, ...)
+end
+
+--[=[
+	Invokes the client from the server
+
+	See [Remoting.InvokeClient].
+
+	@server
+	@param player Player
+	@param ... any
+	@return ... any
+]=]
+function RemotingMember:InvokeClient(player, ...)
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+	assert(RunService:IsServer(), "InvokeClient must be called on client")
+
+	return self._remoting:InvokeClient(self._memberName, player, ...)
+end
+
+--[=[
+	Fires all clients.
+
+	See [Remoting.FireAllClients].
+
+	@server
+	@param ... any
+]=]
+function RemotingMember:FireAllClients(...)
+	assert(RunService:IsServer(), "FireAllClients must be called on client")
+
+	self._remoting:FireAllClients(self._memberName, ...)
+end
+
+--[=[
+	Fires the client with the data
+
+	See [Remoting.FireClient].
+
+	@server
+	@param player Instance
+	@param ... any
+]=]
+function RemotingMember:FireClient(player, ...)
+	assert(RunService:IsServer(), "FireClient must be called on client")
+	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
+
+	self._remoting:FireClient(self._memberName, player, ...)
+end
+
+return RemotingMember