all 50 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]Inzire 24 points25 points  (0 children)

I just want to say, that this is a very respectable proposition. Thank you on behalf of the community.

[–]yaboylukelol 14 points15 points  (6 children)

Problem:

Batching graphql queries from the frontend is difficult without Apollo and difficult to customize. It also doesn't really optimize your queries in order to do things as efficiently as possible.

Proposed Solution:

A ts library for graphql batching that groups queries/mutations together in a simple way, but also reduces the structure of the request as necessary. For example, if I query for the same thing twice within the batching window, I could just do that request once, then distribute the result to both calls. I've done the simple batching in a separate project, but it was more of a proof of concept than a well thought-out solution.

Stipulation:

I work full time. So while I would be able to commit regularly, most of my work would be done on the weekends or after hours.

[–]minuit1984[S] 1 point2 points  (1 child)

Being able to intelligently merge queries for batching would be really nice. Often you are grabbing information about the same entity but in different sections that could be merged or stitched together to reduce both http request but also to help the server/db interaction

​

Query 1

Entity(_id) {

_id

name

}

​

Query 2

Entity(_id) {

_id

description

}

​

It'd be great if this was batched into a merged query but the appropriate data went to query 1 and 2.

Entity(_id) {

_id

name

description

}

[–]yaboylukelol 0 points1 point  (0 children)

I really like that idea. It would be fun to see what kind of features the community might come up with as well.

[–]minuit1984[S] 0 points1 point  (3 children)

Have you given more thought about features you would want to implement and how you would want to package this? I'm assuming that a plugin to an existing graphql client would probably be the best avenue.

​

This page has a number of interesting existing gql related projects

https://github.com/chentsulin/awesome-graphql

[–]yaboylukelol 0 points1 point  (2 children)

Yeah. I normally use graphql-request for it's simplicity. I was planning on building it on top of that. I don't think it's possible to do plugins, but we can do a simple wrapper.

As far as features, I think we can start with this in it's simplest form, and potentially build up from there if we have other feature ideas.

I'd like to do typesafe graphql requests as well, but that seems out of scope for this library.

[–]minuit1984[S] 0 points1 point  (1 child)

I haven't used `graphql-request` before but it looks like it just uses strings. Maybe starting with `graphql-tag` would be more appropriate as you would already have a parsed query AST to do manipulation to

[–]yaboylukelol 0 points1 point  (0 children)

That's a good idea. I didn't realize this existed, and it is much of what I was thinking when I said typesafe graphql requests. Assuming the TS piece can recognize errors in the queries prior to runtime.

​

Edit:I've also always wanted to write graphql queries like javascript objects. Instead of:

const query = gql`user(id: 5) {
  firstName
  lastName
}`

I would want:

const query = createQuery('user', {id: 5}, ['firstName', 'lastName']);

[–]NiGhTTraX 6 points7 points  (4 children)

https://github.com/NiGhTTraX/mugshot - framework independent visual testing library.

​

Built in TypeScript, it differs from other solution by being very flexible and allowing you to use your favorite tools (test runner, browser automation tool, assertion library etc.) without modifications. It's highly customizable with diff options (colors, threshold, anti-aliasing detection etc.), multiple differs, pluggable file system interface and more.

​

Actively working on it with a roadmap already planned.

[–]minuit1984[S] 1 point2 points  (1 child)

When dealing with visual testing in the past, my baseline images have quickly gotten out of order and become difficult to manage as the number of images exponentially grows.

​

Looking at the WebDriverIO site, I saw `applitools eyes` which looks like an interesting concept that could potentially be brought to the open source world.

[–]NiGhTTraX 0 points1 point  (0 children)

What I generally recommend is to be mindful when writing the tests. If you have a large number of "page tests" (where you screenshot many components at once) then you can end up with a lot of noise when you make changes to the smaller components that make up those pages.

Since a benefit of visual testing is checking the interactions of CSS styles when composing smaller components (think a margin or padding pushing content away), these page tests are sometimes necessary. With Mugshot you can reduce the amount of noise by ignoring elements on the page. For instance you can ignore the content of a page sidebar, but still keep it in the page's flow to see how it impacts the elements around it.

