Convert Figma logo to code with AI

atomicdata-dev logoatomic-server

An open source headless CMS / real-time database. Powerful table editor, full-text search, and SDKs for JS / React / Svelte.

1,104
50
1,104
321

Top Related Projects

Solid server on top of the file-system in NodeJS

1,138

Apache Jena, A free and open source Java framework for building Semantic Web and Linked Data applications.

Quick Overview

Atomic Server is an open-source, lightweight database and graph server with built-in authorization, versioning, and more. It aims to make data more interoperable and easier to work with by using Atomic Data, a modular specification for sharing, modifying and modeling typed data.

Pros

  • Built-in versioning, authorization, and validation
  • Supports multiple data formats (JSON, JSON-LD, RDF, Atomic Data)
  • Easy to set up and use with a single binary
  • Provides a user-friendly web interface for data management

Cons

  • Relatively new project, which may lack extensive community support
  • Limited ecosystem compared to more established database solutions
  • Learning curve for developers unfamiliar with Atomic Data concepts
  • May not be suitable for large-scale enterprise applications yet

Code Examples

Here are a few examples of using the Atomic Server API with Rust:

  1. Creating a new Resource:
use atomic_lib::Storelike;
use atomic_lib::agents::Agent;

let store = atomic_lib::Store::init().unwrap();
let agent = Agent::new_private();

let resource = store.create_resource(None, &agent).unwrap();
store.set_string(
    &resource,
    "https://atomicdata.dev/properties/shortname",
    "my-resource",
    &agent,
).unwrap();
  1. Querying Resources:
use atomic_lib::Storelike;

let store = atomic_lib::Store::init().unwrap();
let results = store.query(
    Some("https://atomicdata.dev/classes/Agent"),
    None,
    None,
    None,
).unwrap();

for resource in results {
    println!("Found agent: {}", resource.get_subject());
}
  1. Updating a Resource:
use atomic_lib::Storelike;
use atomic_lib::agents::Agent;

let store = atomic_lib::Store::init().unwrap();
let agent = Agent::new_private();

store.set_string(
    "https://example.com/resource",
    "https://atomicdata.dev/properties/description",
    "Updated description",
    &agent,
).unwrap();

Getting Started

To get started with Atomic Server, follow these steps:

  1. Install Atomic Server:

    cargo install atomic-server
    
  2. Run the server:

    atomic-server
    
  3. Open your browser and navigate to http://localhost:9883 to access the web interface.

  4. Use the API endpoints or the Rust client library to interact with the server programmatically.

Competitor Comparisons

Solid server on top of the file-system in NodeJS

Pros of node-solid-server

  • More mature project with a larger community and ecosystem
  • Better documentation and resources for developers
  • Implements the full Solid specification, providing a complete decentralized web solution

Cons of node-solid-server

  • Heavier and more complex implementation
  • Slower development cycle and potentially more challenging to contribute to
  • May have higher resource requirements for deployment

Code Comparison

node-solid-server:

const solid = require('solid-server')
const path = require('path')

solid
  .createServer({
    root: path.join(__dirname, '../data'),
    port: 8443
  })
  .listen(8443, () => {
    console.log('Solid server running on https://localhost:8443')
  })

atomic-server:

use atomic_server::Server;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let server = Server::init().await?;
    server.run().await
}

The node-solid-server example shows a more configuration-heavy setup, while atomic-server demonstrates a more concise initialization process. node-solid-server offers more out-of-the-box customization, whereas atomic-server prioritizes simplicity and ease of use.

1,138

Apache Jena, A free and open source Java framework for building Semantic Web and Linked Data applications.

Pros of Jena

  • Mature and well-established project with extensive documentation and community support
  • Comprehensive framework for building Semantic Web and Linked Data applications
  • Supports a wide range of RDF formats and SPARQL query language

Cons of Jena

  • Steeper learning curve due to its extensive feature set
  • Can be resource-intensive for large-scale data processing
  • Primarily Java-based, which may not be ideal for all development environments

Code Comparison

Atomic Server (Rust):

use atomic_lib::Db;

let db = Db::init("path/to/store").unwrap();
let subject = "https://example.com/resource";
let property = "https://example.com/name";
let value = "John Doe";
db.set_string(subject, property, value, None).unwrap();

Jena (Java):

import org.apache.jena.rdf.model.*;

Model model = ModelFactory.createDefaultModel();
Resource resource = model.createResource("https://example.com/resource");
Property property = model.createProperty("https://example.com/name");
resource.addProperty(property, "John Doe");

While both projects deal with RDF data, Atomic Server focuses on a more modern, lightweight approach using Rust, whereas Jena provides a comprehensive Java-based framework for Semantic Web applications. Atomic Server aims for simplicity and performance, while Jena offers a broader range of features and established standards support.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

AtomicServer

crates.io Discord chat MIT licensed github

Create, share, fetch and model Atomic Data! AtomicServer is a lightweight, yet powerful CMS / Graph Database. Demo on atomicdata.dev. Docs on docs.atomicdata.dev

This repo also includes:

Status: alpha. Breaking changes are expected until 1.0.

AtomicServer

  • 🚀 Fast (less than 1ms median response time on my laptop), powered by actix-web and sled
  • 🪶 Lightweight (8MB download, no runtime dependencies)
  • 💻 Runs everywhere (linux, windows, mac, arm)
  • 🔧 Custom data models: create your own classes, properties and schemas using the built-in Ontology Editor. All data is verified and the models are sharable using Atomic Schema
  • ⚙️ Restful API, with JSON-AD responses.
  • 🔎 Full-text search with fuzzy search and various operators, often <3ms responses. Powered by tantivy.
  • 🗄️ Tables, with strict schema validation, keyboard support, copy / paste support. Similar to Airtable.
  • 📄 Documents, collaborative, rich text, similar to Google Docs / Notion.
  • 💬 Group chat, performant and flexible message channels with attachments, search and replies.
  • 📂 File management: Upload, download and preview attachments.
  • 💾 Event-sourced versioning / history powered by Atomic Commits
  • 🔄 Real-time synchronization: instantly communicates state changes with a client. Build dynamic, collaborative apps using websockets (using a single one-liner in react or svelte).
  • 🧰 Many serialization options: to JSON, JSON-AD, and various Linked Data / RDF formats (RDF/XML, N-Triples / Turtle / JSON-LD).
  • 📖 Pagination, sorting and filtering queries using Atomic Collections.
  • 🔐 Authorization (read / write permissions) and Hierarchical structures powered by Atomic Hierarchy
  • 📲 Invite and sharing system with Atomic Invites
  • 🌐 Embedded server with support for HTTP / HTTPS / HTTP2.0 (TLS) and Built-in LetsEncrypt handshake.
  • 📚 Libraries: Javascript / Typescript, React, Svelte, Rust

https://user-images.githubusercontent.com/2183313/139728539-d69b899f-6f9b-44cb-a1b7-bbab68beac0c.mp4

Documentation

Check out the documentation for installation instructions, API docs, and more.

Contribute

Issues and PRs are welcome! And join our Discord! Read more in the Contributors guide.