gundb / feature-requests Goto Github PK

Hey,

as I already posted here amark/gun#413, I would like to build a decetralized chat application using Gun.JS. I want to use native android and don't want to use facebook's react or any hybrid framework as phonegap or ionic.

• Do you know about any approaches? I thought about using J2V8.
• I have concerns about the RAM memory usage of GUN.JS and mobile devices.. Are there any benchmarks / average memory usage values I can use as reference?

Thanks,
Jonas

We may want a module that allows developers to save data in a gun-friendly way (e.g. could perform .all() searches against it) in either LocalStorage, alternating Gun instances, or multiple nodes.

Guidance in porting it to go and keeping compatibility with the js :)

This way, it could sex better with golang backend systems. (but I am doing some research into how to facilitate that sexing w/o a go port right ths moment)

gitter conversation - meat of the discussion starts at https://gitter.im/amark/gun?at=56abb0526b6468374a0a52e2 and continues well past https://gitter.im/amark/gun?at=56abbef9c54bc2bf180cdca2

Moved from core repo to extensions repo. See amark/gun#62 for details.

Re: amark/gun#60

"Create an extension that only has one key, like 'keyspace' which just uses a regular GUN node where the "keys" are now just fields on that node, that reference the actual node. These fields have the conflict-resolution sync guarantees on them already, so if you want to change where the field key references, you just update it to point to the new node. This then is the overwriting behavior, with the additional perk that it has the eventual consistency feature, which keys don't normally have."

We need some type (and probably multiple types of) encryption capability. This does not below in gun core and will therefore be provided via modules and extensions.

See issues amark/gun#47, amark/gun#48, and #3 for additional info.

Moved from core repo to extensions repo. See amark/gun#128 for details.

I'm looking at integrating Gun with a React + Redux app. Does anyone know of existing Gun-Redux middleware? If not, would anyone like to work on this with me?

The concept here would be to prototype jQuery.data() such that it pushes data to GunDB rather than attaching the data to the DOM as it does now (standard jQuey behavior). While this would have limited meaning when GunDB is utilizing local storage, if the plugin were initialized with a reference to a gun server, any jQuey app that uses .data() methods could be made instantly collaborative.

I was a bit surprised to see that gun and it's dependencies are 18.8 MB after npm install.

npm install --save gun

Some ideas on how to reduce the size:

1. Add a .npmignore file, see docs. This could exclude folders such as test, examples, and anything that is not necessary for gun to work at runtime.
2. Remove the dependency on aws-sdk and allow the user to pass in the sdk they wish to use in a Gun constructor. This will reduce the size drastically. By creating a common interface for reads/writes, this would allow the end user to pick which cloud service they want to store the data: AWS, Google Cloud Storage, etc.

Number 1 is straight forward but number 2 requires some refactoring.