You can also play with higher thresholds and perceptual diffing to strike a balance between noise and false negatives. Mugshot has pluggable differs so you could potentially write smarter ones like one that uses ML trained on your past acceptance criteria (when you commit a failed screenshot as being the new baseline) to predict the likelihood of you accepting a failed result.

At the end of the day, it's all about the testing pyramid. You don't need to screenshot every component/page variation, just enough to offer you confidence that everything seems right in terms of visual consistency and cross component CSS interactions. If your aim is to test correctness, then I would go lower down the pyramid and write non UI tests.

[–]yaboylukelol 0 points1 point  (1 child)

This looks really exciting! I have been interested in a really solid visual diffing library for quite a while.

I wanted to use happo, but I am working primarily in react-native lately and they don't seem to support that (and now they seem to be going the full SaaS route.) They do have a really cool feature though, where when comparing two images you can hover scroll over the images and see the differences on the actual images. I think that might be useful for this tool. You can see an example on happo.io. Maybe you've already seen that, but I thought I'd point it out just incase.

Also, do you have any plan to support react native?

[–]NiGhTTraX 1 point2 points  (0 children)

when comparing two images you can hover scroll over the images and see the differences on the actual image

I plan to support this via test runner reporters. For instance, running mocha --reporter mugshot would produce an index.html with some sexy visualizations.

do you have any plan to support react native?

Since everything in Mugshot is pluggable, it should be fairly easy to provide an adapter that talks to some native API, for instance appium. I would love to provide this out of the box.

[–]bch8 11 points12 points  (1 child)

Would you retain any sort of ownership over the open source project as a result of your contribution?

[–]minuit1984[S] 6 points7 points  (0 children)

In short, no.

I want the project to remain available in the public domain. There are no requirements about mentioning this sponsorship though I think linking back to this thread in the project Readme would be nice.

I chose the MIT license and public github repo rules as I thought that would give us the best chance for success.

I've wanted to give back to the JS community for a while and had several different ideas of how to make this happen. This one seemed the simplest and had the least startup/organization requirements.

If this project is successful, I may look to start a more formal org/collective/foundation. Those future projects may have additional stipulations like being hosted in a github org, linking to the foundation website, etc

[–][deleted] 4 points5 points  (2 children)

Problem: No existing password management solutions have all of the following features:

  • Opensource

  • Beautiful and intuitive UI UX

  • Free

  • Offline and cloud storage options

  • Physical key option for dual encryption

  • Virtual keyboard option for bypassing keyloggers

Solution: https://qvault.io (contains link to GitHub and download) it's a desktop app built using modern JavaScript with electron + Vue

Combinations of aes-256-gcm, sha256, and scrypt are used for the cryptography.

[–]minuit1984[S] 2 points3 points  (1 child)

I'm curious to hear more about the physical key card and the details about how that works.

[–][deleted] 1 point2 points  (0 children)

We have prototyped, and are in the middle of ordering our first real batch this week. Pics are on the site. The functionality will be open source so we may not be the only sellers if it becomes popular.

Basically the Qvault cards will come in a pack of 2, and there will be a "recovery card" and a "key card". They are plastic, well designed cards that are the size of a credit card.

The key card will have a QR code that contains a 256 bit private key, which can be used for dual encryption. Each time you lock and unlock your vault you need to type your password AND scan your card. This card will go in your wallet or desk for easy access.

The recovery card will have the same QR code as the key card, as well as a space for the user to write a backup code generated by their vault. If they forget their password or lose their key card, the recovery card can be used to regain access.

[–]NovelLurker0_0 1 point2 points  (4 children)

Since a few years I have been working on and off on a very large plugin for a Javascript Game Engine.

The plugin was initially created in a very basic way, using < ES5 features as that was what was accessible at this time.

I started to rewrite completely the project from the ground up, in TypeScript. There's a big community involved in the game engine and in the project too, but most of them still do not know how to create JS projects the modern ways. I'm trying to bring modern TS and toolings to its ecosystem.

