@flamework-experimental/networking 2.0.0-alpha.0

package/out/init.luau

@@ -0,0 +1,78 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local NetworkingSkip = TS.import(script, script, "middleware", "skip").Skip
+local NetworkingFunctionError = TS.import(script, script, "function", "errors").NetworkingFunctionError
+local createNetworkingEvent = TS.import(script, script, "events", "createNetworkingEvent").createNetworkingEvent
+local createNetworkingFunction = TS.import(script, script, "functions", "createNetworkingFunction").createNetworkingFunction
+local Networking = {}
+do
+	local _container = Networking
+	--[[
+		*
+		     * Creates a new event based off the supplied types.
+		     * @param serverMiddleware Middleware for server events
+		     * @param clientMiddleware Middleware for client events
+		     * @metadata macro
+		     
+	]]
+	local function createEvent(name)
+		return createNetworkingEvent(name)
+	end
+	_container.createEvent = createEvent
+	--[[
+		*
+		     * Creates a new function event based off the supplied types.
+		     * @param serverMiddleware Middleware for server events
+		     * @param clientMiddleware Middleware for client events
+		     * @metadata macro
+		     
+	]]
+	local function createFunction(name)
+		return createNetworkingFunction(name)
+	end
+	_container.createFunction = createFunction
+	--[[
+		*
+		     * Stops networking function middleware.
+		     
+	]]
+	local Skip = NetworkingSkip
+	_container.Skip = Skip
+	--[[
+		*
+		     * Specifies that this event is unreliable.
+		     *
+		     * This will only work on remote events.
+		     
+	]]
+	--[[
+		*
+		     * Sends this event's arguments as they are, bypassing `networking.serialization` for this event
+		     * alone. The generated guards still run on what arrives.
+		     
+	]]
+	--[[
+		*
+		     * An unreliable event whose arguments bypass serialization; see {@link RawReliable}.
+		     
+	]]
+	--[[
+		*
+		     * A function whose requests and results bypass serialization; see {@link RawReliable}.
+		     
+	]]
+	--[[
+		*
+		     * A function that generates an event middleware.
+		     
+	]]
+	--[[
+		*
+		     * A function that generates an event middleware.
+		     
+	]]
+end
+return {
+	Networking = Networking,
+	NetworkingFunctionError = NetworkingFunctionError,
+}

package/out/middleware/createGuardMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { t } from "@rbxts/t";
+import { MiddlewareFactory } from "./types";
+import { SignalContainer } from "../util/createSignalContainer";
+import { EventNetworkingEvents } from "../handlers";
+import { NetworkInfo } from "../types";
+export declare function createGuardMiddleware<I extends unknown[], O>(name: string, fixedParameters: t.check<unknown>[], restParameter: t.check<unknown> | undefined, networkInfo: NetworkInfo, warnOnInvalid: boolean, signals: SignalContainer<EventNetworkingEvents>, failureValue?: O): MiddlewareFactory<I, O>;

package/out/middleware/createGuardMiddleware.luau

