client-side | Client-side running on the same codebase as server-side | Frontend Framework library

So my doubt is we only write server-side code and node.js doesn't have a native fetch API, so what fetch API is used inside getStaticProps and getServerSideProps?

In the Node.js environment (getStaticProps, getServerSideProps and API routes) Next.js uses node-fetch to polyfill the fetch API.

Firebase also has a REST API which allows anyone to make requests to your Firebase services directly without any of your code in play. So even if reverse engineering and modifying the code was impossible, there's the REST API.

You must not trust client applications (especially web apps) and always validate the incoming data and ensure only authorized users can modify it.

How would they get the information needed to make API calls to my database though? And wouldn't they need a key?

If you check the Firebase config, it contains an API key which is used to identify your Firebase project only and there's no risk involved in that being visible.

Now that anyone on the internet knows address of your database, they can use it with REST API if you don't have any security rules setup.

Do note that after running the db.collection("users").get() query, all the documents have been fetched already (and data should be visible in network tab) from Firestore and then you are just looping over all the documents to find one that matches the current user's UID.

This query without security rules is insecure (unless listing users is a feature of your application):

Swagger UI sends requests using JavaScript, and those numbers fall outside of JavaScript's number range, that's why they are getting rounded. For more information, see:

• Large numbers erroneously rounded in JavaScript
• Swagger UI incorrect display of type: integer format: int64 as rounded int values in response body

You can still test the requests using another client, e.g. curl. Or you specifically need Swagger UI, a possible workaround is to change the type of Ids from List to List.

CryptoJS only supports symmetric encryption and therefore not ECDSA. WebCrypto supports ECDSA, but not secp256k1.
WebCrypto has the advantage that it is supported by all major browsers. Since you can use other curves according to your comment, I will describe a solution with a curve supported by WebCrypto.
Otherwise, sjcl would also be an alternative, a pure JavaScript library that supports ECDSA and especially secp256k1, s.here.

WebCrypto is a low level API that provides the functionality you need like key generation, key export and signing. Regarding ECDSA WebCrypto supports the curves P-256 (aka secp256r1), P-384 (aka secp384r1) and p-521 (aka secp521r1). In the following I use P-256.

The following JavaScript code generates a key pair for P-256, exports the public key in X.509/SPKI format, DER encoded (so it can be sent to the Python site), and signs a message:

As mentioned in the comments we can use htmlwidgets::onRender to pass custom JS.

With the help of the eachLayer method we can add an on-click function to each polygon layer (also see this related answer):

Reading from the official documentation, you need to at least provide two restrictions for allowing any URL in a single subdomain or naked domain (you only provide one in your screenshot). Here's the excerpt:

I believe that you need a combination of concatMap() and last().

concatMap does not subscribe to the next observable until the previous completes. Using it you will ensure the order of requests execution. And as it follows from the description it doesn't cancel previous subscriptions and let them finish, unlike switchMap.

last emits the last value emitted from the source on completion. Using it you will ensure that only one (last) result will be passed to the result.

Your code will look like that:

There are many ways to write such query in LINQ, with most of them being able to be translated by EF Core 5/6+.

The straightforward approach once you have defined a subquery for the necessary grouping and aggregates is to join it to the data table, but not with join operator - instead, use row limiting correlated subquery (SelectMany with Where and Take), e.g.

You are almost there. You just need to also config the following (Don't forget to restart your VS):