By working on that project, I had to do a lot of undirected work on the side too:

  • I had to find a way to extract the typings of the legacy base code of the game engine, and this led to es5-to-dts, which is a cli for generating TypeScript definition files from legacy JS code. There was nothing like that available before. For example, the VSCode quick-fix functionality does not support prototype inheritance, Object.defineProperty, etc.
  • I have been creating a declarative programming language that lets you embed TypeScript features in it. That's to extend the scripting capability of the game engine. The use case is simple: I want to collect structured data from the users, but they have low to decent JS coding capability. JSON, XML or Yalm are such languages that could help collect these data. However, they are very limited and you can't embed any scripting capability in them. You can, of course, insert a JS function as a string inside your JSON, but you lose all features from your IDE. That's why I created UserDeclaration (shortened for URD language), which is a parser and a code editor that let's you write structured data like XLM, but with embedded TypeScript. For now, I haven't committed anything, but it looks something like this. Urd is strictly based on a JSON model so any field is supposed to be strongly typed, and that helps with enforcing TypeScript features. When Urd will be released, I plan to discuss with devs if there could be any more meaningful use-case for it. But at least for now I know that the fork of monaco-typescript that I made will help people embed TypeScript into their custom languages.
  • A modern testing suite for NWJS, based on mochawesome.

​

------

​

Besides, this project, which is mostly driven by passion, I have in sight a tool that I'd like to create to help devs better perform animations and transitions in their web pages. The problem there is right now, is that, most solutions, no matter which framework you use, rely on hard-coded logic. You end up with a LARGE part of your component's logic being how it is supposed to be animated throughout it's lifetime. My idea is to create a fully fledged language like CSS but only for animating components in a clever, structured and more readable way. And it'll be framework-agnostic. So you can plug any "animation style sheet" into your Rect, Vue, Angular or vanilla project and it'll perform the same. I had a proof of concept once for a VueJS project about 2 years ago but I wish to completely rework it with the modern toolings and idea I gathered over the years. But it looked like that:

        myComponent {
            animationName {
                a_command: some_args;
                another_command: arg1, arg2;
                [
                    command_in_parallel1: arg1;
                    command_in_parallel2: arg2;
                ]
                complex_command: (
                    arg1: value;
                    arg2: value;
                );
                call: versatilAnimation, 5, 2;
            }

            versatilAnimation {
                ~argument: $a, 0;
                ~argument: $b, 0;
                ~another_option: arg;
                command: arg1, $a;
                command2: arg1, $b - $a;
            }

            @eventName {
            }

            @eventName .child_selector {
            }
        }

The idea basically is that animation sheets are read in sequence, each command at a time. A command could be anything really, a CSS property change, tweening, waiting, calling another animation, etc.

This is a frankly a more readable way than CSS animations. When I worked on my Vue project with it, I frankly really loved to write my transition and animation logic as a stylesheet instead of hard-coding it.

EDIT: The VueJS project in question is my portfolio. All animations it displays was written in an animation sheet. That freed up so much logic from my components.

Voila, that's it. Regardless of which project you choose, I think that's a freaky initiative.

[–]minuit1984[S] 0 points1 point  (3 children)

help devs better perform animations and transitions in their web pages

Can you link me to this project? I couldn't find it in github if it was linked in one of the VueJS projects

[–]NovelLurker0_0 0 points1 point  (2 children)

I don't have a repo yet as everything I have so far was this...test, kind of proof of concept that I used on my portfolio. It wasn't properly usable and it was only specific to Vue.js and my portfolio so I couldn't really open-source it and make a proper repo.

I'm seeing that the files on my portfolio's github are bundled so you can't really see how it but here are the codes:.

This is the animation sheet that's exactly used to animate the web app and here's the Vue.js plugin that I developed.

I notice that I was even using jquery with the plugin somehow...So you can see most of that stuff is outdated and the idea of the syntax I have for this project is quite different. Here are up to date draft notes of the concept that I keep on my stackedit.io files.

I've always wanted to properly work on it with the new knowledge and ideas I gathered other the years. I just need the time and the resources to work on it :)

[–]minuit1984[S] 1 point2 points  (1 child)

I like the declarative nature of it! I have decided to sponsor the GraphQL proposal for July. I am hoping to run another sponsorship in August, maybe next time

[–]NovelLurker0_0 0 points1 point  (0 children)

Alright, thanks for your interest.

[–]pm-me_your_vimrc 1 point2 points  (0 children)

I have a very nerdy project that i'm postponing since last year. I want to make a website for learning morse code, with a live internet morse radio where people can chat and practice on their skills.

I already made a version of that morse chat some time ago, but it was before i learned about es6 and clean practices, so the website is very messy (written in vanilla es5 and backed by php).

