GitHub - syncliteio/SyncLite: SyncLite : Build Anything Sync Anywhere

pip install synclite            # Python — self-contained wheel, batteries included

npm install synclite            # Node.js — self-contained N-API package, batteries included

cargo add synclite-rs           # Rust — cdylib also embeddable from C/C++, Go, Node, Ruby, C#

<!-- Java / Maven -->
<dependency>
    <groupId>io.synclite</groupId>
    <artifactId>synclite</artifactId>
    <version>1.0.0</version>
</dependency>

// Java / Gradle
implementation 'io.synclite:synclite:1.0.0'

import synclite as sl

DB_PATH   = "sampledevice.db"
POSTGRES  = "postgresql://postgres:postgres@localhost:5432/syncdb"
DB        = "syncdb"
SCHEMA    = "syncschema"

# One call wires up the local logger, the segment shipper,
# and the embedded consolidator that drains into PostgreSQL.
sl.initialize(
    device_type="SQLITE",
    device_name="sampledevice",
    db_path=DB_PATH,
    destination=sl.DestinationOptions(
        dst_type="POSTGRES",
        dst_connection_string=POSTGRES,
        dst_database=DB,
        dst_schema=SCHEMA,
        dst_sync_mode="REPLICATION",
    ),
)

conn = sl.Connection.open(DB_PATH)
conn.execute("CREATE TABLE IF NOT EXISTS orders(id INTEGER PRIMARY KEY, item TEXT, qty INTEGER)")
conn.execute("INSERT INTO orders(id, item, qty) VALUES(?, ?, ?)", [1, "widget", 100])
conn.execute("INSERT INTO orders(id, item, qty) VALUES(?, ?, ?)", [2, "gadget",  50])
conn.commit()

conn.flush()                          # ensure pending writes are shipped before process exits
sl.await_sync(DB_PATH, 30.0)          # optional: block until PostgreSQL confirms apply
conn.close()

const { initialize, SqliteConnection, awaitSync } = require('synclite');

// One call wires up the local logger, the segment shipper,
// and the embedded consolidator that drains into PostgreSQL.
initialize({
  device_type: 'SQLITE',
  device_name: 'sampledevice',
  db_path: 'sampledevice.db',
  destination: {
    dst_type: 'POSTGRES',
    dst_connection_string: 'postgresql://postgres:postgres@localhost:5432/syncdb',
    dst_database: 'syncdb',
    dst_schema: 'syncschema',
    dst_sync_mode: 'REPLICATION',
  },
});

const conn = SqliteConnection.open('sampledevice.db');
conn.execute('CREATE TABLE IF NOT EXISTS orders(id INTEGER PRIMARY KEY, item TEXT, qty INTEGER)');
conn.execute('INSERT INTO orders(id, item, qty) VALUES(?, ?, ?)', [1, 'widget', 100]);
conn.execute('UPDATE orders SET qty = ? WHERE id = ?', [150, 1]);
conn.commit();

conn.flush();
awaitSync('sampledevice.db', 30);
conn.close();

<!-- Maven -->
<dependency>
    <groupId>io.synclite</groupId>
    <artifactId>synclite</artifactId>
    <version>1.0.0</version>
</dependency>

import io.synclite.*;
import java.nio.file.Path;
import java.sql.*;
import java.time.Duration;

private static final Path   DB_PATH        = Path.of("sampledevice.db");
private static final String DEVICE_NAME    = "sampledevice";
private static final String POSTGRES_URL   =
        "jdbc:postgresql://localhost:5432/syncdb?user=postgres&password=postgres";
private static final String POSTGRES_DB     = "syncdb";
private static final String POSTGRES_SCHEMA = "syncschema";

// One call wires up the local logger, the segment shipper,
// and the embedded consolidator that drains into PostgreSQL.
SQLite.initialize(DB_PATH, DEVICE_NAME,
    DestinationOptions.builder()
        .dstType(DstType.POSTGRES)
        .connectionString(POSTGRES_URL)
        .database(POSTGRES_DB).schema(POSTGRES_SCHEMA)
        .syncMode(DstSyncMode.REPLICATION)
        .build());

