goms

command module

v0.7.0 Latest Latest Go to latest Published: Jul 8, 2018 License: GPL-3.0 Imports: 13 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/artpar/goms

Links

Open Source Insights

README ¶

Daptin

A modern backend for application developers, designers and testers

Key Features • Getting Started

Download • Documentation • Community

Create entity and add item

Key Features

JSON APIs
- create, read, update, delete
GraphQL APIs
- work in progress
Client libraries for all platforms
Rich data types
Websocket support
Sub sites hosting
Oauth token and connections
Cloud storage sync
Action APIs and Relational data APIs
Validation and conformation support
Daptil will expose all APIs for easy use
Fully featured dashboard
- Responsive to desktop, mobile and table
Cross platform
- Windows, Mac and Linux ready.

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

Note: documentation is still a work in progress, please create a pull-request if you wish to contribute.

Installation

Setup and data

APIs

CRUD APIs
- Read, search, filter
- Create
- Update
- Delete
- Relations
- Execute
Action APIs
- Using actions
- Actions list
User APIs
- User registration/signup
- User login/signin
State tracking APIs
- State machines

Users

Auth & Auth

Asset and file storage

Cloud storage

Sub-sites

Creating a subsite

Client library


Ruby	Python	Javascript
Typescript	PHP	Dart
.NET	Java	iOS
Elixir	R	Perl

API spec RAML

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

RAML API documentatnon

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
    }
}

Web Dashboard

Sign up and Sign in Create entity and add item Generate random data to show tables

Use the following APIs

JSON based CRUD+eXecute APIs for all your entities
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.)