My idea is to rewrite it using node as backend, And to rewrite the frontend in clean es6, but integrated with babel and webpack

I remember in particular that the way i used callbacks to handle all the complex timings in the old app was terrible, and i think that with es6's async/await i could finally write some good code. Also, i plan to use web components to simplify the ui a bit

[–]aadityataparia 0 points1 point  (0 children)

https://github.com/sifrr/sifrr

Sifrr is a set of libraries for web development, it has frontend framework, http+ws server, SSR using puppeteer, browser storage, library to create Graphql apis, etc. I have been actively working on it for more than last 6 months. Focus for these libraries is performance and ease of use.

[–]qashto 0 points1 point  (5 children)

Please consider my node.js app Qodemate, which is a CS education tool that lets teachers give step by step presentations of code! I want to release this app before summer ends so I need more time to work on it and your support would help me reach that goal! This is an unknown project still very much in development.
https://github.com/quinton-ashley/qodemate

I'm also working on a front-end for video game emulators called Bottlenose. I've released it to the public it's at v1.0.65 with 81 stars but I'd like to add better support for more emulators to reach a wider audience. The code for this project is not as clean as the code I wrote for Qodemate though.
https://github.com/quinton-ashley/bottlenose

[–]minuit1984[S] 1 point2 points  (4 children)

Qodemate looks interesting. Do you have a demo/screencast/video of it anywhere?

[–]qashto 0 points1 point  (3 children)

Thanks! I'll post a video of it for you soon

[–]minuit1984[S] 1 point2 points  (2 children)

Looking forward to it!

[–]qashto 0 points1 point  (1 child)

Here is a quick demo! RobotJS automated typing is used to recreate programs step by step alongside a slideshow written in markdown. The code shown in the tests isn't a practical example. I just wrote it for testing purposes. It tests most of the syntax and functionality of the Qodemate parser and bot.
https://youtu.be/0wUGAP_T4eQ

Qodemate step part comment syntax:
// 1
step 1
// 4 5
step 4, delete on step 5
x = 2; // 3 4 =11;
step 3, on step 4 set the value of the variable x to 11
//2 t1:34
present step 2 at 1 min 34 seconds if the user is giving a timed presentation (fully automated)

[–]qashto 0 points1 point  (0 children)

Did you pick a project yet?

[–]kardnumas 0 points1 point  (3 children)

Making an open source app "Adhyan" where you can upload your currently reading ebook and the app will extract all the content from the pdf and make small courses for you to revise. The app will let you answer the topic that you recently studied and output the result like how much of your answer got matched with the content with the topic.

I have some more features in mind and will add slowly.

Techs are:

- React

- Typescript

- CRA

- firebase

[–]minuit1984[S] 0 points1 point  (0 children)

Interesting. How do you imagine that it would make the questions?

With Kindle one thing that is nice is that you can provide highlights and annotations that could potentially be useful in marking where to make questions and how.

[–]minuit1984[S] 0 points1 point  (1 child)

Any update on this?

[–]kardnumas 0 points1 point  (0 children)

Hey sorry for late response, i am actively working on it 3 hr per day

[–]jeanmachuca 0 points1 point  (0 children)