try (Connection conn = DriverManager.getConnection(
        "jdbc:synclite_sqlite:" + DB_PATH);
     Statement s = conn.createStatement()) {
    s.execute("CREATE TABLE IF NOT EXISTS orders(id INTEGER PRIMARY KEY, item TEXT, qty INTEGER)");
    s.execute("INSERT INTO orders VALUES(1, 'widget', 100)");
    s.execute("INSERT INTO orders VALUES(2, 'gadget',  50)");
}

SyncLite.awaitSync(DB_PATH, Duration.ofSeconds(30)); // optional: block until PostgreSQL confirms apply
SQLite.closeDevice(DB_PATH);

use synclite::rusqlite::Connection;
use synclite::{DestinationOptions, DeviceType, DstSyncMode, DstType, Result,
               SyncLiteOptions, Value};

const DB_PATH:     &str = "sampledevice.db";
const DEVICE_NAME: &str = "sampledevice";
const POSTGRES:    &str = "postgresql://postgres:postgres@localhost:5432/syncdb";
const DB:          &str = "syncdb";
const SCHEMA:      &str = "syncschema";

// One call wires up the local logger, the segment shipper,
// and the embedded consolidator that drains into PostgreSQL.
synclite::initialize(
    DeviceType::SQLITE,
    DEVICE_NAME,
    DB_PATH,
    Some(DestinationOptions {
        dst_type: DstType::Postgres,
        dst_connection_string: POSTGRES.into(),
        dst_database: Some(DB.into()),
        dst_schema: Some(SCHEMA.into()),
        dst_sync_mode: DstSyncMode::Replication,
    }),
    SyncLiteOptions::default(),
)?;

let mut conn = Connection::open(DB_PATH)?;
conn.execute("CREATE TABLE IF NOT EXISTS orders(id INTEGER PRIMARY KEY, item TEXT, qty INTEGER)", &[])?;
conn.execute("INSERT INTO orders(id, item, qty) VALUES(?, ?, ?)",
    &[Value::Int(1), Value::Text("widget".into()), Value::Int(100)])?;
conn.execute("INSERT INTO orders(id, item, qty) VALUES(?, ?, ?)",
    &[Value::Int(2), Value::Text("gadget".into()),  Value::Int(50)])?;

conn.flush()?;  // ensure pending writes are shipped before process exits
synclite::await_sync(DB_PATH, std::time::Duration::from_secs(30))?; // optional: block until PG confirms
conn.close()?;

cd bin/
./deploy.sh      # or deploy.bat on Windows   (downloads Tomcat + JDK, deploys all WARs)
./start.sh       # or start.bat on Windows    (starts Tomcat + every SyncLite app)

cd bin/
./docker-deploy.sh     # Builds synclite-platform image (+ optional SFTP/MinIO + PostgreSQL/MySQL)
./docker-start.sh      # Starts synclite-platform container and optional helpers
./docker-stop.sh       # Stops synclite-platform container and optional helpers

git clone --recurse-submodules https://github.com/syncliteio/SyncLite.git SyncLite
cd SyncLite

# 1. Full platform (default)
mvn -Drevision=1.0.0 clean install

# 2. Full platform, Java-only (no Rust toolchain required)
mvn -Drevision=1.0.0 -DskipNonJavaLoggers=true clean install

# 3. Runtime only — slim embeddable zip
mvn -Drevision=1.0.0 -DruntimeOnly=true clean install

# Fastest build on a host without zig
mvn -Drevision=1.0.0 -DruntimeOnly=true -DskipRustCrossCompile=true -DskipTests clean install

cargo install cargo-zigbuild
rustup target add x86_64-unknown-linux-gnu aarch64-unknown-linux-gnu
# zig must be on PATH — download from https://ziglang.org/download/

