phoxelua / matcha Goto Github PK

no clue why it doesn't work but its annoying as shit

• Value proposition
• User scenarios
• Competitive analysis
• Required features
• Nice-to-have features

why? state should never be mutated. causes more errors than it's worth.

we can use immutable.js to help with this, or try to use some of the helpers that react has already implemented in the library. i feel that immutable.js is better, though.

a couple of options:

• redux-immutable, which creates a combineReducers which works with an immutable initialState
• redux-immutable-state-invariant, which is dev-only and spits out errors if you're mutating it

we should probably use form validation instead of manually checking the request json?

after spending a while trying to finagle with eslint and babel to get the airbnb configs to work (they didn't end up working), we should really:

• how our babel config works
• what we need to do in order to support better linting
• remove anything we don't need, and add things that might help (look at boilerplates to get an idea here)

Primarily for authentication. We could also consider creating a Profile data model or something, to store some user information. We may want to discuss this in person and go over some existing implementations to design this well, but the only requirement is to support auth.

https://github.com/davezuko/react-redux-starter-kit/wiki/Fractal-Project-Structure

not all of it is smart but some of it is

maybe use Hound if that still exists? Or precommit hooks?

just use redux-auth, maybe we can help contribute along the way. so much time saved

• Kill all usage of Heroku
• Write scripts to launch the api server and the webpack server

some info here: https://github.com/dropbox/zxcvbn#perf

In order to remove any reliance on the materialize.js crap, let's make a dropdown. There's enough components out there that we should largely be able to make whatever we need from Materialize, but in native react.

It's really nice to have but is utterly unmaintainable. Since we can easily re-add pieces, we should just cut loads of crap from it. Save some of the nice stuff, get rid of the stuff which will likely go unused.

Connect service to MongoDB

https://github.com/mzabriskie/axios

good library, we can replace the places we're using fetch in the client with this

dis lib is specifically for the passw0rds https://pythonhosted.org/passlib/index.html

it suck

eh, why not..... since this is mostly just going to be a learning project. elixer deals with many requests way better anyways.

alternatively, nodejs would be a great way to learn about isomorphic apps, would be easier to build, and would have a lot of great packages supported more easily.

• if token is there, attempt to get data with it
  • if that succeeds, then we're ok
  • if that fails, then we redirect to sign in page
• else, redirect to sign in page

• Dashboard (home page)
• Transactions
• Goals
• Profile

add them to the routes folder so we can slim down the entry.jsx. also maybe rename that to main.jsx or index.jsx or some shit. make sure the base layout works

• Write a basic Card
• Write a top navigation bar
  • Make it responsive
• Set up multiple routes
• Add some SCSS mixins for a responsive container (could probably copy from Bootstrap, hard to do with Flexbox because it requires a parent and a child)

I'm a huge fan of the way that davezuko does his webpack configurations in this boilerplate. Planning on powering up our webpack config code in a similar way, so we can get rid of having the webpack configs in the root directory.

There's actually a lot of good info there to learn about. Have to be careful and test a lot tho because of the different entry points in his isomorphic boilerplate vs our Flask config.

https://github.com/zalmoxisus/redux-devtools-extension

Create a setup script that will setup the environment with necessary exports variables and installs packages.

Script should clean environment first and have strict versioning.

We can use CircleCI for running tests actually, free up to however many build runs.

http://flowtype.org/

Would be great to use this in Travis and/or pre-commit too.

This way we don't need to call snake_case_to_camel_case every time.

Plaid has an official library for Python to integrate with.

This extremely basic integration should include:

• Basic configuration for the Plaid client
• Authenticate a Connect user

The latter might be best done in the form of a command-line script which makes a request to our server with the username and password of the bank account. If we can't test that because all of our account information is MFA, then this might be blocked upon creating a frontend for this flow.

token is always in localstorage so can just grab from there, makes code look nicer

https://github.com/reactjs/reselect

sounds like some hot shit, might be worthwhile to learn now

make login do shit like actually verify something meaningful instead of returning a hardcoded token

Basically, go through and make sure that the things that are there are things we want, with the right versioning. Most of them should be set to newest, if possible.

flake8 is bitching about alembic so we need to ignore those

should have linter configs in general, i added one which hooks into webpack for airbnb's js styles but it doesn't really enforce them that rigorously oh well.

Jest is probably a good choice, it also comes with the boilerplate.

some ideas here: http://damyanon.net/flask-series-testing/

inspired by the god tj himself: https://github.com/tj/frontend-boilerplate

maybe there's a way to do variables in postcss? should see, a lot of this shit is pretty cool esp modules. plays well with react too.

http://simplaio.github.io/rucksack/docs/
https://github.com/outpunk/postcss-modules