@@ -0,0 +1,44 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Players
+local function createGuardMiddleware(name, fixedParameters, restParameter, networkInfo, warnOnInvalid, signals, failureValue)
+	return function(processNext)
+		return function(player, ...)
+			local args = { ... }
+			do
+				local i = 0
+				local _shouldIncrement = false
+				while true do
+					if _shouldIncrement then
+						i += 1
+					else
+						_shouldIncrement = true
+					end
+					if not (i < math.max(#fixedParameters, #args)) then
+						break
+					end
+					local guard = fixedParameters[i + 1] or restParameter
+					if guard and not guard(args[i + 1]) then
+						if warnOnInvalid then
+							if player then
+								warn(`'{player}' sent invalid arguments for event '{name}' (arg #{i}):`, args[i + 1])
+							else
+								warn(`Server sent invalid arguments for event '{name}' (arg #{i}):`, args[i + 1])
+							end
+						end
+						signals:fire("onBadRequest", player or Players.LocalPlayer, {
+							networkInfo = networkInfo,
+							argIndex = i,
+							argValue = args[i + 1],
+						})
+						return failureValue
+					end
+				end
+			end
+			return processNext(player, unpack(args))
+		end
+	end
+end
+return {
+	createGuardMiddleware = createGuardMiddleware,
+}

package/out/middleware/createMiddlewareProcessor.d.ts

@@ -0,0 +1,3 @@
+import { NetworkInfo } from "../types";
+import { Middleware, MiddlewareFactory, MiddlewareProcessor } from "./types";
+export declare function createMiddlewareProcessor<I extends readonly unknown[], O>(middlewareFactories: MiddlewareFactory<I, O>[] | undefined, networkInfo: NetworkInfo, finalize: Middleware<I, O>): MiddlewareProcessor<I, O>;

package/out/middleware/createMiddlewareProcessor.luau

@@ -0,0 +1,24 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local function createMiddlewareProcessor(middlewareFactories, networkInfo, finalize)
+	local middleware = {}
+	if not middlewareFactories or #middlewareFactories == 0 then
+		middleware[1] = finalize
+	else
+		for i = #middlewareFactories - 1, 0, -1 do
+			local factory = middlewareFactories[i + 1]
+			local processNext = middleware[i + 2] or finalize
+			middleware[i + 1] = factory(TS.async(function(player, ...)
+				local args = { ... }
+				return processNext(player, unpack(args))
+			end), networkInfo)
+		end
+	end
+	return TS.async(function(player, ...)
+		local args = { ... }
+		return middleware[1](player, unpack(args))
+	end)
+end
+return {
+	createMiddlewareProcessor = createMiddlewareProcessor,
+}

package/out/middleware/skip.d.ts

@@ -0,0 +1,8 @@
+export type Skip = {
+    _nominal_Skip: never;
+};
+export declare const Skip: Skip;
+export type SkipBadRequest = Skip & {
+    _nominal_SkipBadRequest: never;
+};
+export declare const SkipBadRequest: SkipBadRequest;

package/out/middleware/skip.luau

@@ -0,0 +1,22 @@
+-- Compiled with roblox-ts v3.0.0
+local Skip = {
+	__index = function()
+		return nil
+	end,
+	__newindex = function()
+		return nil
+	end,
+	__tostring = function()
+		return `Networking.Skip`
+	end,
+}
+setmetatable(Skip, Skip)
+-- This is a special skip type used to instruct Flamework to reject with a value of "BadRequest"
+-- This does affect equality, though, so it can only be returned from the very first middleware
+-- to avoid other middleware from being able to inspect it.
+local SkipBadRequest = {}
+setmetatable(SkipBadRequest, Skip)
+return {
+	Skip = Skip,
+	SkipBadRequest = SkipBadRequest,
+}

package/out/middleware/types.d.ts

@@ -0,0 +1,15 @@
+import { NetworkInfo } from "../types";
+import { Skip } from "./skip";
+
+export type MiddlewareProcessor<I extends readonly unknown[], O> = (player?: Player, ...args: I) => Promise<O>;
+export type Middleware<I extends readonly unknown[] = unknown[], O = void> = (
+	player?: Player,
+	...args: I
+) => O | Promise<O>;
+export type MiddlewareFactory<I extends readonly unknown[] = [], O = void> = (
+	processNext: MiddlewareProcessor<I, O>,
+	event: NetworkInfo,
+) => Middleware<I, O>;
+
+export type EventMiddleware<I extends readonly unknown[] = unknown[]> = MiddlewareFactory<I, void>;
+export type FunctionMiddleware<I extends readonly unknown[] = unknown[], O = void> = MiddlewareFactory<I, O | Skip>;

package/out/types.d.ts

@@ -0,0 +1,78 @@
+import { Modding, Serialization } from "@flamework-experimental/core";
+import { t } from "@rbxts/t";
+
+export interface NetworkInfo {
+	/**
+	 * The name provided for this event.
+	 */
+	name: string;
+
+	/**
+	 * The (generated) global name used for distinguishing different createEvent calls.
+	 */
+	globalName: string;
+
+	/**
+	 * Whether this remote is an event or function.
+	 */
+	eventType: "Event" | "Function";
+}
+
+export type NetworkUnreliable<T> = T & { _flamework_unreliable: never };
+
+/**
+ * Marks an event or function whose values travel as they are, outside serialization: the transformer
+ * leaves its call sites alone and the metadata carries no decoder for it.
+ */
+export type NetworkRaw<T> = T & { _flamework_raw: never };
+
+export interface NetworkingObfuscationMarker {
+	/**
+	 * An internal marker type used to signify to Flamework to obfuscate access expressions.
+	 * @hidden
+	 * @deprecated
+	 */
+	readonly _flamework_key_obfuscation: "remotes";
+}
+
+export type FunctionParameters<T> = T extends (...args: infer P) => unknown ? P : never;
+export type FunctionReturn<T> = T extends (...args: never[]) => infer R ? R : never;
+
+export type ObfuscateNames<T> = IntrinsicObfuscateArray<
+	(T extends T ? Modding.Target.Obfuscate<T & string, "remotes"> : never)[],
+	string[]
+>;
+
+/** @hidden Intrinsic feature not intended for users */
+export type IntrinsicObfuscate<T> = Modding.Intrinsic<"obfuscate-obj", [T, "remotes"], Record<string, T[keyof T]>>;
+
+/** @hidden Intrinsic feature not intended for users */
+export type IntrinsicObfuscateArray<T, V = T> = Modding.Intrinsic<"shuffle-array", [T], V>;
+
+/** @hidden Intrinsic feature not intended for users */
+export type IntrinsicTupleGuards<T> = Modding.Intrinsic<"tuple-guards", [T], GuardType>;
+
+/**
+ * Decode code for the argument list `T`, generated only when the project's flamework.config.json
+ * enables `networking.serialization`; `undefined` otherwise, which passes values through as they
+ * are. The matching encoding is generated inline at every call site, so no encoder exists at runtime.
+ * @hidden Intrinsic feature not intended for users
+ */
+export type IntrinsicNetworkDecoder<T extends Array<unknown>> = Modding.Intrinsic<
+	"network-decoder",
+	[T],
+	Serialization.Decoder<T> | undefined
+>;
+
+/**
+ * Decode code for the result of the function type `F`, carried as a one-element list. Takes the
+ * function type rather than its return type so that the return type as declared is known.
+ * @hidden Intrinsic feature not intended for users
+ */
+export type IntrinsicNetworkResultDecoder<F> = Modding.Intrinsic<
+	"network-result-decoder",
+	[F],
+	Serialization.Decoder | undefined
+>;
+
+type GuardType = [t.check<unknown>[], t.check<unknown> | undefined];

package/out/util/createSignalContainer.d.ts

@@ -0,0 +1,5 @@
+export interface SignalContainer<T> {
+    fire<K extends keyof T>(name: K, ...args: Parameters<T[K]>): void;
+    connect<K extends keyof T>(name: K, callback: T[K]): RBXScriptConnection;
+}
+export declare function createSignalContainer<T>(): SignalContainer<T>;

package/out/util/createSignalContainer.luau

@@ -0,0 +1,30 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Signal = TS.import(script, TS.getModule(script, "@rbxts", "signal"))
+local function createSignalContainer()
+	local signals = {}
+	return {
+		fire = function(self, name, ...)
+			local args = { ... }
+			local _name = name
+			local signal = signals[_name]
+			if signal then
+				signal:Fire(unpack(args))
+			end
+		end,
+		connect = function(self, name, callback)
+			local _name = name
+			local signal = signals[_name]
+			if not signal then
+				local _exp = name
+				signal = Signal.new()
+				local _signal = signal
+				signals[_exp] = _signal
+			end
+			return signal:Connect(callback)
+		end,
+	}
+end
+return {
+	createSignalContainer = createSignalContainer,
+}

package/out/util/getNamespaceConfig.d.ts

@@ -0,0 +1,10 @@
+import { EventCreateConfiguration } from "../events/types";
+import { FunctionCreateConfiguration } from "../functions/types";
+type ConfigType = EventCreateConfiguration<unknown> | FunctionCreateConfiguration<unknown>;
+/**
+ * Creates a new config with the namespace's middleware at the top level.
+ */
+export declare function getNamespaceConfig<T extends ConfigType>(config: T, namespaceId: string): T & {
+    middleware: never;
+};
+export {};

package/out/util/getNamespaceConfig.luau

@@ -0,0 +1,15 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * Creates a new config with the namespace's middleware at the top level.
+	 
+]]
+local function getNamespaceConfig(config, namespaceId)
+	local _object = table.clone(config)
+	setmetatable(_object, nil)
+	_object.middleware = config.middleware[namespaceId] or {}
+	return _object
+end
+return {
+	getNamespaceConfig = getNamespaceConfig,
+}

