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 — ETL/replication configuration (not application code)
job-name = orders_incremental
source-type = POSTGRESQL
source.host = pg.internal
source.port = 5432
source.database = sales
source.user = reader

table.1.source = public.orders
table.1.target = orders
table.1.mode = INCREMENTAL
table.1.watermark-column = updated_at

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

# SyncLite QReader — MQTT ingestion configuration (not application code)
job-name = iot_temperature_ingest
broker = tcp://mqtt.example.com:1883
client-id = synclite-qreader-01
subscription.1 = devices/+/telemetry
payload-format = JSON
target-table = iot_events

field.device_id = $.deviceId
field.temperature = $.temp
field.event_time = $.ts

# 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')")
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"]]})

// 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.