hosting multiple apps

[threepointone]

I was thinking of 'multiple apps' with modular. We already have a couple of usecases popping up, and I can imagine it's not really an edge case for most people. I'd think there are 3 'kinds' of scenarios/solutions:

• The current solution is to use dynamic imports + React.lazy for every entry, and use a router to load them on different paths.

  • pros
    • There's no extra work here, already supported.
    • Conceptually simple
    • Single build, shared assets, one unit.
    • Always available as an option, and can be used alongside any other solution.
  • cons
    • Initial waterfall could be slow.
    • Solving waterfall with prefetch requires server infra
    • Doesn't solve a possible scenario, where multiple apps might need to load different things on the same routes (unlikely, but still)
    • Might need to explicitly disallow routes for different ACLs.

• Separate apps, basically separate CRA instances. So you could have packages/app1 and packages/app2 be full fledged CRA generated repositories.

  • pros
    • Easy-ish to do
    • No extra config per se
    • modular build should accept a entry input; e.g. modular build packages/app2
  • cons
    • The /public boilerplate is annoying, could do better?
    • Super slow, since it effectively doubles build time (or how many ever apps are there)
    • Doesn't reuse work across builds
    • Must be served from different (sub)domains / requires more server infra/config

• We could have multiple entry points in the generated bundle. CRA currently assumes src/index.js; we could theoretically add more. So the command to build would be modular build packages/app/src/index.js packages/app/src/docs.js ....

  • pros
    • This is all in one build, and it would reuse work for all the entry points by default
    • Conceptually simple to understand.
  • cons
    • This is ine one build, so if it's a small change in an entry point that represents a small app, the build would be slow since it has to rebuild the whole app (unless we can figure out incremental build)
    • Unsure whether it's as simple as passing multiple entries to webpack (https://webpack.js.org/concepts/entry-points/), might break other assumptions in CRA's infra.
    • Will require custom server infra that loads the right entry in the html for a given route or whatever.

It feels to me like a combination of options 1 and 2 is the right way to go about this, and we solve the cons (figure out a way to inline prefetches for a given entry, figure out incremental builds, etc.) Open to input.

[threepointone]

This has now landed and published, leaving open until we write docs for it.

[sebinsua]

This relates in some ways to the high-level 'loaders' issue.

[threepointone]

The main readme now documents the commands for making/running a new app, and our simplified docs don't need more detail than this (for now). Closing.