package/out/util/timeoutPromise.d.ts

@@ -0,0 +1 @@
+export declare function timeoutPromise(timeout: number, rejectValue: unknown): Promise<unknown>;

package/out/util/timeoutPromise.luau

@@ -0,0 +1,10 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local function timeoutPromise(timeout, rejectValue)
+	return TS.Promise.delay(timeout):andThen(function()
+		return TS.Promise.reject(rejectValue)
+	end)
+end
+return {
+	timeoutPromise = timeoutPromise,
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@flamework-experimental/networking",
+  "version": "2.0.0-alpha.0",
+  "main": "out/init.luau",
+  "types": "out/index.d.ts",
+  "scripts": {
+    "build": "rbxtsc",
+    "watch": "rbxtsc -w"
+  },
+  "files": [
+    "out",
+    "flamework.build"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@flamework-experimental/core": "*"
+  },
+  "devDependencies": {
+    "@flamework-experimental/core": "2.0.0-alpha.0",
+    "@rbxts/compiler-types": "^3.0.0-types.0",
+    "@rbxts/types": "^1.0.948",
+    "roblox-ts": "^3.0.0"
+  },
+  "dependencies": {
+    "@rbxts/object-utils": "^1.0.4",
+    "@rbxts/services": "^1.1.5",
+    "@rbxts/signal": "^1.0.3",
+    "@rbxts/t": "^3.1.0"
+  }
+}