atom.io 0.46.12 → 0.46.14

package/src/realtime/employ-socket.ts

@@ -1,24 +1,21 @@
-import type { EventsMap, Socket, TypedSocket } from "atom.io/realtime"
-import type { Events } from "atom.io/realtime-server"
+import type { Json } from "atom.io/json"
+import type { EventsMap, GuardedSocket, Socket } from "atom.io/realtime"
 
 export function employSocket<I extends EventsMap, K extends string & keyof I>(
-	socket: TypedSocket<I, any>,
+	socket: GuardedSocket<I>,
 	event: K,
 	handleEvent: (...data: Parameters<I[K]>) => void,
 ): () => void
-export function employSocket<I extends Events, K extends string & keyof I>(
+export function employSocket(
 	socket: Socket,
-	event: K,
-	handleEvent: (...data: I[K]) => void,
+	event: string,
+	handleEvent: (...data: Json.Serializable[]) => void,
 ): () => void
-export function employSocket<I extends Events, K extends string & keyof I>(
-	socket: Socket | TypedSocket<any, any>,
-	event: K,
-	handleEvent: (...data: I[K]) => void,
+export function employSocket(
+	socket: GuardedSocket<any> | Socket,
+	event: string,
+	handleEvent: (...data: Json.Serializable[]) => void,
 ): () => void {
 	socket.on(event, handleEvent)
-	const retireSocket = () => {
-		socket.off(event, handleEvent)
-	}
-	return retireSocket
+	return socket.off.bind(socket, event, handleEvent)
 }

package/src/realtime/{cast-socket.ts → guard-socket.ts}

@@ -1,14 +1,14 @@
 import type { Loadable } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import type { EventsMap, Socket, TypedSocket } from "./socket-interface"
+import type { EventsMap, GuardedSocket, Socket } from "./socket-interface"
 import type { StandardSchemaV1 } from "./standard-schema"
 
-export type SocketListeners<T extends TypedSocket> =
-	T extends TypedSocket<infer ListenEvents> ? ListenEvents : never
-
-export type SocketGuard<L extends EventsMap> = {
-	[K in keyof L]: StandardSchemaV1<Json.Array, Parameters<L[K]>>
+export type SocketGuard<ListenEvents extends EventsMap> = {
+	[K in keyof ListenEvents]: StandardSchemaV1<
+		Json.Array,
+		Parameters<ListenEvents[K]>
+	>
 }
 
 export type Loaded<L extends Loadable<any>> =
@@ -25,13 +25,13 @@ function onLoad<L extends Loadable<any>>(
 	}
 }
 
-export function castSocket<T extends TypedSocket>(
+export function guardSocket<ListenEvents extends EventsMap>(
 	socket: Socket,
-	guard: SocketGuard<SocketListeners<T>> | `TRUST`,
+	guard: SocketGuard<ListenEvents> | `TRUST`,
 	logError?: (error: unknown) => void,
-): T {
+): GuardedSocket<ListenEvents> {
 	if (guard === `TRUST`) {
-		return socket as T
+		return socket as GuardedSocket<ListenEvents>
 	}
 	const guardedSocket: Socket = {
 		id: socket.id,
@@ -66,5 +66,5 @@ export function castSocket<T extends TypedSocket>(
 		offAny: socket.offAny.bind(socket),
 		emit: socket.emit.bind(socket),
 	}
-	return guardedSocket as T
+	return guardedSocket as GuardedSocket<ListenEvents>
 }

package/src/realtime/index.ts

@@ -1,5 +1,5 @@
-export * from "./cast-socket"
 export * from "./employ-socket"
+export * from "./guard-socket"
 export * from "./mutex-store"
 export * from "./realtime-continuity"
 export * from "./realtime-key-types"

package/src/realtime/shared-room-store.ts

@@ -87,7 +87,7 @@ export const mutualUsersSelector: ReadonlyPureSelectorFamilyToken<
 				const users = get(usersOfRoomsAtoms, room)
 				return [...users]
 			}
-			return []
+			return [userKey]
 		},
 })
 

package/src/realtime/socket-interface.ts

@@ -26,17 +26,30 @@ export type EventEmitter<EmitEvents extends EventsMap = EventsMap> = <
 	...args: Parameters<EmitEvents[E]>
 ) => void
 
-export type TypedSocket<
-	ListenEvents extends EventsMap = EventsMap,
-	EmitEvents extends EventsMap = never,
-> = {
+export interface GuardedSocket<ListenEvents extends EventsMap> extends Socket {
 	id: string | undefined
-	on: ParticularEventListener<ListenEvents>
-	onAny: (listener: AllEventsListener<ListenEvents>) => void
-	onAnyOutgoing: (listener: AllEventsListener<EmitEvents>) => void
-	off: ParticularEventListener<ListenEvents>
-	offAny: (listener: AllEventsListener<ListenEvents>) => void
-	emit: EventEmitter<EmitEvents>
+	on: <E extends string & keyof ListenEvents>(
+		event: E,
+		listener: ListenEvents[E],
+	) => void
+	onAny: (
+		listener: <E extends string & keyof ListenEvents>(
+			event: E,
+			...args: Parameters<ListenEvents[E]>
+		) => void,
+	) => void
+	onAnyOutgoing: (listener: AllEventsListener<EventsMap>) => void
+	off: <E extends string & keyof ListenEvents>(
+		event: E,
+		listener?: ListenEvents[E],
+	) => void
+	offAny: (
+		listener?: <E extends string & keyof ListenEvents>(
+			event: E,
+			...args: Parameters<ListenEvents[E]>
+		) => void,
+	) => void
+	emit: EventEmitter<EventsMap>
 }
 
 export type Socket = {

package/src/realtime-server/provide-rooms.ts

@@ -15,16 +15,16 @@ import type { Json } from "atom.io/json"
 import type {
 	AllEventsListener,
 	EventsMap,
+	GuardedSocket,
 	RoomKey,
 	RoomSocketInterface,
 	Socket,
 	SocketGuard,
 	StandardSchemaV1,
-	TypedSocket,
 	UserKey,
 } from "atom.io/realtime"
 import {
-	castSocket,
+	guardSocket,
 	isRoomKey,
 	ownersOfRooms,
 	roomKeysAtom,
@@ -129,7 +129,7 @@ export function spawnRoom<RoomNames extends string>({
 export type ProvideEnterAndExitConfig = {
 	store: RootStore
 	socket: Socket
-	roomSocket: TypedSocket<RoomSocketInterface<any>, any>
+	roomSocket: GuardedSocket<RoomSocketInterface<string>>
 	userKey: UserKey
 }
 export function provideEnterAndExit({
@@ -283,9 +283,10 @@ export function provideRooms<RoomNames extends string>({
 	roomNames,
 	userKey,
 }: ProvideRoomsConfig<RoomNames>): () => void {
-	const roomSocket = castSocket<
-		TypedSocket<RoomSocketInterface<RoomNames>, never>
-	>(socket, createRoomSocketGuard(roomNames))
+	const roomSocket = guardSocket<RoomSocketInterface<RoomNames>>(
+		socket,
+		createRoomSocketGuard(roomNames),
+	)
 	const exposeMutable = realtimeMutableProvider({
 		socket,
 		store,

package/src/realtime-server/server-config.ts

@@ -72,6 +72,13 @@ export function realtime(
 		.use(async (socket, next) => {
 			const result = await auth(socket.handshake)
 			if (result instanceof Error) {
+				store.logger.error(
+					`📡`,
+					`socket`,
+					socket.id,
+					`failed to authenticate`,
+					result.message,
+				)
 				next(result)
 				return
 			}