So what about context

[estrattonbailey]

Atm we're calling the object that gets passed through a render cycle "context".

But what is context?

• lambdas have context from the server (currently aliased as lambdaContext)
• react has context (obvi p separate from this, but something to consider since people might confuse it)
• people might render files other than HTML, so some props/utils on this context might be confusing
• context is mutable and I add a few things to it atm

Things added to context during a render cycle:

• content - the string from the template, used like this
• head
  • this needs attention for sure, just haven't spent time thinking hard on it
  • passed to template, head is a function to configure head meta tags
  • once this reaches createContent, head is overwritten to be the object of head meta, so it can be inlined into the document

👉 This context object could be valuable real estate for other plugins or utils to be added to as well.

Open questions:

1. What do we think of the shape of this object?
2. Any ideas around plugins/utils?
3. Maybe we should make this more immutable and provide a multi-use object on a sub-property where we can attach random data, depending on plugins/utils and the type of document being rendered?
4. How about naming? Is there a better word for "context"? Better word for the multi-use object?

[estrattonbailey]

Maybe the answer here is to make it explicit and not try to be clever...

What everything shared an object like this, and we referred to it as "props" to clear the way for "context" to be a separate shared bucket for plugins and stuff?

const props = {
  path: '/about',
  params: {}, // route params
  query: {}, // query params
  lambda: {
    event: { ...headers }, // full lambda event
    context: {}, // lambda context
  },
  context: {}, // SHARED
  plugins: { head } // place to attach plugins, which are passed the context object
}

[estrattonbailey]

So here, we'd by default pre-configure a head plugin, which could be instantiated like this:

const context = {}

const props = {
  context,
  plugins: { head: createHeadPlugin(context) }
}

The user would then reference plugins.head({ title: 'Page Title' }) in their template.

createContent would be able to reference props.context.head which would be the object of head tags.

Other plugins could add to the context as well, so the user could consume in createContent or createResponse.

[estrattonbailey]

I think we've got a good thing going here now as of #35