Chat-App | react-firebase-chat | Authentication library

The difference is much more conventional rather than functional - the difference being side-effects vs a final consumer.

The doOnXXX series of methods are meant for user-designed side-effects as the reactive chain executes - logging being the most normal of these, but you may also have metrics, analytics, etc. that require a view into each element as it passes through. The key with all of these is that it doesn't make much sense to have any of these as a final consumer (such as the println() in your above example.)

On the contrary, the subscribe() consumers are meant to be a "final consumer", and usually called by your framework (such as Webflux) rather than by user code - so this case is a bit of an exception to that rule. In this case they're actively passing the messages in this reactive chain to another sink for further processing - so it doesn't make much sense to have this as a "side-effect" style method, as you wouldn't want the Flux to continue beyond this point.

(Addendum: As said above, the normal approach with reactor / Webflux is to let Webflux handle the subscription, which isn't what's happening here. I haven't looked in detail to see if there's a more sensible way to achieve this without a user subscription, but in my experience there usually is, and calling subscribe manually is usually a bit of a code smell as a result. You should certainly avoid it in your own code wherever you can.)

This might be related to CORS problems. I had a similar issue where i had the socketio server running on port 5000, the angular app on 4200, which the CORS policy did not like at all. I solved this using a proxy configuration and starting the dev server with --proxy-config proxy.json.

proxy.json:

You are starting the server on PORT 8000 but the client is trying to connect to PORT 8081.

Change this line,

You should start the import path from src folder src/app/_services/modal.service or you should move back two folders so to reach _services folder ../../_services/modal.service

The syntax is INT UNSIGNED, not UNSIGNED INT. In addition, NOT NULL is redundant on a PRIMARY KEY. So try this:

You are clearing the controller in the button callbkack _controller.clear(), but what you are really sending to Firebase is not the _controller text but rather the variable _enteredMessage which does not get cleared.

if you just send the controller text instead of _enteredMessage the problem should be solved:

add the following import:

Turns out it was a problem with my imports.

Incorrect: import API from '@aws-amplify/api'

Correct: import { API } from '@aws-amplify'

The incorrect API worked just fine for other graphQL queries, but it was borking subscriptions.

I should also note that the failure was generating a AWSAppSyncProvider.ts:204 Uncaught (in promise) undefined error in the console, which I hadn't noticed earlier, though that didn't help much toward finding the solution.

This topic arises from time-to-time, and it's important to realize that security can (and likely should) happen in different layers of your application.

When working in AWS, it's important you understand Identity and Access Management(IAM). IAM is what AWS uses to define access policies to resources throughout the AWS ecosystem.

IAM is extremely powerful, and can even be used to define which DynamoDB partition each of your users has access to! This may seem like the solution to your problem. However, it's unlikely your applications users are accessing DynamoDB directly. Instead, they are invoking an API, which executes a Lambda using a different IAM role than your user. So, what do you do?

Remember when I said security should happen at different layers of your application? Well, this is one of those times! Your application code should make decisions based on who is accessing the application and take appropriate action to allow/deny that access.

For example, your application might decide that users can only message people they are friends with. This is not something IAM is going to help you with. Instead, you need to implement the logic to enforce this business rule directly in your application code.

The moral of the story here is that there is no built-in mechanism to enforce all types of business rules your application may have.

If you are using Amplify, you should start by looking into Cognito for Auth. Cognito will help you set up permissions for users of your application using IAM roles (e.g. unauthenticated, authenticated, administrators, etc). These roles will let you define different IAM policies that grant your users a variety of permissions (e.g. access to API Gateway endpoints, specific S3 buckets and DynamoDB tables, etc).