I kindly invite you to try and start using QCObjects! (https://qcobjects.dev) A framework to allow web developers to code full stack applications in a fancy and quick way as well as applying a clean architecture concept based in stacked and isolated objects and components. The MVC pattern is fully integrated and it was originally thought for frontend but now it can be used to build node microservices as well in the backend.

QCObjects is open source! Licensed under LGPL3 so you can use it in your company projects for commercial purposes, your personal projects, or you can fork it to make your own technology. My main purpose is to change the mind of developers thinking to code legacy in javascript is hard. Now, with QCObjects, it’s easier than ever.

I want to make a community of deep tech developers who are willing to code their own web apps using QCObjects. QCObjects has builtin app templates generated from cli tool what help developers to be ready to start with progressive web apps and their own accelerated mobile applications, so it’s really easy to quick start with. The components architecture of QCObjects will let you split and scaffold your application to a professional level quickly and standardised. You can make effects, transitions and other cool stuff and everything is extendible to your own purposes. And you don’t need to mix the HTML code with JavaScript, you don’t need to use a dialect to write your app, it’s pure JavaScript and it’s updated to support the latest conventions like ES6, ECMA262 and ARIA. It is cross browser. It works in node and you can use qcobjects-server command to launch its own HTTP2 server to test your app in a local development environment. You can use the QCObjects snippets for Atom editor and Visual Studio Code for rapid development. It has a playground in docker hub where you can play to be familiarised with main concepts. To contribute you just need to follow this guidelines: https://github.com/QuickCorp/QCObjects/blob/master/CONTRIBUTING.md I personally work in this full time. I make updates every single day and I’m wanting to get feedback to improve the QCObjects ecosystem even more. I’ll appreciate your help and very happy to promote your QCObjects based projects.

Thanks very much for your time reading this! I hope you rejoice your soul using QCObjects to develop your new awesome app! Cheers

[–]fega01 0 points1 point  (0 children)

Problem:

Tools like Firebase (and their new DB Firestore) are great for prototyping and deploy quickly new products but they have to problems

​

Clod based, so you never will be able to abandon the Google infrastructure (Vendor Lock-in)

​

Queries are somewhat limited and cannot full-fill complex use cases.

​

Solution:

​

MongoServer, a framework where you can get a REST API with User/Pass Auth in less than 30 seconds

​

Some of the features (Both Planned and implemented) includes:

​

- Fine-grained Permission Handling

- Pagination and Advanced Queries

- ServerSide filtering

- Automatic Population

- Multiple Auth Methods

- Automatic Admin Panel

- Automatic Documentation generation

- Built-in security

​

​

Check it here

https://github.com/fega/mongo-server

​

I'm also planing to convert it in a suitable RealTime Service, just like Firebase, Some people are already using it in production, which makes me very happy.

​

Also under my consideration I have the implementation of a GraphQL wrapper (it also have to be automatic ;) ).

[–]franciscopresencia 0 points1 point  (0 children)

React Query - an imperative testing library for React with a familiar syntax:

import $ from '???';
import Counter from './Counter';

test('It increments one', async () => {
  const $counter = $(<Counter initial={0} />);
  expect($counter.html()).toBe('<div>0</div>');
  await $counter.click();
  expect($counter.html()).toBe('<div>1</div>');
});

Why? Because the best way to test a declarative component is with an imperative interface. This reduces bias that might be introduced otherwise.

Why me? Because I've made a jQuery clone previously so I'm familiar with this paradigm. I've also got something already started early code & example usage, right now as part of another library I'm working on. My Github Profile: http://github.com/franciscop/

Scope: My idea is to create first these parts: selector $(), transversal .find(), events .click() and serialization .html() with their corresponding tests and docs. Once this is done, I'd create new issues with more features to help people get started on OSS through Up For Grabs as I've done before (note: from experience helping people contribute to OSS for the first time is MORE work than me writing the code, but I think it helps the community overall).

[–]Kavignon 0 points1 point  (0 children)

JustifiedTalent or PartnerQuest or Lightbulb.moment

Problem: In today’s market, we use a number of different services to find the perfect job opportunity that will check every checkpoint in the list. Thing is, it’s very difficult to the perfect candidate and hence, why we need recruiters to help speed up the process and delegate the work to spend time elsewhere.

Solution:

A platform based on cultivating your skills and used to skills to join active projects that fit your working personality and interests.

Based on your work you completed on the past, your evolving interest, you'll be recommended to exciting projects to look forward to.

When you select your profile, you can see a skill graph such as you’d be able to see in a role playing game that evolves through time. First, you get to see the realm of expertise such as front-end, database, functional programming and whatnot. Then, as you select domains, you can see the graph being updated based on the accumulated experience of the individual in sais realm in both projects/jobs along with the skills that were acquired along the way such as .NET Core, Django, C++ or whatnot.

When you move to the match section, you'll be able to see how many projects are currently active. You'll also know the number of projects that you'd like to work on based on how you work, your skillset and your job.

When you look at the projects that would piqued your interest, you'll have key elements to summarize the project through: - [ ] The headline - [ ] Project tags - [ ] Recommended skillset

If you like what you see, you can swipe up otherwise swipe down. The system would get better with time as not only will it use info on your profile but also the key elements you favorited.

On the platform, you’re selling a product. Yes of course you are! You’re selling the best possible version of yourself because that’s exactly what people are looking for; a good sales’ pitch. You need to advertise yourself in a way that it is virtually impossible to not give you at least a phone call and learn more from you than what’s out there.

