Schematize Features

UML

Schematize utilizes UML (the Unified Modeling Language) at it's core which makes Schematize one of the coolest and feature-rich BaaS providers you'll ever meet.

What is UML?

UML is an international standard managed by OMG (the Object Management Group). UML has also been published by the International Organization for Standardization (ISO) and the International Electrotechnical Commission (IEC) as the ISO/IEC 19501 standard. (See ISO/IEC 19505-1:2012)

"The objective of UML is to provide system architects, software engineers, and software developers with tools for analysis, design, and implementation of software-based systems as well as for modeling business and similar processes."

- UML 2.5.1 Specification Section 1

In short, UML is a modeling language standard for describing a system.

Why does Schematize use UML?

Anyone that wants to be successful in building an app must start with a solid architecture.

There are many different software/application development processes and methodologies (See Software Development Process and Software Development Life Cycle for an example of a few), but every one of them begins with a "Plan" or "Design" phase before getting into the "Build" phase.

In other words, a successful app should be planned out and designed before being built. Would you start building a house without blueprints? Of course not. For this same reason, Schematize encourages solid architecture by starting first with designing, planning, and modeling your "Schema" using UML.

UML Class Diagrams

The primary way that you design, plan, and model your "Schema" in Schematize is by using UML Class Diagrams.

Schematize provides you with a powerful UML Class Diagram UI for visualizing, documenting, and sharing your "model" with engineers, developers, stakeholders, and partners who want to integrate with your app.

Are you paying for a UML Diagramming software solution? Good news! You may not need one anymore.

Benefits

When you build your app on Schematize, you can feel confident you are building on top of international industry standards.
Schematize allows you vizualize your entire backend data in one diagram
Automatic documenation of your backend in one visual
The definition of your model is managed and stored in one place
You can download your "schema" (or "model"/"package") as JSON, which potentially could be used for many other reasons:
- Dynamically generate your own libraries to integrate with your app
- Dynamically generate your own documentation
You can download your "schema" (or "model"/"package") as XMI (XML Metadata Interchange). This might be useful if you want to:
- Import into another UML-based editor for further editing or printing

Don't like UML?

No problem! We also give you the Schematize table editor an alternative to the UML Class Diagram editor, with others editors coming soon.

Relational + Object-Oriented Database

One of the most impressive features of Schematize is it's database. We classify the database to be both a "Relational" and an "Object-Oriented" database which means you get all of the benefits of relational databases, all of the benefits of object-oriented databases, plus a slough of other features that we've added.

What is a Relational Database?

Relational Databases are probably the most popular and reliable type of databases that exist today. Relational databases store data in databases, tables, and columns and use keys and indexes to retrieve rows. They are ACID (Atomicity, Consistency, Isolation, Durability) compliant and are highly scalable.

What is an Object-Oriented Database?

Object-oriented Datbases are based on object-oriented pinciples. Generally you retrieve "objects" instead of rows and are able to benefit from Object-oriented principles like Inheritance, Abstraction, Polymorphism, and Encapsulation.

How is Schematize a Relational and an Object-oriented Database?

Schematize uses AWS Aurora MySQL under the hood. So, you get the benefits that come from a highly performant, highly available, highly scalable database.

But on top of MySQL is a built-in layer of abstraction that makes it possible to take advantage of Object-oriented patterns and principles. Here are just a few of the most prominent examples:

Inheritance

You can easily designate one "Class" or "Interface" to inherit from another. Under the hood, tables and columns are uniquely created so that in essense the one table "extends" or "inherits from" the other. Take the example of a model that has a "Dog" class that inherits from an "Animal" class. Assuming the "Animal" class has a "color" property, the "Dog" class would inherit the "color" property as well. What this means is that when you query instances of the "Dog" class, you can fetch or filtre on the "color" column along with any other "Dog" specific properties.

Multiple Inheritance

That's right, Schematize allows multiple-inheritance and handles appropriate table/column creation allowing your "Dog" class to "extend" from "Quadruped" abstract class as well as the "Animal" class.

Abstraction

