**[Quick 60 second demo video showing Model Editing -> Code Generation -> Updated Full-stack TypeScript app](https://streamable.com/lrn4o8)**


When I was primarily in Java development, I was a big fan of the [Eclipse Modeling Framework](https://en.wikipedia.org/wiki/Eclipse_Modeling_Framework). It's a beautiful piece of engineering, and although the whole ecosystem can be somewhat sprawling, the core capability is fairly straightforward, and can be fabulously useful. The core problem it it addresses is all of those times you find yourself writing the same patterns over and over again for your data model: Serialization/DTOs, REST endpoints, data base mappings, UI components, reference resolution, data diffing/merging, etc. You add a new type or field, and then scurry around updating N points in your stack to support it. EMF offered the ability to eliminate all of this, primarily driven by two major tricks:

 - Fully **introspectable models** at runtime: each object can tell you it's structure and relationships, and allow you to create/modify structure [reflectively](https://en.wikipedia.org/wiki/Reflective_programming).
 
 - Formal definition and automatic enforcement of **containment** relationships. A fundamental concept of all programming is that objects can "belong" to other objects. They should be serialized, updated and deleted together. But that's all it is: a concept. In most programming languages, it is entirely up to you to enforce it. EMF/TMF actually make it *real*.

When I moved over to TypeScript, I missed it, and decided to build a port myself. The [github repo is here](https://github.com/tripsnek/tmf) and it is available as [an npm package here](https://www.npmjs.com/package/@tripsnek/tmf). The gist of how it works is this:

 1. ``npm install @tripsnek/tmf`` - one library handles everything

 2. Define your model as an .ecore file (most easily the with [VSCode extension](https://github.com/tripsnek/tmf-ecore-editor) I am releasing concurrently - search "TMF Ecore Editor" on the extension marketplace)
 
 3. Generate your code, which includes all of the infrastructure that provides model introspection and enforcement of containment references (and also bi-directional references, which is another handy feature).
 
 4. Extend the 'impl' files as you see fit. You can use the exact same types across your entire stack, including for serialization.

An included class called TJson will do serialization for you, it's sort of like if JSON.stringify() did something useful. If you've ever wondered _why_ JSON.stringify() mostly doesn't work, it all comes down to containment! TypeScript classes (and Javascript more generall) don't know which references represent containment, so it can't know what the "shape" of the data is. It has to traverse every reference, which usually leads to a cycle and then....boom. Containment fixes that. Object graphs become coherent trees with clear boundaries.
 
This is the first release, but it is on reasonably solid footing. I have been using it for years as the basis of a real world full stack application ([tripsnek](https://tripsnek.com/), a site for building optimized travel itineraries). Additionally, it comes with:

 - The aforementioned [TMF Ecore Editor](https://github.com/tripsnek/tmf-ecore-editor) VSCode Extension available in the market place
 
 - A repository of [example full stack applications](https://github.com/tripsnek/tmf-examples) using Node, React, Angular and NX. 
 
The example applications are all identical, and are depicted in the video on the right hand side. They are *fully* reflective across the entire stack, giving a taste of what is possible with reflection. Not one line of code refers to any type in the generated model. Drop in any other TMF-defined model, and the entire stack will work.

I'm excited that other people can now use this. Everything mentioned is totally open source, MIT licensed. Feedback welcome and contributions welcome!

Initial release of TMF: Model-driven development for TypeScript