synclite-runtime-1.0.0/
+-- lib/
|   +-- java/
|   |   +-- synclite-<version>.jar              # Add to your app classpath
|   |   +-- synclite.conf                       # Default logger configuration
|   +-- native/                                 # Multi-arch native cdylibs (Rust runtime)
|   |   +-- include/                            # C / C++ ABI headers (synclite.h, synclite.hpp)
|   |   +-- synclite_<version>.dll                    # Windows host build
|   |   +-- synclite_<version>.dll.lib                # Windows import library
|   |   +-- synclite_<version>.lib                    # Windows static library
|   |   +-- libsynclite_<version>_linux_x86_64.so     # cross-compiled
|   |   +-- libsynclite_<version>_linux_aarch64.so    # cross-compiled
|   |   +-- libsynclite_<version>.dylib               # only if built on macOS
|   |   +-- synclite.conf
|   +-- python/
|   |   +-- synclite-<version>-cp38-abi3-win_amd64.whl
|   |   +-- synclite-<version>-cp38-abi3-manylinux_2_28_x86_64.whl
|   |   +-- synclite-<version>-cp38-abi3-manylinux_2_28_aarch64.whl
|   +-- rust/
|       +-- synclite-source/                    # Self-contained Cargo workspace
+-- sample-apps/                                # One sample per language
|   +-- cpp/                                    # CMake-based, links lib/native
|   +-- java/                                   # javac + lib/java/synclite-<version>.jar
|   +-- python/                                 # pip install lib/python/*.whl
|   +-- rust/                                   # cargo run, path-deps into lib/rust
+-- LICENSE
+-- synclite_platform_version.txt

synclite-platform-1.0.0/
+-- bin/
|   +-- deploy.sh / deploy.bat        # One-command setup: downloads Tomcat + JDK, deploys WARs
|   +-- start.sh / start.bat          # Start Tomcat + all SyncLite apps
|   +-- stop.sh / stop.bat            # Graceful shutdown
|   +-- docker-deploy.sh / docker-start.sh / docker-stop.sh
|   +-- stage/sftp/ stage/minio/      # Docker scripts for staging servers
|   +-- dst/postgresql/ dst/mysql/    # Docker scripts for destination DBs
+-- lib/                              # Same as runtime-only zip above
+-- tools/
|   +-- synclite-client/  synclite-db/  synclite-dbreader/
|   +-- synclite-qreader/ synclite-jobmonitor/ synclite-validator/
|   +-- synclite-sample-app/
+-- sample-apps/                      # cpp / java / python / rust

import io.synclite.*;
import java.nio.file.Path;
import java.sql.*;

Path dbDir  = Path.of(System.getProperty("user.home"), "synclite", "db");
Path dbPath = dbDir.resolve("myapp.db");
Path conf   = dbDir.resolve("synclite.conf");

Class.forName("io.synclite.SQLite");
SQLite.initialize(dbPath, conf);

try (Connection c = DriverManager.getConnection("jdbc:synclite_sqlite:" + dbPath);
     Statement  s = c.createStatement()) {
    s.execute("CREATE TABLE IF NOT EXISTS orders(id INT, item TEXT, qty INT)");
    s.execute("INSERT INTO orders VALUES(1, 'widget', 100)");
    // ↑ captured in a log file and shipped to staging storage automatically
}
SQLite.closeAll();

import io.synclite.SQLiteStore;
import io.synclite.SyncLiteStore;

Class.forName("io.synclite.SQLiteStore");
SQLiteStore.initialize(dbPath, conf);

try (SyncLiteStore store = SQLiteStore.open(dbPath)) {
    store.createTable("orders", new LinkedHashMap<>(Map.of(
        "id",  "INTEGER PRIMARY KEY",
        "item", "TEXT",
        "qty",  "INTEGER"
    )));
    store.insert("orders", Map.of("id", 1, "item", "widget", "qty", 100));
    store.update("orders", Map.of("qty", 150), Map.of("id", 1));
    store.delete("orders", Map.of("id", 1));
    List<Map<String, Object>> rows = store.selectAll("orders");
}
SQLiteStore.closeDevice(dbPath);

