The Sync Layer
Your App Has Been Missing

// SyncLiteStore — typed CRUD without raw SQL, schema evolution built-in
Class.forName("io.synclite.logger.SQLiteStore");
SQLiteStore.initialize(dbPath, conf);

try (SyncLiteStore store = SQLiteStore.open(dbPath)) {

    store.createTable("players", new LinkedHashMap<>(Map.of(
        "id", "INTEGER PRIMARY KEY", "name", "TEXT", "score", "INTEGER"
    )));

    store.insert("players", Map.of("id", 1, "name", "Alice", "score", 100));
    store.update("players", Map.of("score", 250), Map.of("name", "Alice"));
    store.delete("players", Map.of("id", 1));

    List<Map<String,Object>> rows = store.selectAll("players");
}
SQLiteStore.closeDevice(dbPath);

// SyncLiteStream — fluent append-only event ingestion
Class.forName("io.synclite.logger.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"
    ));

    // New columns added inline — schema evolves automatically
    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")
    ));
}

# SyncLite DBReader — job configuration file (not application code)
# Table/topic mappings are configured via the web UI at http://localhost:8080/synclite-dbreader

synclite-device-dir = /opt/synclite/devices
synclite-logger-configuration-file = /opt/synclite/synclite_logger.conf

src-type = POSTGRESQL
src-connection-string = jdbc:postgresql://pg.internal:5432/sales
src-user = reader
src-password = secret
src-connection-timeout-s = 30

src-dbreader-method = INCREMENTAL
src-dbreader-interval-s = 10
src-dbreader-batch-size = 100000

src-object-type = TABLE
src-default-unique-key-column-list = id
src-default-incremental-key-column-list = updated_at
src-infer-schema-changes = true

# DBReader handles batching, retries, checkpoints, and restarts.

# SyncLite QReader — job configuration file (not application code)
# Topic-to-table mappings are configured via the web UI at http://localhost:8080/synclite-qreader

synclite-device-dir = /opt/synclite/devices
synclite-logger-configuration-file = /opt/synclite/synclite_logger.conf

mqtt-broker-url = tcp://mqtt.example.com:1883
mqtt-qos-level = 1
mqtt-clean-session = true
mqtt-broker-connection-timeout-s = 10
mqtt-broker-connection-retry-interval-s = 2

src-message-format = CSV
src-message-field-delimiter = ,

qreader-synclite-device-type = SQLITE_APPENDER
qreader-map-devices-to-single-synclite-device = true
qreader-default-synclite-device-name = iot_device
qreader-default-synclite-table-name = iot_events

# Works with Mosquitto, EMQX, AWS IoT Core, and Azure IoT Hub.

# Python via JayDeBeApi — standard SQL, same JDBC driver
import jaydebeapi, jpype

jar = "/path/to/synclite-logger-<version>.jar"
jpype.startJVM(jpype.getDefaultJVMPath(), f"-Djava.class.path={jar}", convertStrings=True)

conn = jaydebeapi.connect(
    "io.synclite.logger.SQLite",
    "jdbc:synclite_sqlite:/home/alice/synclite/db/myapp.db",
    {"config": "/home/alice/synclite/synclite_logger.conf"},
    jar
)
cur = conn.cursor()
cur.execute("CREATE TABLE IF NOT EXISTS events(id INT, payload TEXT)")
cur.execute("INSERT INTO events VALUES(1, 'hello from Python')")

# SELECT — local read from the embedded database
cur.execute("SELECT id, payload FROM events WHERE id = 1")
for row in cur.fetchall(): print(row)

conn.commit()
conn.close()


# SyncLiteStore via JPype
from io.synclite.logger import SQLiteStore, SyncLiteStore
from java.nio.file import Paths
from java.util import LinkedHashMap

db = Paths.get("/home/alice/synclite/db/mystore.db")
SQLiteStore.initialize(db, Paths.get("synclite_logger.conf"))
with SyncLiteStore.open(db) as store:
    cols = LinkedHashMap()
    cols.put("id", "INTEGER PRIMARY KEY"); cols.put("name", "TEXT")
    store.createTable("users", cols)
    store.insert("users", {"id": 1, "name": "Alice"})
SQLiteStore.closeDevice(db)

# Any language — plain HTTP/JSON via SyncLite DB server
# Works with Python, Go, Rust, C#, C++, Ruby, Node.js…
import requests

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

# 1. Initialize
requests.post(BASE, json={
    "db-type": "SQLITE", "db-path": "/tmp/myapp.db",
    "synclite-logger-config": "/tmp/synclite_logger.conf", "sql": "initialize"
})

# 2. DDL
requests.post(BASE, json={"db-path": "/tmp/myapp.db",
    "sql": "CREATE TABLE IF NOT EXISTS orders(id INT, item TEXT)"})

# 3. Batched insert
requests.post(BASE, json={"db-path": "/tmp/myapp.db",
    "sql": "INSERT INTO orders VALUES(?, ?)",
    "arguments": [[1, "widget"], [2, "gadget"]]})

# 4. SELECT — local read from the embedded database
resp = requests.post(BASE, json={"db-path": "/tmp/myapp.db",
    "sql": "SELECT id, item FROM orders"})
print(resp.json())

// Jedis-compatible API for Redis-style commands on SyncLiteKV
try (SyncRedis redis = new SyncRedis("jdbc:synclite_sqlite:" + dbPath, conf)) {

  redis.set("session:u1", "active");
  redis.hset("profile:u1", "tier", "gold");
  redis.incrBy("counter:events", 1);

  String state = redis.get("session:u1");
}
// Commands are persisted locally and replicated through the standard SyncLite pipeline.

// Kafka Producer-compatible API backed by SyncLiteStream
Properties props = new Properties();
props.put("bootstrap.servers", "synclite://local");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

try (Producer<String, String> p = new KafkaProducer<>(props)) {
  p.send(new ProducerRecord<>("events", "u1", "signup"));
  p.send(new ProducerRecord<>("events", "u2", "purchase"));
}
// Same producer workflow, with SyncLite handling local durability and downstream replication.