You can achieve abstraction in Schematize by defining your model in terms of "Interfaces" or "Abstract Classes". Keeping our same example, we may want to define an interface called "Omnivorous" that defines a few required properties and methods. If "Dog" implements the "Omnivorous" interface, it would be defined with the same properties/columns necessary to make it truly "Omnivorous".

Polymorphism

Schematize support polymorphism in a few forms. First, let's introduce a "Lion" class which inherits from "Animal". If we also create an association from "Animal" to "Habitat" through "Habitat"s list property "inhabitants", both "Dog" and "Lion" can now be used as instances in the "inhabitants" list. Second, if the "Animal" class requires a method "eat()", both "Dog" and "Lion" have the opportunity to "override" the default "eat()" method. At this time, we have not implemented method "overloading" yet, but again have the capacity to do so because of our reliance on UML as a base.

Encapsulation

Schematize in it's current form doesn't allow for any private members...yet. however, being built on top of UML, Schematize can easily accomodate encapsulation.

Associations/References

Although not part of the "4 pillars" of OOP, references are integral to how object-oriented programming works. Schematize recognizes this and makes enabling associations and navigating bi-directional references easy.

Operations/Methods

Yes, Schematize even supports methods! UML calls these "Operations". The implementation of this feature is still in it's infancy, but yes, you can define instance methods in the langauges available and they become available to use in the libraries that are automatically assembled.

Why not just use an ORM tool/solution?

ORMs (Object-relational mappings) have have filled a gap. ORMs really are amazing! Schematize in fact is inspired and patterned after ORMs in many ways. But, there are still limitations to many ORMs out there.