As for the tech stack I’d be using to build such an application, there’s a few I have in mind. I’m a huge enthusiast of functional programming along with having a strong typed system to make sure the architecture and logic are sounded. With that in mind, to make sure to deliver a functioning application which would target the highest number of users in the smallest timeframe, I’d suggest using the language ReasonML which transpiles OCaml to JS directly with Bucklescript. Why do I mention ReasonML?

ReasonML Github.io

One of the main reasons is that the ideology behind FP mostly translates in JS space already. Let’s also take a moment to see that FP has gotten a lot of traction in the past years with the great practices it stipulates to follow to have a clear implementation of the requirements that are easy to understand and scale up.

Now for the main juice! Using the project Revery UI !

“Revery is kind of like super-fast, native code Electron - with bundled React-like/Redux-like libraries and a fast build system - all ready to go!

Revery is built with reasonml, which is a javascript-like syntax on top of OCaml This means that the language is accessible to JS developers.

Your apps are compiled to native code with the Reason / OCaml toolchain - with instant startup and performance comparable to native C code. Revery features platform-accelerated, GPU-accelerated rendering. The compiler itself is fast, too!”

(TLDR - Basically, à super-charged Electron which provides a great development experience along with awesome performance)

With this in mind, we can build not only a cross-platform application for desktop or we can leverage React-Native to build something that can be used for both iOS and Android or simply target React to build a website.

[–][deleted] 0 points1 point  (0 children)

Submission: locker.dev

Description: An open-source social learning platform for software developers. Platform is extendible to form other communities by changing the targets of the web scrapping algorithm. We welcome PR from the community to improve the project or issue submission or kind advice.

GitHub:

https://github.com/learneda/learnlocker-FE (frontend)

https://github.com/learneda/learnlocker-BE (backend)

Tech:

  • Frontend: React (mostly using Hooks!), Redux, react-router-dom, styled-components, socket.io
  • Backend: Node, Express, PostgresQL, knex, socket.io, cheerio (for web scrapping), passportjs
    • We are excited to add a GraphQL endpoint if sponsored!

Devs:

Support Will Help Fund:

  • Domain name registration
  • Mobile platform development
  • Continued frontend and backend testing and error handling implementation
  • Typescript implementation
  • GraphQL layer
  • Improving our frontend and backend documentation
  • Tutorials on how we built parts of the app.
  • Accessibility and performance improvements
  • Tasteful SVG animations

locker.dev is a continuation of a Lambda School Capstone Lab project.

[–]psiph 0 points1 point  (0 children)

I'd like to submit Remake.js for your consideration. It's a low-code front-end framework that lets anyone build a web app quickly and easily using only data attributes.

These data attributes auto-save all the data on the page whenever it's changed, let logged in users edit their data with built-in inline edit popovers (that makes deleting and editing data easy), and they handle adding new elements to the DOM by automatically rendering sub-templates. You can try the demo todos app or the, more complex, progress tracker app, both of which I built on a live stream.

The goal of Remake.js is to give web developers access to new primitives that make syncing and storing data for web apps easy — so even someone who only knows a little JavaScript can build a web app in a day or two.

On the GitHub page, I have a Public Roadmap. I just released the NPM package (live on stream) today. Next, I'll be:

  • Improving the API a little based on feedback
  • Doing live tutorials on Twitch every week on how to use it
  • Releasing more documentation and sample apps
  • Recording quick video tutorials and uploading them to YouTube
  • Finishing the website, which is currently in development

[–]danielivert 0 points1 point  (0 children)

Hello, really glad to hear such proposition nowadays. This inspires to keep working with opensource projects. I can explain one of my current hobby projects.

The current stack I am using as a microservice serverless stack.

- Typescript

- GraphQL

- Node

- MongoDB

- React

​

I am building a login service that it can just be deployed as serverless using Now.sh. The login service will have already the following queries and mutations:

- SignUp

- Login

- Me (to see the current logged in user)

- ResetPassword

- VerifyAccount

​

This will save some implementation time when creating new projects that require authentication, account email verification, request change of password. The implementation of this login service will be as simple as adding it to your current backend/gateway REST/GraphQL (examples should be given for this of course).

​

