@tldraw/sync-core 5.2.0-canary.6421dbe4e25a → 5.2.0-canary.667cbd6bb6ff

package/src/lib/TLSyncRoom.ts

@@ -838,6 +838,28 @@ export class TLSyncRoom<R extends UnknownRecord, SessionMeta> {
 		this.broadcastPatch(diff)
 	}
 
+	/**
+	 * Work out whether a client we can't reconcile schemas with is running a newer or older SDK
+	 * than us.
+	 */
+	private getVersionMismatchReason(theirSchema: SerializedSchema) {
+		const ourSchema = this.serializedSchema
+
+		if (theirSchema.schemaVersion > ourSchema.schemaVersion) {
+			return TLSyncErrorCloseEventReason.SERVER_TOO_OLD
+		}
+
+		if (theirSchema.schemaVersion === 2 && ourSchema.schemaVersion === 2) {
+			for (const [sequenceId, theirVersion] of Object.entries(theirSchema.sequences)) {
+				const ourVersion = ourSchema.sequences[sequenceId]
+				if (ourVersion === undefined || theirVersion > ourVersion) {
+					return TLSyncErrorCloseEventReason.SERVER_TOO_OLD
+				}
+			}
+		}
+		return TLSyncErrorCloseEventReason.CLIENT_TOO_OLD
+	}
+
 	private handleConnectRequest(
 		session: RoomSession<R, SessionMeta>,
 		message: Extract<TLSocketClientSentEvent<R>, { type: 'connect' }>
@@ -874,8 +896,13 @@ export class TLSyncRoom<R extends UnknownRecord, SessionMeta> {
 			return
 		}
 		const migrations = this.schema.getMigrationsSince(message.schema)
-		// if the client's store is at a different version to ours, we can't support them
-		if (!migrations.ok || migrations.value.some((m) => m.scope !== 'record' || !m.down)) {
+		if (!migrations.ok) {
+			this.rejectSession(session.sessionId, this.getVersionMismatchReason(message.schema))
+			return
+		}
+		// The client's schema is older than ours, but we can't migrate our data down to their
+		// version (a migration isn't record-scoped or has no down migration), so they're too old.
+		if (migrations.value.some((m) => m.scope !== 'record' || !m.down)) {
 			this.rejectSession(session.sessionId, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
 			return
 		}

package/src/test/TLSyncRoom.test.ts

@@ -845,6 +845,48 @@ describe('23. Connect handshake (HS)', () => {
 		)
 	})
 
+	it('rejects a client running a newer schema with SERVER_TOO_OLD, not CLIENT_TOO_OLD', () => {
+		// Regression test for #6169
+		// A client running a newer SDK than the server: its schema has a sequence version higher
+		// than anything this server knows about. The server can't reconcile it, but the server is
+		// the one that's behind, so it should report SERVER_TOO_OLD (not CLIENT_TOO_OLD).
+		const serializedSchema = schema.serialize()
+		const newerSerializedSchema: SerializedSchemaV2 = {
+			schemaVersion: 2,
+			sequences: {
+				...serializedSchema.sequences,
+				'com.tldraw.shape.arrow': 999,
+			},
+		}
+
+		const { room } = makeRoom()
+		const socket = makeSocket()
+
+		room.handleNewSession({
+			sessionId: 'newer-client-session',
+			socket,
+			meta: undefined,
+			isReadonly: false,
+		})
+
+		room.handleMessage('newer-client-session', {
+			connectRequestId: 'connect-1',
+			lastServerClock: 0,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: newerSerializedSchema,
+			type: 'connect',
+		})
+
+		// Session should not be connected - it was rejected due to incompatible schema
+		expect(room.sessions.get('newer-client-session')?.state).not.toBe(RoomSessionState.Connected)
+
+		// Socket should be closed with SERVER_TOO_OLD, since the client is on a newer version
+		expect(socket.close).toHaveBeenCalledWith(
+			TLSyncErrorCloseEventCode,
+			TLSyncErrorCloseEventReason.SERVER_TOO_OLD
+		)
+	})
+
 	it('[HS4] handles a client with lastServerClock greater than the current documentClock', () => {
 		const { room } = makeRoom({ snapshot: makeSnapshot(records, { documentClock: 10 }) })
 

package/src/test/upgradeDowngrade.test.ts

@@ -482,9 +482,9 @@ it('[HS3] when the client is too new it cannot connect', () => {
 
 	expect(v2_socket.close).toHaveBeenCalledWith(
 		4099,
-		// this should really be 'serverTooOld' but our schema format is a bit too loose to
-		// accurately determine that now.
-		TLSyncErrorCloseEventReason.CLIENT_TOO_OLD
+		// the client is on a newer schema than the server, so from its perspective the server is
+		// the one that's too old.
+		TLSyncErrorCloseEventReason.SERVER_TOO_OLD
 	)
 })