Meta-System

Meta-System is an extensible and modular no-code engine, built for everyone, free and open-source.

It aims to simplify software as a whole, freeing you, the developer, to work on what makes your software truly unique. It does so by being simple, capable, and extensible: Just give Meta-System (MSYS for short) a configuration file and watch as it builds http routes, databases, functions and voilà! Your system should be up and running!

Features

Build Anything! : Meta-System wasn't made for "a type" of software, meaning you can build anything you like!
Simple, Yet Extensible : Its modular design allows you for adding, creating and sharing Add-ons, expanding your possibilities as far as you need them.
Unopinionated : Meta-System doesn't make decisions for you, instead, it opens the path for you to focus only in what is necessary. Of course, however, you can extend it with your own opinions as you wish.
The Power of JSON : Your Meta-System is configured using human-readable, and machine-parseable JSON.
GUI for Configuring your System : (Coming Soon!) A graphical editor for your Meta-System configuration files, turning your JSON system into a beautiful set of cards and flows.

How To Use

Oversimplifying, It is actually as easy as:

Download Meta-System.
Configure your system's behavior.
Launch!

1. Downloading Meta-System

The Meta-System can be downloaded through NPM. If you have NodeJs installed you probably already have npm and it is a matter of installing with the command npm install -g meta-system

Note: If you don't have NodeJs and/or npm installed, more info on those can be found here.

2. Configuring your first system

For you to make Meta-System into your very own system, you'll need a configuration file. Here you can check in depth how to make Meta-System into your own software. If you're new around, though, here's a classic: FizzBuzz!

Let's get going:

Click to Show Example Config

{
  "name": "fizz-buzz HTTP Example",
  "version": "0.0.1",
  "envs": [],
  "businessOperations": [
    {
      "identifier": "isDivisibleBy",
      "input": {
        "number": { "type": "number", "required": true },
        "divisor": { "type": "number", "required": true }
      },
      "output": {
        "boolean": { "type": "boolean", "required": true }
      },
      "constants": [
        { "type": "boolean", "value": true, "name": "true" },
        { "type": "boolean", "value": true, "name": "false" },
        { "type": "number", "value": 0, "name": "zero" }
      ],
      "variables": [],
      "configuration": [
        {
          "key": 1,
          "dependencies": [
            { "origin": "input", "originPath": "number", "targetPath": "A" },
            { "origin": "input", "originPath": "divisor", "targetPath": "B" }
          ],
          "moduleName": "modulus",
          "moduleType": "internal"
        },
        {
          "key": 2,
          "dependencies": [
            { "origin": 1, "originPath": "result.result", "targetPath": "A" },
            { "origin": "constant", "originPath": "zero", "targetPath": "B" }
          ],
          "moduleName": "equalTo",
          "moduleType": "internal"
        },
        {
          "key": 0,
          "dependencies": [
            { "origin": 2, "originPath": "result.isEqual", "targetPath": "boolean" }
          ],
          "moduleName": "output",
          "moduleType": "output"
        }
      ]
    },
    {
      "identifier": "fizzBuzz",
      "input": {
        "number": { "type": "number", "required": true }
      },
      "output": {
        "text": { "type": "string", "required": true }
      },
      "constants": [
        { "type": "string", "value": "Fizz!", "name": "fizz" },
        { "type": "string", "value": "Buzz!", "name": "buzz" },
        { "type": "string", "value": "FizzBuzz!", "name": "fizzBuzz" },
        { "type": "number", "value": 3, "name": "fizzDivisor" },
        { "type": "number", "value": 5, "name": "buzzDivisor" }
      ],
      "variables": [],
      "configuration": [
        {
          "key": 2,
          "moduleName": "isDivisibleBy",
          "moduleType": "bop",
          "dependencies": [
            { "origin": "input", "originPath": "number", "targetPath": "number" },
            { "origin": "constants", "originPath": "fizzDivisor", "targetPath": "divisor" }
          ]
        },
        {
          "key": 3,
          "moduleName": "isDivisibleBy",
          "moduleType": "bop",
          "dependencies": [
            { "origin": "input", "originPath": "number", "targetPath": "number" },
            { "origin": "constants", "originPath": "buzzDivisor", "targetPath": "divisor" }
          ]
        },
        {
          "key": 4,
          "moduleName": "and",
          "moduleType": "internal",
          "dependencies": [
            { "origin": 2, "originPath": "result.boolean", "targetPath": "A" },
            { "origin": 3, "originPath": "result.boolean", "targetPath": "B" }
          ]
        },
        {
          "key": 6,
          "moduleName": "if",
          "moduleType": "internal",
          "dependencies": [
            { "origin": 3, "originPath": "result.boolean", "targetPath": "boolean" },
            { "origin": "constant", "originPath": "buzz", "targetPath": "ifTrue" },
            { "origin": "input", "originPath": "number", "targetPath": "ifFalse" }
          ]
        },
        {
          "key": 5,
          "moduleName": "if",
          "moduleType": "internal",
          "dependencies": [
            { "origin": 2, "originPath": "result.boolean", "targetPath": "boolean" },
            { "origin": "constant", "originPath": "fizz", "targetPath": "ifTrue" },
            { "origin": 6, "originPath": "result.outputValue", "targetPath": "ifFalse" }
          ]
        },
        {
          "key": 1,
          "moduleName": "if",
          "moduleType": "internal",
          "dependencies": [
            { "origin": 4, "originPath": "result.bothTrue", "targetPath": "boolean" },
            { "origin": "constant", "originPath": "fizzBuzz", "targetPath": "ifTrue" },
            { "origin": 5, "originPath": "result.outputValue", "targetPath": "ifFalse" }
          ]
        },
        {
          "key": 0,
          "dependencies": [
            { "origin": 1, "originPath": "result.outputValue", "targetPath": "text" }
          ],
          "moduleName": "output",
          "moduleType": "output"
        }
      ]
    }
  ],
  "schemas": [],
  "addons": [
    {
      "identifier": "http",
      "version": "4.0.0-rc5",
      "source": "http-meta-protocol",
      "collectStrategy": "npm",
      "configuration": {
        "port": 8080,
        "host": "0.0.0.0",
        "routes": [
          {
            "route": "/number/:value",
            "businessOperation": "fizzBuzz",
            "method": "GET",
            "inputMapConfiguration": [
              { "origin": "route", "originPath": "value", "targetPath": "number" }
            ],
            "resultMapConfiguration": {
              "statusCode": 200,
              "headers": [],
              "body": {
                "result": "text"
              }
            }
          }
        ]
      }
    }
  ]
}

