Daptin

Daptin is an open-source backend development framework to develop and deploy production-ready JSONAPI microservices. With Daptin you can design your data model and have a production ready JSON API online in minutes.

By following shared conventions, you can increase productivity, take advantage of generalized tooling, and focus on what matters: your application.

Daptin works as an interface between your users and your data.

• Easily consume the API on any device using a JSONAPI.org client

• Interact with users as guests or known users by using a JWT token

• Grant permission of data/actions to users based on ownership, groups and guests

• Build custom actions to expose custom APIs over your data apart from the usual CRUD APIs

• Sync with cloud storage services like gdrive, dropbox, b2, s3 and more

• Sync folders and expose these as static websites under separate sub-domain/sub-paths

• Connect with other services by directly connecting with any external API

• Database to easily evolves your data schema & migrates your database [Postgres/MySQL/SQLite]

• Flexible auth using the JWT-based authentication & permission system

• Works with all frontend frameworks like React, Vue.js, Angular, Android, iOS

• Very low memory requirement and horizontally scalable

• Can be deployed on a wide range of hardware arm5,arm6,arm7,arm64,mips,mips64,mips64le,mipsle (or build for your target using go)

Deploy and get started

Deployment preference	Getting started
Heroku
Docker	docker run -p 8080:8080 daptin/daptin
Kubernetes	Service & Deployment YAML
Local	go get github.com/daptin/daptin
Linux (386/amd64/arm5,6,7)	Download static linux builds
Windows	go get github.com/daptin/daptin
OS X	go get github.com/daptin/daptin
Load testing	Docker compose
Raspberry Pi	Linux arm 7 static build

Database persistence

Store data on MySQL, PostgreSQL for heavy use cases (thousands of users) or SQLite for light use cases (iot, embedded).

Client

API spec RAML

RAML spec is auto generated for each endpoint exposed. This can be use to generate further documentation and clients.

curl http://localhost/apispec.raml

{
    "data": [
        {
            "type": "tableName",
            "attributes": {
                "col1": "",
                "col2": "",
            },
            "id": "",
        }
    ],
    "included": [
        {
            "type": "tableName",
            "attributes": {},
            "id": "",
        },
        .
        .
    ],
    "links": {
        "current_page": 1,
        "from": 0,
        "last_page": 100,
        "per_page": 50,
        "to": 50,
        "total": 5000
    }
}

Querying

Pagination

Projection, Sort, Filter

Usage

Tables:
- TableName: todo
  Columns:
  - Name: title
    DataType: varchar(500)
    ColumnType: label
    IsIndexed: true
  - Name: completed
    DataType: int(1)
    ColumnType: truefalse
    DefaultValue: 'false'
  Validations:
  - ColumnName: title
    Tags: required
- TableName: project
  Columns:
  - Name: name
    DataType: varchar(200)
    ColumnType: name
    IsIndexed: true
Relations:
- Subject: todo
  Relation: has_one
  Object: project

Web Dashboard

Daptin will provide

• JSON based CRUD+eXecute APIs for all your entities

• Integrated authentication and authorization with user management

• Access control for data

• Extensible system with useful integrations (eg sync data updates to 3rd party api)

• Client libraries to consume JSON API seamlessly

• Sub site hosting (SSH) without the need to run separate server

• An events-actions-outcomes framework to extend system

• Data-as-objects (instead of just strings)

Compared to building JSON APIs directly, Daptin provides APIs that makes writing fast frontend apps simpler.

Why Daptin?

Daptin was to help build faster, more capable APIs over your data that worked across for all types of frontend.

While Daptin primarily targeted Web apps, the emergence of Android and iOS Apps as a rapidly growing target for developers demanded a different approach for building the backend. With developers classic use of traditional frameworks and bundling techniques, we struggle to invest enough time in the business and frontend demands for all sorts of Apps that provide consistent and predictable APIs which perform equally well on fast and slow load, across a diversity of platforms and devices.

Additionally, framework fragmentation had created a APIs development interoperability nightmare, where backend built for one purpose needs a lot of boilerplate and integration with the rest of the system, in a consistent way.

A component system around JSON APIs offered a solution to both problems, allowing more time available to be invested into frontend and business building, and targeting a standards-based JSON/Entity models that all frontends can use.

However, JSON APIs for data manipulation by themselves weren't enough. Building apps required a lot of custom actions, workflows, data integrity, event subscription, integration with external services that were previously locked up inside of traditional web frameworks. Daptin was built to pull these features out of traditional frameworks and bring them to the fast emerging JSON API standard in an automated way.

Getting started

• Deploy instance of Daptin on a server
• Upload JSON/YAML/TOML/HCL file which describe your entities (or use marketplace to get started)
• or upload XLS file to create entities and upload data
• Become Admin of the instance (until then its a open for access, that's why you were able to create an account)

Tech Goals

• Zero config start (sqlite db for fresh install, mysql/postgres is recommanded for serious use)
• A closely knit set of functionality which work together
• Completely configurable at runtime, can be run without any dev help
• Stateless(Horizontally scalable)
• Try to piggyback on used/known standards
• Runnable on all types on devices
• Cross platform app using qt (very long term goal. A responsive website for now.)

Road Map

• Normalised Db Design from JSON schema upload
• Json Api, with CRUD and Relationships
• OAuth Authentication, inbuilt jwt token generator (setups up secret itself)
• Authorization based on a slightly modified linux FS permission model
• Objects and action chains
• State tracking using state machine
• Native tag support for user defined entities
• Data connectors -> Incoming/Outgoing data
• Plugin system -> Grow the system according to your needs
• Native support for different data types (geo location/time/colors/measurements)
• Configurable intelligent Validation for data in the APIs
• Pages/Sub-sites -> Create a sub-site for a target audiance
• Define events all around the system
• Ability to define hooks on events from UI
• Data conversion/exchange/transformations
• Live editor for subsites - grapesjs
• Store connectors for storing big files/subsites - rclone
• Market place to allow plugins/extensions to be installed
• Online entity designer
• Excel to entity identification

Documentation

• Checkout the documentation for daptin

Tech stack