@axpecter/lync 2.1.2 → 2.2.1

package/src/api/Query.luau

@@ -5,275 +5,285 @@
 local Players = game:GetService("Players")
 local RunService = game:GetService("RunService")
 
-local Baseline = require(script.Parent.Parent.internal.Baseline)
 local Channel = require(script.Parent.Parent.internal.Channel)
 local Registry = require(script.Parent.Parent.internal.Registry)
+local Transport = require(script.Parent.Parent.internal.Transport)
 local Types = require(script.Parent.Parent.Types)
+local Util = require(script.Parent.Parent.internal.Util)
 
--- Constants -----------------------------------------------------------
+-- Constants --------------------------------------------------------------
 
 local IS_SERVER = RunService:IsServer()
 local DEFAULT_TIMEOUT = 5
 
--- State ---------------------------------------------------------------
+-- State ------------------------------------------------------------------
 
 local _nextCorrId = 0
 local _pending: { [number]: thread } = {}
+local _pendingGather: { [number]: (any) -> () } = {}
 
--- Public --------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
-local Query = {}
+local isPlayer = Util.isPlayer
+
+local function nextCorr(): number
+    _nextCorrId += 1
+    return _nextCorrId
+end
 
-export type QueryHandle = {
-    handle: (self: QueryHandle, fn: (request: any, player: Player?) -> any) -> Types.Connection,
-    request: (self: QueryHandle, data: any, target: any?) -> any,
-    name: (self: QueryHandle) -> string,
-    stats: (self: QueryHandle) -> Types.PacketStats,
+-- Public types -----------------------------------------------------------
+
+--[[
+    Server `request(data, target)` returns `Resp?` for a Player target and
+    `{ [Player]: Resp? }` for a multi-target table; Luau doesn't support
+    overloads on table fields, so the type advertises `Resp?` (the common
+    single-target case). Multi-target callers must cast the return.
+]]
+export type QueryHandle<Req, Resp> = {
+    handle: (
+        self: QueryHandle<Req, Resp>,
+        fn: (request: Req, player: Player?) -> Resp?
+    ) -> Types.Connection,
+    request: (self: QueryHandle<Req, Resp>, data: Req, target: any?) -> Resp?,
+    name: (self: QueryHandle<Req, Resp>) -> string,
+    stats: (self: QueryHandle<Req, Resp>) -> Types.PacketStats,
 }
 
-function Query.define(
+-- Public -----------------------------------------------------------------
+
+local Query = {}
+
+function Query.define<Req, Resp>(
     name: string,
-    requestCodec: Types.InternalCodec<any>,
-    responseCodec: Types.InternalCodec<any>,
+    requestCodec: Types.InternalCodec<Req>,
+    responseCodec: Types.InternalCodec<Resp>,
     options: Types.QueryOptions?
-): QueryHandle
-    local opts = options or {} :: Types.QueryOptions
+): QueryHandle<Req, Resp>
+    local opts = options or ({} :: Types.QueryOptions)
     local timeout = opts.timeout or DEFAULT_TIMEOUT
 
-    -- Register request channel
     local reqOpenFn = Channel.resolveOpenFn(Channel.TS_NONE, name)
-    local reqReg = Registry.register(
-        name,
-        Registry.KIND_REQUEST,
-        requestCodec,
-        false,
-        nil,
-        IS_SERVER,
-        1,
-        Channel.TS_NONE,
-        reqOpenFn,
-        opts.rateLimit or { maxPerSecond = 30 },
-        opts.validate,
-        nil
-    )
-
-    -- Register response channel (paired)
-    local respOpenFn = Channel.resolveOpenFn(Channel.TS_NONE, `{name}_resp`)
-    local respReg = Registry.register(
-        `{name}_resp`,
-        Registry.KIND_RESPONSE,
-        responseCodec,
-        false,
-        reqReg.id,
-        false,
-        1,
-        Channel.TS_NONE,
-        respOpenFn,
-        nil,
-        nil,
-        nil
-    )
+    local respName = `{name}\0resp`
+    local respOpenFn = Channel.resolveOpenFn(Channel.TS_NONE, respName)
+
+    local reqReg = Registry.register({
+        name = name,
+        kind = Registry.KIND_REQUEST,
+        codec = requestCodec,
+        isUnreliable = false,
+        partner = nil,
+        needsGate = IS_SERVER,
+        headerSize = 1,
+        timestampMode = Channel.TS_NONE,
+        openFn = reqOpenFn,
+        rateLimit = opts.rateLimit or { maxPerSecond = 30 },
+        validate = opts.validate,
+        maxPayloadBytes = nil,
+    })
+
+    local respReg = Registry.register({
+        name = respName,
+        kind = Registry.KIND_RESPONSE,
+        codec = responseCodec,
+        isUnreliable = false,
+        partner = reqReg.id,
+        needsGate = false,
+        headerSize = 1,
+        timestampMode = Channel.TS_NONE,
+        openFn = respOpenFn,
+        rateLimit = nil,
+        validate = nil,
+        maxPayloadBytes = nil,
+    })
 
     reqReg.partner = respReg.id
 
-    -- Lazy-require to avoid circular deps
-    local _server: any = nil
-    local _client: any = nil
-
-    local function getServer(): any
-        if not _server then
-            _server = require(script.Parent.Parent.transport.Server)
-        end
-        return _server
-    end
+    local activeHandler: ((any, Player?) -> any)? = nil
+    local handlerToken = 0
 
-    local function getClient(): any
-        if not _client then
-            _client = require(script.Parent.Parent.transport.Client)
-        end
-        return _client
-    end
-
-    -- Listen for incoming responses and resolve pending requests
-    respReg.signal:connect(function(value: any, sender: Player?, corrId: number)
-        local waiting = _pending[corrId]
-        if waiting then
+    respReg.signal:connect(function(value: any, _sender: Player?, corrId: number)
+        local single = _pending[corrId]
+        if single then
             _pending[corrId] = nil
-            task.spawn(waiting, value)
+            task.spawn(single, value)
+            return
+        end
+        local gather = _pendingGather[corrId]
+        if gather then
+            _pendingGather[corrId] = nil
+            gather(value)
         end
     end)
 
-    -- Listen for incoming requests and auto-respond
-    local _handler: ((any, Player?) -> any)? = nil
-
     reqReg.signal:connect(function(value: any, sender: Player?, corrId: number)
-        if not _handler then
+        local handler = activeHandler
+        if not handler then
             return
         end
 
-        -- Run handler, get response
-        local ok, response = pcall(_handler :: any, value, sender)
-
-        if IS_SERVER then
-            if sender then
-                local Server = getServer()
-                local ch = Server.getChannel(sender, false)
-                if ok then
-                    Channel.writeQuery(ch, respReg.id, corrId, responseCodec, response)
-                else
-                    Channel.writeQuery(ch, respReg.id, corrId, nil, nil)
-                end
-            end
-        else
-            local Client = getClient()
-            local ch = Client.getChannel(false)
-            if ok then
-                Channel.writeQuery(ch, respReg.id, corrId, responseCodec, response)
-            else
-                Channel.writeQuery(ch, respReg.id, corrId, nil, nil)
-            end
+        local ok, response = pcall(handler, value, sender)
+        local payloadCodec = if ok then responseCodec else nil
+        local payloadData = if ok then response else nil
+
+        local ch = if IS_SERVER and sender
+            then Transport.server().getChannel(sender, false)
+            elseif not IS_SERVER then Transport.client().getChannel(false)
+            else nil
+        if ch then
+            Channel.writeQuery(ch, respReg.id, corrId, payloadCodec, payloadData)
         end
     end)
 
-    local handle: any = {}
-
-    function handle.handle(
-        _self: QueryHandle,
-        fn: (request: any, player: Player?) -> any
-    ): Types.Connection
-        _handler = fn
-
-        -- Return a connection that clears the handler on disconnect
-        return table.freeze({
-            connected = true,
-            disconnect = function(self: Types.Connection): ()
-                if not (self :: any).connected then
-                    return
-                end
-                (self :: any).connected = false
-                _handler = nil
-            end,
-        } :: any)
-    end
-
-    function handle.request(_self: QueryHandle, data: any, target: any?): any
-        _nextCorrId += 1
-        local corrId = _nextCorrId
-
-        if IS_SERVER then
-            if target == nil then
-                error(`[Lync] Query "{name}": server request requires a target`)
+    local function scheduleSingleTimeout(corrId: number, running: thread): ()
+        task.delay(timeout, function()
+            if _pending[corrId] == running then
+                _pending[corrId] = nil
+                task.spawn(running, nil)
             end
+        end)
+    end
 
-            local Server = getServer()
+    local function requestSingle(target: Player, data: any): any
+        local corrId = nextCorr()
+        local ch = Transport.server().getChannel(target, false)
+        Channel.writeQuery(ch, reqReg.id, corrId, requestCodec, data)
 
-            -- Single player
-            if typeof(target) == "Instance" and target:IsA("Player") then
-                local ch = Server.getChannel(target :: Player, false)
-                Channel.writeQuery(ch, reqReg.id, corrId, requestCodec, data)
+        local running = coroutine.running()
+        _pending[corrId] = running
+        scheduleSingleTimeout(corrId, running)
+        return coroutine.yield()
+    end
 
-                -- Wait for response
-                local running = coroutine.running()
-                _pending[corrId] = running
+    local function requestMulti(targets: { Player }, data: any): { [Player]: any }
+        if #targets == 0 then
+            return {}
+        end
 
-                task.delay(timeout, function()
-                    if _pending[corrId] == running then
-                        _pending[corrId] = nil
-                        task.spawn(running, nil)
-                    end
-                end)
+        local results: { [Player]: any } = {}
+        local remaining = #targets
+        local running = coroutine.running()
+        local resolved = false
 
-                return coroutine.yield()
+        local function resolveOnce(): ()
+            if resolved then
+                return
             end
+            resolved = true
+            task.spawn(running, results)
+        end
 
-            -- Multi-target: collect responses into { [Player]: response? }
-            local targets: { Player } = {}
-
-            if typeof(target) == "table" then
-                local tbl = target :: any
-                if tbl._lyncAll then
-                    targets = Players:GetPlayers()
-                elseif tbl._lyncGroup then
-                    for player in tbl._members do
-                        table.insert(targets, player)
-                    end
-                else
-                    for _, p in tbl do
-                        if typeof(p) == "Instance" and (p :: Instance):IsA("Player") then
-                            table.insert(targets, p :: Player)
-                        end
-                    end
+        local Server = Transport.server()
+        for _, player in targets do
+            local pCorr = nextCorr()
+            local ch = Server.getChannel(player, false)
+            Channel.writeQuery(ch, reqReg.id, pCorr, requestCodec, data)
+
+            local pRef = player
+            _pendingGather[pCorr] = function(response: any)
+                results[pRef] = response
+                remaining -= 1
+                if remaining == 0 then
+                    resolveOnce()
                 end
             end
+        end
 
-            if #targets == 0 then
-                return {}
-            end
-
-            local results: { [Player]: any } = {}
-            local remaining = #targets
-            local running = coroutine.running()
-
-            for _, player in targets do
-                _nextCorrId += 1
-                local playerCorrId = _nextCorrId
-                local ch = Server.getChannel(player, false)
-                Channel.writeQuery(ch, reqReg.id, playerCorrId, requestCodec, data)
-
-                local playerRef = player
-                _pending[playerCorrId] = coroutine.create(function(response: any)
-                    results[playerRef] = response
-                    remaining -= 1
-                    if remaining == 0 then
-                        task.spawn(running, results)
-                    end
-                end)
-            end
+        task.delay(timeout, resolveOnce)
+        return coroutine.yield()
+    end
 
-            -- Timeout
-            task.delay(timeout, function()
-                if remaining > 0 then
-                    remaining = 0
-                    task.spawn(running, results)
-                end
-            end)
+    local function collectTargets(target: any): { Player }
+        local targets: { Player } = {}
+        if typeof(target) ~= "table" then
+            return targets
+        end
 
-            return coroutine.yield()
+        if target._lyncAll then
+            for _, p in Players:GetPlayers() do
+                table.insert(targets, p)
+            end
+        elseif target._lyncGroup then
+            for player in target._members do
+                table.insert(targets, player)
+            end
         else
-            -- Client → server
-            local Client = getClient()
-            local ch = Client.getChannel(false)
-            Channel.writeQuery(ch, reqReg.id, corrId, requestCodec, data)
-
-            local running = coroutine.running()
-            _pending[corrId] = running
-
-            task.delay(timeout, function()
-                if _pending[corrId] == running then
-                    _pending[corrId] = nil
-                    task.spawn(running, nil)
+            for _, p in target do
+                if isPlayer(p) then
+                    table.insert(targets, p :: Player)
                 end
-            end)
-
-            return coroutine.yield()
+            end
         end
+        return targets
     end
 
-    function handle.name(_self: QueryHandle): string
-        return name
+    local function requestFromServer(data: any, target: any): any
+        if target == nil then
+            error(`[Lync] Query.request: "{name}" server request requires a target`)
+        end
+        if isPlayer(target) then
+            return requestSingle(target :: Player, data)
+        end
+        return requestMulti(collectTargets(target), data)
     end
 
-    function handle.stats(_self: QueryHandle): Types.PacketStats
-        return {
-            bytesSent = reqReg.bytesSent + respReg.bytesSent,
-            bytesReceived = reqReg.bytesReceived + respReg.bytesReceived,
-            fires = reqReg.fires + respReg.fires,
-            recvFires = reqReg.recvFires + respReg.recvFires,
-            drops = reqReg.drops + respReg.drops,
-        }
+    local function requestFromClient(data: any): any
+        local corrId = nextCorr()
+        local ch = Transport.client().getChannel(false)
+        Channel.writeQuery(ch, reqReg.id, corrId, requestCodec, data)
+
+        local running = coroutine.running()
+        _pending[corrId] = running
+        scheduleSingleTimeout(corrId, running)
+        return coroutine.yield()
     end
 
-    return table.freeze(handle)
+    type Self = QueryHandle<Req, Resp>
+
+    local handle = {
+        handle = function(
+            _self: Self,
+            fn: (request: Req, player: Player?) -> Resp?
+        ): Types.Connection
+            handlerToken += 1
+            local myToken = handlerToken
+            activeHandler = fn :: any
+
+            local conn = { connected = true }
+            function conn.disconnect(self): ()
+                if not self.connected then
+                    return
+                end
+                self.connected = false
+                if handlerToken == myToken then
+                    activeHandler = nil
+                end
+            end
+            return conn :: Types.Connection
+        end,
+
+        request = function(_self: Self, data: Req, target: any?): Resp?
+            if IS_SERVER then
+                return requestFromServer(data, target)
+            end
+            return requestFromClient(data)
+        end,
+
+        name = function(_self: Self): string
+            return name
+        end,
+
+        stats = function(_self: Self): Types.PacketStats
+            return {
+                bytesSent = reqReg.bytesSent + respReg.bytesSent,
+                bytesReceived = reqReg.bytesReceived + respReg.bytesReceived,
+                fires = reqReg.fires + respReg.fires,
+                recvFires = reqReg.recvFires + respReg.recvFires,
+                drops = reqReg.drops + respReg.drops,
+            }
+        end,
+    }
+
+    return table.freeze(handle) :: QueryHandle<Req, Resp>
 end
 
 function Query.pendingCount(): number
@@ -281,6 +291,9 @@ function Query.pendingCount(): number
     for _ in _pending do
         count += 1
     end
+    for _ in _pendingGather do
+        count += 1
+    end
     return count
 end
 

package/src/api/Scope.luau

@@ -1,76 +1,74 @@
 --!strict
 --!optimize 2
--- Batched connection lifecycle management.
+-- Batched connection lifecycle. Accepts Lync Connection,
+-- RBXScriptConnection, and any object with :disconnect() / :Disconnect().
 
 local Types = require(script.Parent.Parent.Types)
 
--- Public --------------------------------------------------------------
-
-local Scope = {}
+-- Public types -----------------------------------------------------------
 
 export type ScopeHandle = {
     on: (self: ScopeHandle, source: any, fn: (...any) -> ()) -> Types.Connection,
     once: (self: ScopeHandle, source: any, fn: (...any) -> ()) -> Types.Connection,
     add: (self: ScopeHandle, connection: any) -> (),
+    size: (self: ScopeHandle) -> number,
     destroy: (self: ScopeHandle) -> (),
 }
 
+type Scope = ScopeHandle & { _connections: { any }, _count: number }
+
+-- Private ----------------------------------------------------------------
+
+local function pushConnection(self: Scope, conn: any): ()
+    local idx = self._count + 1
+    self._count = idx
+    self._connections[idx] = conn
+end
+
+-- Public -----------------------------------------------------------------
+
 local ScopeMeta = {}
 ScopeMeta.__index = ScopeMeta
 
-function ScopeMeta.on(self: any, source: any, fn: (...any) -> ()): Types.Connection
+function ScopeMeta.on(self: Scope, source: any, fn: (...any) -> ()): Types.Connection
     local conn = source:on(fn)
-    local conns = self._connections
-    local idx = self._count + 1
-    self._count = idx
-    conns[idx] = conn
+    pushConnection(self, conn)
     return conn
 end
 
-function ScopeMeta.once(self: any, source: any, fn: (...any) -> ()): Types.Connection
+function ScopeMeta.once(self: Scope, source: any, fn: (...any) -> ()): Types.Connection
     local conn = source:once(fn)
-    local conns = self._connections
-    local idx = self._count + 1
-    self._count = idx
-    conns[idx] = conn
+    pushConnection(self, conn)
     return conn
 end
 
-function ScopeMeta.add(self: any, connection: any): ()
-    local idx = self._count + 1
-    self._count = idx
-    self._connections[idx] = connection
+ScopeMeta.add = pushConnection
+
+function ScopeMeta.size(self: Scope): number
+    return self._count
 end
 
-function ScopeMeta.destroy(self: any): ()
+function ScopeMeta.destroy(self: Scope): ()
     local conns = self._connections
     local count = self._count
-
     for i = 1, count do
         local conn = conns[i]
-        conns[i] = nil :: any
-
-        --[[
-            Support both Lync Connection (conn:disconnect())
-            and RBXScriptConnection (conn:Disconnect()).
-        ]]
-        if typeof(conn) == "table" then
-            if conn.disconnect then
-                conn:disconnect()
-            end
-        elseif typeof(conn) == "RBXScriptConnection" then
+        conns[i] = nil
+        if typeof(conn) == "RBXScriptConnection" then
             (conn :: RBXScriptConnection):Disconnect()
+        elseif typeof(conn) == "table" and conn.disconnect then
+            conn:disconnect()
         end
     end
-
     self._count = 0
 end
 
-function Scope.create(): ScopeHandle
-    return setmetatable({
-        _connections = {},
-        _count = 0,
-    }, ScopeMeta) :: any
+table.freeze(ScopeMeta)
+
+local ScopeModule = {}
+
+function ScopeModule.create(): ScopeHandle
+    return (setmetatable({ _connections = {}, _count = 0 }, ScopeMeta) :: any) :: ScopeHandle
 end
 
-return table.freeze(Scope)
+return table.freeze(ScopeModule)