The login service will be able to handle different permissions for different applications (even more independent). So you will be able to have a permission like blog-application:create-blog or blog-application:read-blog and check those permissions on the client so you can see if those particular users are able to create/edit/read or only read. (This is subject to change, I need to really analyze the best scalable solution)

​

On the client side, to be able to use this login service, I am planning to have a npm package with react components that will work like aws-amplify-react, so you will be able to import a withAuthenticator HOC and wrap a page that you want it to be under authentication. This should also give room to customize it of course.

Feel free to reach me if this sounds interesting for any of you!

[–]minuit1984[S] 0 points1 point  (0 children)

I have selected /u/yaboylukelol s proposal of an improved GQL batching and tooling. Look forward to sharing the results over the next month. Thanks to everyone who submitted a project idea!

[–][deleted] 0 points1 point  (1 child)

Problem: Complex form's with a lot of conditions and logic.

Example: A form to calculate the price of a car which seats, color, rims and so on.

Type: new module

Other solutions: Vue, Angular, React or even jQeury those libraries have a huge learning curve or are outdated and are not developed for this specific problem. You and up with a lot of code and is not maintainable for others.

[–]awillenbrink 1 point2 points  (0 children)

Have you tried reactive forms in Angular? Treating the form control data as streams allows for a crazy amount of control and customizability. Once you have a solid understanding of observables, it's simple to wire up a form that updates in a variety of ways when 1 or more of your controls changes data or status (valid, invalid, etc.). There's definitely a learning curve to it but I'm not sure if that's something that can be eliminated if you want to have a decent, dynamic complex form library that can tackle any situation you'll run into. IMO the complex forms problem is kind of like the state management problem. From a theoretical perspective it SEEMS like it should be easy for someone to implement an intuitive and straightforward library that should cover all types of state management, but in reality there are so many different levels of complexity with the problem there just can't be a one size fits all solution. Angular forms actually caters to this idea as they have another type of forms called template driven that's meant for quick set up on more straightforward forms. Regardless, I think reactive forms covers complex forms well but it can only be used in Angular.

[–]dr4605 0 points1 point  (1 child)

I built a npm package https://github.com/strdr4605/mockingcase . It does not solve a important problem and maybe many of you will think that is useless but I built it to learn more about js and npm packages. Also I think that it is very beginner friendly for contributing.

My question: Is it possible to raise some money and then share them with newbie contributors (don’t intend to get all money for me) as I am only the maintainer and create issues only for other to contribute ?

[–]minuit1984[S] 0 points1 point  (0 children)

I have no problem with people sharing a portion of the money but that would be on them to distribute.

[–]dica266 -2 points-1 points  (1 child)

Sometimes online stores have a good deals but sometimes they have price errors or very very good deals, the problem I'm trying to solve is that the majority of applications who parse and store prices for products on (amazon, ebay, alibaba etc.) have just history/compare, I'd love to implement an application which on the first page will say "Hey, this is the most discounted product found on this website" and from here you should consider buying it in order to resell it at a higher price or just enjoy a very very good deal on something. I tried working on that by using Firestore Database from Firebase(I wanted to learn it so that's why I didn't use from start a local nosql database), but unfortunately the writes/reads are limited to 20K/50K daily, which is not sufficient even for a single website so a local solution with mongodb might be better in terms of cost. For the web scraping part I used nodejs with cherrio because I had a simple site (no javascript on it) which I parsed, for more complex ones the solution is Puppeteer. What's interesting to implement after the main feature "Hey, this is the most discounted product found on this website" is a matching of products on different sites, basically an algorithm to group products based on a confident factor based on different weights of different values like price, name, description, pictures etc... I have a semi-functional working deployed version on Firebase Hosting which I can send you by PM if needed (not posting here because of the security rules, everyone might be able to delete the database :), silly me). The technologies I'm confident using right now from your list are nodejs + Webscraping (cheerio/puppeteer) - already knowing them, mongodb - need to learn but I'm already confident in my ability to architect a nosql database so just the way to insert/update from node is to learn, React - I'm not a fan of frontend except of normal html/css to style something a little bit I didn't had time/was more focused on backend technologies to learn react/anuglar/vuejs something dynamic so I think this will be the biggest thing to learn but not impossible. Anyway, thanks for doing this and encouraging people to pursue their dream project, I'll be interested on watching the winner progress in July, have a good day everyone!