You may have heard of the term "object-relational impedance mismatch" when it comes to traditional ORMs (See https://en.m.wikipedia.org/wiki/Object%E2%80%93relational_impedance_mismatch ).

Schematize solves many of these issues in a unique way allowing for you to treat your database like you are using an Object-oriented language. And it does better than other ORMs out there. Take a few of the examples above. Does your ORM support inhertance? interfaces? abstract classes? associations/references? how about instance methods?

Why not NoSQL, Key/Value, or Document Databases?

Don't get us wrong, there is a place for these types of databases. But, one of the things that they lack are the ability to easily, quickly, and efficiently maintain bi-directional references. Joins and/or query related references can be performed, but less efficiently or flexibly. Also, advancing your model or adding features to your app by changing one of these types of databases can become extremely difficult.

Real-time Migrations

One of the biggest pains of other databases, platforms, or solutions is the pain of managing migrations. Let's say you are ready to add a new feature to your app that requires adding a new class/table or even modifying exting classes/tables. What tables do you need to migrate? What columns do you need to change? What about updating the existing data already stored?

Schematize helps you with this process by allowing you to define functions for moving data forward and even backward. Not only this, but it allows you to maintain multiple versions of your model at the same so that older clients, app versions, or scripts can still use the older model and API until they are ready to go live with the new models. We call this "forking" a model. While this functionality is still in alpha, we are getting very close to making this an available feature for anyone to use.

Benefits

Benfits of Relational Databases

Reliable
ACID Compliant
SQL Compatible

Benfits of Object-oriented Databases

Inheritance
Multiple Inheritance
Abstraction
Encapsulation
Polymorphism
Associations/References
Operations/Methods

Benfits of AWS Aurora MySQL

Highly Performant
Highly Available
Highly Scalable

Additional Schematize Features

Easily, quickly, and efficiently advance your model or add features to your app.
Automatic indexes
Ability to create composite keys/identifiers for your tables

APIs

Schematize automatically makes APIs available to you and others who want to integrate with your app without any additional configuration on your part.

CRUD (Create, Read, Update, and Delete) APIs

Schematize automatically provides you with multiple APIs without you needing to configure a single thing. This includes but is not limited to:

APIs to create an instance of a Class and persist it to the database
APIs to list instances of a Class, Abstract Class, or Interface (following OOP principles)
APIs to read a single instance of a Class, Abstract Class, or Interface by its identifier(s)
APIs to read an instances related references (again following OOP principles)
APIs to update a single instance of a Class
APIs to delete a single instance of a Class

What APIs does Schematize provide?

We don't believe that you should need to choose one API over another. Each API has it's own strengths and weakensses in different situations. For this reason, as soon as you save your model to the database, API makes these APIs immediately available to you:

JSON:API

JSON:API is a specification for REST-based APIs. It makes the tasks of deciding endpoint names, versioning, data structure, error or status codes, etc. a breeze by establish a set of conventions to follow. Schematize provides you an implementation of JSON:API out of the box.

GraphQL (Coming soon)

GraphQL is a query language for your API. It allows clients to request only the necessary data and is powerful for navigating relationship.

OpenAPI (Coming soon)

OpenAPI is another REST-based API specification.

Automatic Documentation

In addition to automatically creating the APIs, Schematize will also create documentation for you so that you don't have to. This isn't just any generic documentation. This is documentation for your specific model, including documentation for classes, interfaces, properties, associated references, etc.

You may choose to use this documentation to share with others who may want to know how to call your APIs or integrate with your app.

Benefits

Automatic APIs without any additional configuration
Built on API best practices and standards
jsonapi, a REST-based API
GraphQL (coming soon)
OpenAPI (coming soon)
CRUD APIs
Automatic documentation of APIs

Libraries

Schematize not only gives you automatic APIs, but it also makes available custom libraries specific to your model for easy integration into your web app, mobile app, game, service, or script.

What languages do you support?

At this point, we support a small handful of libraries, but plan to make many others avaialble soon.

Javascript

We provide two javascript libraries currently that vary in their features and size. Both can be loaded into either web apps or into nodejs scripts or apps. The javascript libraries are the most advanced and have the most features at this point.

TypeScript

We also provide a TypeScript library that has less features, but allow you to use the script directly in a deno runtime or in your TypeScript codebase.

Python

We also provide a Python library that also has less features for easy integration into your python scripting environment. You may choose to use this library in pulling data for analysis or AI models.

Java (Coming soon)

PHP (Coming soon)

Ruby (Coming soon)

Swift (Coming soon)

(and many more...)

What features do the libraries have?

Each of the libraries have varying levels of features. At this point the javascript libraries are most mature. Here are a few examples of features that these libraries use:

CRUD functionality for instantiating new instances, updating instances, or destroying instances and freeing memory
".find()" convenience method on Classes, Abstract Classes, or Interfaces for retrieving instances from APIs
".save()" convenience method for sending changes to APIs
".delete()" convenience method for calling the delete API
EventTarget interface implementation for listening to changes to instances
Automatic linking of references by identifiers
Automatic bi-directional references when setting one side of association
Lazy loading of references or related instances from API
Ability to extend or hook into functionality of library
Extremely performant and relatively small code footprint

Automatic Documentation

In addition to making custom libraries available to your for download and integration into your app, Schematize will also create documentation for the libraries. This isn't just any generic documentation. This is documentation for your specific model, including documentation for classes, interfaces, properties, associated references, etc.

You may choose to use this documentation to share with others who may want to know how to use your custom libraries or integrate with your app.

Benefits

Automatic creation of libraries for easy integration into your app
Multiple libraries for your specific platform or app (javascript, typescript, python, and many more coming soon)
Automatic documentation of APIs

Auth

Schematize recognizes the need to secure your model, data, apis, etc. and that you will need a way to authenticate and authorize users and integrations to your protected resources. For this reason Schematize enables you to implement OAuth 2.0, OpenID Connect, and many other industry standards in your model and then extend or modify it to your needs.

How does Auth work in Schematize?

Schematize takes a unique approach to Auth.

First, Schematize doesn't require that your model be protected. If you want your model to be open, you can make it open. This might be beneficial for Analytics use cases or for getting a prototype up and running quickly.

Second, if you do want to secure your model, Schematize gives you an automatically created template of Auth elements in your model alongside everything else you already have. In other words, it gives you a fully functional Auth model and framework as a starting point but also allows you to customize it to your own needs, connect it to other elements in your model, or extend it.

What Auth standards does Schematize provide?

When you implement Auth in your model, you automatically get the following:

OAuth 2.0

The OAuth 2.0 Authorization Framework
The OAuth 2.0 Authorization Framework: Bearer Token Usage
OAuth 2.0 Threat Model and Security Considerations (Coming soon)
OAuth 2.0 Token Revocation (Coming soon)
Hypertext Transfer Protocol (HTTP/1.1): Authentication - Partially Implemented
JSON Web Signature (JWS) - Partially Implemented
JSON Web Key (JWK) - Partially Implemented
JSON Web Algorithms (JWA) (Coming soon)
JSON Web Token (JWT)
Assertion Framework for OAuth 2.0 Client Authentication and Authorization Grants (Coming soon)
Security Assertion Markup Language (SAML) 2.0 Profile for OAuth 2.0 Client Authentication and Authorization Grants (Coming soon)
JSON Web Token (JWT) Profile for OAuth 2.0 Client Authentication and Authorization Grants (Coming soon)
OAuth 2.0 Dynamic Client Registration Protocol (Coming soon)
OAuth 2.0 Dynamic Client Registration Management Protocol (Coming soon)
Proof Key for Code Exchange by OAuth Public Clients (PKCE)
OAuth 2.0 Token Introspection - Partial Support
OAuth 2.0 Authorization Server Metadata
OAuth 2.0 Device Authorization Grant (Coming soon)
OAuth 2.0 Token Exchange (Coming soon)
Resource Indicators for OAuth 2.0 (Coming soon)
JSON Web Token Best Current Practices (Coming soon)
JSON Web Token (JWT) Profile for OAuth 2.0 Access Tokens

OpenID Connect

OpenID Connect Core 1.0 - Mostly Implementated
OpenID Connect Discovery 1.0 - Partially Implemented
OpenID Connect Dynamic Client Registration 1.0 (Coming soon)
OAuth 2.0 Multiple Response Type Encoding Practices (Coming soon)
OAuth 2.0 Form Post Response Mode (Coming soon)

Additional Features

Sign In page
Sign Up page
Verify Email
Verify Phone (Coming soon)
Forgot Password
Reset Password
OAuth Client Registration
Access Control and Fine grained CRUD permissions to:

all instances in the entire package
all Instances of a Class
individual instances (row-level security)

User Management
User Groups
Account Management and Advanced User profiles (Coming soon)
MFA (Multi-factor Authentication) (Coming soon)
Captcha and bot detection (Coming soon)
Magic link sign in (Coming soon)
Biometric sign in (Coming soon)
OTP integration (Coming soon)
Custom password policies (Coming soon)
Maximum Password attempts (Coming soon)
Remember me (Coming soon)
Stay signed in (Coming soon)
SSO (Single Sign-on) (Coming soon)
Social Providers (Sign in with Github, Apple, Facebook, Google, etc.) (Coming soon)
Enterprise Functionality:

SAML (Security Access Markup Language) (Coming soon)
Azure (Coming soon)
Active Directory (Coming soon)
etc.

Can I use my own Auth?

Yes! We understand that you may already have a system that you use and trust for your Auth requirements.

Each Schematize model has the ability to specify your own "hasAccess" function that allows you to call your own "OAuth 2.0 introspection endpoint" or query whether the user who is requesting access should be allowed to call the api or server function.

Benefits

Ability to make your model open
A heavily integrated Auth framework with your current model
Ability to customize, connect, or extend Auth
A myriad of standards already implemented for you out of the box (Oauth 2.0, OpenID Connect, etc.)
Ability to use and integrate your own Auth system

Serverless Functions

Schematize also recognizes that you may need to customize your model, your APIs, or your backend even further. So, Schematize allows you to build your own serverless functions that you can reach from the public internet.

What languages do you support?

At this point, we support a small handful of libraries, but plan to make many others avaialble soon.

Javascript

At this point, we only support serverless functions built in javascript, specifically a variation of nodejs that runs in an isolated environment.

(we plan on supporting many more in the future...)

Benefits

Customize your model, your APIs, or add functionality to your backend
In-browser Monaco Editor
Specify your own friendly endpoint paths for your serverless functions
Publicly available endpoints
Database hooks (Coming soon)