couchdb | A straight-forward client for CouchDB REST API | Runtime Evironment library

You don't need a 3rd Party React wrapper to use PouchDB with React. You can use the PouchDB js lib directly in your application and render the output using React.

You can't. When the browser is closed (or the page existed) the JS environment goes away and all promises disappear. You need to take a different approach.

A typical approach would be to store the data about the order in (for example) localStorage and then:

• Delete it when the order is executed
• Read it when the page is loaded and:
  • put pending orders back on the queue
  • handle out-of-date orders however you like (e.g. display an error or submit them late)

There is a setting which enables the history database for peers. It is enabled by default and is a a physically separate database from world state.

Each channel has it's own history database. The history database uses LevelDB (an embedded database) for storage.

The history database stores key/txid/blocknum for each update. When you call GetHistoryForKey, it iterates through the history db and then retrieves the values from block storage.

The problem is that you are creating the user through the _node/_local interface. The user should be created via the clustered API on the _users clustered database.

One may in fact compact a mango index because every index created at the /db/_index endpoint¹ has a "ddoc" (design doc) just like the design docs for map/reduce views.

Quoting from the /db/_index documentation,

Mango is a declarative JSON querying language for CouchDB databases. Mango wraps several index types, starting with the Primary Index out-of-the-box. Mango indexes, with index type json, are built using MapReduce Views.¹

Now look to the /db/_compact/design-doc² endpoint's documentation^*

Compacts the view indexes associated with the specified design document. It may be that compacting a large view can return more storage than compacting the actual db. Thus, you can use this in place of the full database compaction if you know a specific set of view indexes have been affected by a recent database change.

^{*Emphasis mine}

Since every "mango index" has a design-doc, it follows that any mango index may be compacted with the /db/_compact/design-doc endpoint.

This may be verified easily with curl. Say there is a mango index with ddoc="foo-json-index-ddoc"in the "stack" database,

I'm guessing you selected typescript as the language for your chaincode/contract, and it looks like it didn't transpile the typescript code to javascript. I would suspect there is a build option in the package.json, so try running npm run build in a vscode terminal in the directory your smart contract is stored (there should be a package.json file in that directory). If that fails because it can't find tsc then you need to run npm install first to install all the pre-reqs, then you should be able to run npm run build.

Once your smart contract has transpiled successfully (there should be in index.js file in the dist directory which is what the error message you posted is complaining about) you should be able to package the chaincode/contract again and install it (you may need to change the version number of your new package before you try to install it again and that's the version field in your package.json file.

You can use UML class diagrams to model entities and aggregates of an application domain, regardless of the implementation technology. You can also model a more concrete implementation that uses a NoSQL database, and in particular document stores such as CouchDB. Objects are stored in the database are kind-of dehydrated (i.e. object data without their behavior) into a document.

There are challenge that you will face:

1. mapping between the document world and the object world: a document may contain several related objects (no joins needed), as well as links to other objects (see also embedded/nested document vs. document references).

2. potentially unstructured (or loosely structured) documents: document databases are extremely flexible about the content of documents, and it is perfectly allowed to mix objects of completely unrelated classes into the same document collection. Moreover, the fields/properties/members of a document may be dynamic and evolve. In practice however, collections often contain similar objects that will vary mainly regarding the fields (for example to acknowledge existence of implicit classes). Documents may even be validated according to a schema to ensure consistency if needed.

3. UML classes are based on strong typing, whereas types in documents are as flexible as the rest of their content (e.g. a field from could be a date 2000-04-02 in one document or a string "a long time ago" in another one).

So before you start, you need to think of the mapping strategy. My advice would be to focus in UML on the design of your object model, and think of documents as a convenient grouping of related ones (DDD aggregates may help in this regard). The following rule of thumb may help for the modeling:

• joins (e.g. links between independent documents) will be represented by associations.
• systematic grouping of objects with other, may suggest existence of some kind of stronger relation such as UML composition.
• fields that vary from document to document would be represented either with optional properties (multiplicity 0..1 or 0..*) or generalisation/specialization of the enclosing object, depending on the logic that explains the variation.

So, I thought of answering my own question, after realizing my mistake. The answer to this is simple. It just needed more time, as the indexing takes a lot of time. you can see the metadata to see the db data being indexed.

Update: This was fixed by using npm config set registry https://registry.npmjs.org/ in the terminal