juggle | Websocket library

You can create groups in your data based on presence of NA values.

You have to cast your custom primary key to the correct type and ensure that Eloquent doesn't think that your primary key is auto incrementable:

A simpler test case:

I think you can get the results you want by computing the difference between the timestamp of each entry and the timestamp of id = 12 (Berry), and selecting either those rows where the difference is <= 0 and name < 'Berry' for the previous row or rows where the difference is >= 0 and name > 'Berry' for the next row. For example, for the previous row:

As of EF Core 5.0, filtered includes are supported, so you could write your query as follows:

Use redux-toolkit.

Create your store, state slices and their reducers using createSlice from @reduxjs/toolkit and every component can access the necessary data from store by using useSelector from react-redux.

There is no need for mapDispatchToProps anymore.

Yes, this is correct.

A coroutine can be seen as an instruction sequence that a thread runs until it encounters a suspension point, at which the coroutine suspends its execution (saving the call stack and local variables to be resumed later) and yields control, and in that case it no longer runs on the thread it was running on.

This is very similar to how a function that returns no longer runs on the thread, returning control to the caller, but a coroutine additionally saves its state so that it is possible to resume it later, on the same thread or another. Once a coroutine yields control, the thread returns to the code that started or resumed the coroutine. That code may or may not be another coroutine.

You can think of a thread as a primitive of a lower level (OS-level, or JVM-level) than coroutines. All code in an application is executed in some thread, one instruction sequence in each thread at a time, and coroutines are no exclusion in this sense.

When TypeScript 4.1 lands you will be able to manipulate string literal types via template literal types as implemented in microsoft/TypeScript#40336. Here's a possible implementation to convert a type to a union of slash-delimited paths that lead to non-object properties:

So when you create a Service Credential with HMAC keys, what is essentially happening there is that those persistent keys are being generated by COS (not IAM) and are bound to an IAM Service ID (ie a non-human user). When you send an S3 API request by creating a signature with those keys, COS figures out the associated Service ID and checks with IAM to see if that identity has sufficient privileges for the operation being requested. This allows you to use the persistent HMAC keys at the expense of needing to waste some CPU calculating all the HMAC signature stuff for each request. So while IAM is involved behind the scenes at the policy enforcement level, authentication is handled by COS directly.

Now, if you want to programmatically create Service Credentials, there's a REST API for that, but no published libraries, (although I suppose you could try and generate one from the OpenAPI spec). Essentially you just call that API and provide the {"HMAC":true} bit inside the "Parameters" object. Inside the response you'll find the credential with the HMAC keys.

All that being said, you don't want to use IAM tokens or HMAC signatures for your application's end users. Think about the Service ID that you've bound to the HMAC credentials as the executor of the operations being performed. Try and keep the user authentication piece isolated, and then when some end user is allowed to do something, then have the Service ID do the operation. Obviously all applications are going to be different and have their own challenges. One pattern that we've seen used (and I keep meaning to put together a tutorial for) is to have the application generate a pre-signed URL, and pass that to the client, avoiding any need to pass credentials outside of the application space.

Basically, IAM is intended for administrators, developers, and other cloud services to authenticate and authorize actions in the IBM Cloud (and thus aren't intended to scale past a few thousand access policies), but you should be looking to something like App ID for the end-user authz pieces.

What language/framework are you using? Are you using the COS SDKs? They abstract away the token management stuff for you if you'd rather use API keys.