import io.synclite.Streaming;
import io.synclite.SyncLiteStream;

Class.forName("io.synclite.Streaming");
Streaming.initialize(dbPath, conf);

try (SyncLiteStream stream = SyncLiteStream.open(dbPath)) {
    stream.createTable("events", new LinkedHashMap<>(Map.of(
        "ts",         "BIGINT",
        "event_type", "TEXT",
        "user_id",    "TEXT"
    )));
    stream.insert("events", Map.of("ts", System.currentTimeMillis(), "event_type", "SIGNUP", "user_id", "u1"));
    stream.insertBatch("events", List.of(
        Map.of("ts", System.currentTimeMillis(), "event_type", "VIEW",     "user_id", "u2", "source", "web"),
        Map.of("ts", System.currentTimeMillis(), "event_type", "PURCHASE", "user_id", "u3", "source", "app")
    ));
}

import io.synclite.Jedis;

// Managed mode — Jedis handles SQLiteStore initialise / open / close
try (Jedis jedis = Jedis.builder(dbPath, conf, "cache-device")
        .host("localhost").port(6379).build()) {
    jedis.set("user:1:name", "Alice");
    jedis.hset("session:42", Map.of("token", "abc123", "status", "active"));
    jedis.rpush("queue", "job-1", "job-2");
    jedis.sadd("tags", "etl", "cdc");
    jedis.zadd("leaderboard", Map.of("Alice", 100.0, "Bob", 200.0));
    jedis.del("tmp");
}

# Python client (plain HTTP — no SDK needed)
import requests, json

BASE = "http://localhost:5555/synclite"

requests.post(BASE, json={"db-type": "SQLITE", "db-name": "myapp",
    "synclite-logger-options": {"local-data-stage-directory": "/tmp/stage"},
    "sql": "initialize"})

requests.post(BASE, json={"db-name": "myapp",
    "sql": "CREATE TABLE IF NOT EXISTS t1(a INT, b TEXT)"})

requests.post(BASE, json={"db-name": "myapp",
    "sql": "INSERT INTO t1 VALUES(?, ?)", "arguments": [[1, "hello"], [2, "world"]]})

// Go client (plain HTTP — no SDK needed)
package main

import (
        "bytes"
        "net/http"
)

func postJSON(url string, body string) error {
        _, err := http.Post(url, "application/json", bytes.NewBufferString(body))
        return err
}

func main() {
        base := "http://localhost:5555/synclite"
        _ = postJSON(base, `{"db-type":"SQLITE","db-name":"myapp","synclite-logger-options":{"local-data-stage-directory":"/tmp/stage"},"sql":"initialize"}`)
        _ = postJSON(base, `{"db-name":"myapp","sql":"CREATE TABLE IF NOT EXISTS t1(a INT, b TEXT)"}`)
        _ = postJSON(base, `{"db-name":"myapp","sql":"INSERT INTO t1 VALUES(?, ?)","arguments":[[1,"hello"],[2,"world"]]}`)
}

// Node.js client (plain HTTP — no SDK needed)
const BASE = "http://localhost:5555/synclite";

async function post(body) {
    await fetch(BASE, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(body),
    });
}

await post({
    "db-type": "SQLITE",
    "db-name": "myapp",
    "synclite-logger-options": { "local-data-stage-directory": "/tmp/stage" },
    sql: "initialize",
});

await post({
    "db-name": "myapp",
    sql: "CREATE TABLE IF NOT EXISTS t1(a INT, b TEXT)",
});

await post({
    "db-name": "myapp",
    sql: "INSERT INTO t1 VALUES(?, ?)",
    arguments: [[1, "hello"], [2, "world"]],
});

bin/stage/sftp/docker-deploy.sh    # SFTP server
bin/stage/minio/docker-deploy.sh   # MinIO object storage