The "getting started" code could include a couple extra lines to wire it up.
This is roughly how I envision it (note that I don't know much about gun internals or aws sdk):

const port = 80;
var express = require('express');
var Gun = require('gun');
var AWS = require('aws-sdk'); // optional
var app = express();

var myConfig = new AWS.Config({
	credentials: myCredentials,
	region: 'us-west-2'
});

var gun = Gun({
	file: 'data.json',
	aws: { // optional
		config: myConfig,
		bucket: myBucket
	}
});

gun.wsp(app);
app.use(express.static(__dirname)).listen(port);

Now there is no dependency on aws but the user can provide it in the constructor. Gun will just have to know which APIs to call in the aws-sdk.

An even better implementation is to provide only an interface to read/write data that Gun requires. Something like the following:

var gun = Gun({
	file: 'data.json',
	cloud: {
		read: aws.s3.readBytes,
		write: aws.s3.writeBytes
	}
});

Then the user could wire up any cloud storage.

We need to provide some mechanism to do distributed math. This will most likely be via a CRDT module or extension.

We may want to develop a module for email integration.

At the very least, we should provide examples of how to integrate with email.

gundb is getting popular these days and having a global test-suites will make it possible for people to port it to other languages a lot easier and by confident. Also update in spec can be identified and fixed in all implementations.

for example websocket has autobahn-testsuite which can test client and server implementation.

Have you thought about this?

See conversation starting at https://gitter.im/amark/gun?at=5691e0340712a5b63b4c8869

Feature request.

There are no major reporting engines that support GUN (nor most NoSQL DB systems). My solution for this kind of issue is to:

1. Architect the NoSQL database, treating each collection like a table, with only a single tier deep of records; AND
2. Have a general software system that subscribes to each collection, and inserts/updates records in a relational database.

I'm sure many coders can repeat [2], and do it in all kinds of mind-bending ways. But ideally, each NoSQL vendor does this kind of thing once and well. I'm sure there are unique features with each NoSQL database system to ensure the integrity and timeliness of relational reporting data.

(Also, there's a chance to use a streaming SQL language so that special reporting results tables can be built live, and aggregate results can be maintained for ready near-instant access.)

This might be a key feature that's missing to enable widespread adoption. With an adaptor to a relational database, most reporting engines will be able to READ from such relational databases for business reporting needs { Dashboards, Emailed PDF reports, adhoc reporting, etc }

It would be best if a "GUN-PostgreSQL" (for example) adaptor project could be managed alongside the core GUN project(s).

Benefits:

• Backups - there are standard mature practices and tools for backups
• Technology-redundancy - Gun-db is solid, but not near as mature and trusted yet as postgresql. Being able to have data in postgresql as well means more peace of mind.
• Leverage postegresql - only implement features in gun-db that you can't workaround with postgresql. That means you can focus on the biggest benefits of gun-db first.
• SQL - one of the leveraged benefits - SQL query directly off postgresql, don't try to parse SQL with gun
• GraphQL - another leveraged benefit. With Postgraphile you can turn postgreql into a graphql server leveraging views, and the security model.
• Reporting tools - unlock tools like powerbi

(If you think of any more benefits please comment, and I'll add them to the OP list here)

Thanks.

erasure coding makes things uber robust
encrypting before hand prevents data leakage or individual pieces of ECd chunks/slices

see any number of papers, esp the ones by Cleversafe (now IBM) folks who've done it well.

How can I use it in a NativeScript project?

Moved from core repo to extensions repo. See amark/gun#55 for details.

Modules to import and export into other data formats, such as csv, xml, xsl/xslx, etc.

See also amark/gun#49

Authentication / Authorization functionality. This does not below in gun core and will therefore be provided via modules and extensions.

See issues amark/gun#47, amark/gun#48, and #5 for additional info.

Moved from core repo to extensions repo. See amark/gun#94 for details.

There should be universal guidance on how to use Gun-JS with a range of given languages and platforms using a headless v8-js engine.

Porting would be ideal, but the first step is getting broad adoption through a single solid code base. When millions of people are using it, then it will make sense to maintain multiple code bases (but it would likely be a Golang and using WebAssembly from Golang for web)

We may want a module that allows developers to perform asynchronous operations between peers (e.g. turn-based games).

It would be great if we had phaser.io tooling for syncing state in game apps...

Gun could strongly benefit by building tools for both Angular and React, making it easier to synchronize application data (preferably flexible enough to handle most use cases). I'm picturing something in Angular that would sync objects from controllers or scopes (perhaps under a gun namespace). In React, maybe a hook into this.setState? There's probably a better way...

We need some type (and probably multiple types of) encryption capability. This does not below in gun core and will therefore be provided via modules and extensions.

Related to #95, if running gun.path('surveys').map().path('q').put(null) through many iterations (e.g. 10,000) time bogs down the system until it locks up.

[ ] Dropbox & [ ] Google Drive - see conversation starting at https://gitter.im/amark/gun?at=569a91e359e3d04215bc2318

@samiralajmovic - I don't see where you posted this, but wanted to make sure it was captured as an issue.

For usage with sd cards its better to write less often and in bigger chunks to ensure that sdcard doesnt die quickly.

Is there any way to separate .put() from actual disk write? Ideally gundb might have 2 parts, a log of few last actions kept in ram, and bigger file kept in storage, that is updated with a log once every minute or so.

When gundb needs to send data by network or show it to user, it should first check the log, and if it has nothing related, then check the disk storage. This way both storages are seen as one for a user, hopefully.

Also this might help to make gundb fully in memory or fully on disk type of db, if users would have a control how odten

Moved from core repo to extensions repo. See amark/gun#90 for details.

Please add some detail about off() to Wiki:)

For usage with sd cards its better to write less often and in bigger chunks to ensure that sdcard doesnt die quickly.

Is there any way to separate .put() from actual disk write? Ideally gundb might have 2 parts, a log of few last actions kept in ram, and bigger file kept in storage, that is updated with a log once every minute or so.

When gundb needs to send data by network or show it to user, it should first check the log, and if it has nothing related, then check the disk storage. This way both storages are seen as one for a user, hopefully.

Also this might help to make gundb fully in memory or fully on disk type of db, if users would have a control how often a disk write is done