trigger-happy | Cross browser event | Functional Testing library

This means that we have to handle the requests coming in is a sequential way, to be able to ensure that users are added and removed to the correct queues in a nice and controlled manner. (right?)

Essentially yes. The requests can execute concurrently but they have to synchronize with one another is some way (e.g. lock or database transactions).

Should I handle the state of the queues in memory instead?

Often, it is best to make web application stateless and requests independent. Under this model state is stored in a database. The tremendous advantage is that no synchronization needs to take place and the application can run on multiple servers. Also, if the application restarts (or crashes) no state is lost.

This seems entirely possible and appropriate here.

Put the state in a relational database and use concurrency control to make concurrent access safe. For example, use the serializable isolation level and retry in case of deadlock. This gives you a very nice programming model where you pretend you are the only user of the database yet it is perfectly safe. All access must be put into a transaction and in case of deadlock the entire transaction must be retried.

If you insist on in-memory state then split the singleton and transient components. Put the global state into a singleton class and put the operations acting on that state in a transient one. That way dependency injection of transient components such as database access is very easy and clean. The global class should be tiny (maybe just the data fields).

Use to_hex() to get a hexadecimal representation for the number. Then use decode() to turn it into a bytea. (Unfortunately I did not find any direct way from bigint to bytea.) Cast that to text and reverse() it, because of the endianess.

Don't use the Application class as the controller class: it makes it too difficult to keep track of which fields are initialized in which instances of the class.

Why does the FXML object get deleted

It doesn't.

Fields annotated @FXML are only initialized in the controller. When you load the FXML file, the FXMLLoader creates an instance of the class specified by the fx:controller attribute, creates the objects corresponding to the elements in the FXML, and then sets the fields in the controller to the objects it created. Finally, it calls initialize() on the controller.

So in this case, calendarContainer is initialized in the controller (which is why you see a non-null value in your initialize() method), but it is never initialized in the instance of the Application class, on which start() is called. So it doesn't suddenly become null at some point: it was always null.

You should create a separate class for the controller:

This seems to be related to the callback triggering multiple times on error if the debugger is be believed. The solution is either not to use this pattern at all, or wrap the async call in a Promise like so