Simply copy and paste the configuration above into a new text file and save it as example.json (you may change the name later, just make sure it is a .json). Now, that you have installed Meta-System and have a configuration ready to go, all there is to do is run Meta-System!

3. Launching Meta-System

You can launch instances of Meta-System using the CLI command meta-system run. To continue our example, try doing:

meta-system run path/to/file/example.json on Unix Systems;
meta-system run path\to\file\example.json on Windows;

You should be now seeing your configuration being validated, then brought to life by Meta-System, ready-to-go.

Let's quickly test it! With your Meta-System running, open a web-page and go to the address: http://localhost:8080/number/2

Now change the number after the last slash (/) to any other, and see the results! 🚀

Want to know more about this fizz-buzz example? How it is like it is? Lets head to it's tutorial page to know more!

Use-Cases

What people can build with MSYS? What is possible?

As an engine, Meta-System can be used to power any kind of software, as long as the target platform allows for running NodeJS or browser-based JavaScript. Also, because it is extensible, you're never limited to only what you have in the engine. The combination of these properties sets Meta-System as a versatile lightweight no-code tool for almost any task! Here's some inspirations:

A Backup Daemon : Configured to automatically run at startup, backs up a preconfigured set of files timely.
An authenticated API for accessing a DataSet : With access to a DataBase, it filters, orders and joins data for a front end application to display.
A Live Sync tool for a Collaborative Software : Used as the source of truth for an user interface to sync data live with peers using a protocol such as WebRTC.
A No-Code tool for Enterprise : You can use Addons to inject business entities and their actions into Meta-System, and allow for wiring their business rules from within MSYS

Getting in Touch & Contributing

Meta-System has many many moving parts for you to wrap your head around. For making learning and building easier, there's our discord server, where you can get help from the community, learn and master different configuration techniques, and also share your own creations.

That's also the place to go if you want to become a contributor and help develop Meta-System, or even getting help developing your own awesome Addon. All core contributors are active around there.

Disclaimers

Meta-System is completely Open-Source, following the GPL-3.0 License.
Currently Meta-System is at version 0.4, which means the API might receive breaking changes faster than you expect. However, The team will make conscious effort to only make such changes if there are tangible benefits in doing so.

Meta-System

Features​

How To Use​

1. Downloading Meta-System​

2. Configuring your first system​

3. Launching Meta-System​

Use-Cases​

Getting in Touch & Contributing​

Disclaimers​