chore: bump to beta (#16)

Author: geofmureithi

…03d75403970fc8347d0f017f04d746b2b98.json …a7bdc9acef7704fe86466d28fc85126b8e3.json.sqlx/query-61843a18bffdee192cd01f1537f0f03d75403970fc8347d0f017f04d746b2b98.json renamed to .sqlx/query-eed1a436f9bad0f9ee6c46b47580fa7bdc9acef7704fe86466d28fc85126b8e3.json .sqlx/query-61843a18bffdee192cd01f1537f0f03d75403970fc8347d0f017f04d746b2b98.json renamed to .sqlx/query-eed1a436f9bad0f9ee6c46b47580fa7bdc9acef7704fe86466d28fc85126b8e3.json

@@ -10,8 +10,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- `apalis-board` support
 - Workflow support
+- Event driven listener
 
 ### Changed
 
 - Moved from monorepo
+
+
+
+Previous Document: https://github.com/apalis-dev/apalis/blob/main/CHANGELOG.md

CHANGELOG.md

@@ -1,6 +1,6 @@
 [package]
 name = "apalis-sqlite"
-version = "1.0.0-alpha.6"
+version = "1.0.0-beta.1"
 authors = ["Njuguna Mureithi <mureithinjuguna@gmail.com>"]
 readme = "README.md"
 edition = "2024"
@@ -11,7 +11,7 @@ keywords = ["apalis", "background-jobs", "task-queue", "sqlite", "async"]
 categories = ["asynchronous", "database"]
 
 [features]
-default = ["migrate", "json"]
+default = ["tokio-comp", "migrate", "json"]
 migrate = ["sqlx/migrate", "sqlx/macros"]
 async-std-comp = ["async-std", "sqlx/runtime-async-std-rustls"]
 async-std-comp-native-tls = ["async-std", "sqlx/runtime-async-std-native-tls"]
@@ -27,28 +27,44 @@ features = ["chrono", "sqlite"]
 [dependencies]
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1" }
-apalis-core = { version = "1.0.0-alpha.9", features = ["sleep"] }
-apalis-sql = { version = "1.0.0-alpha.9" }
+apalis-core = { version = "1.0.0-beta.1", features = ["sleep"] }
+apalis-sql = { version = "1.0.0-beta.1" }
 log = "0.4.21"
 futures = "0.3.30"
 tokio = { version = "1", features = ["rt", "net"], optional = true }
 async-std = { version = "1.13.0", optional = true }
 chrono = { version = "0.4", features = ["serde"] }
 thiserror = "2.0.0"
 pin-project = "1.1.10"
-libsqlite3-sys = "0.30.1"
 ulid = { version = "1", features = ["serde"] }
-bytes = "1.1.0"
 
 [dev-dependencies]
 tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
-apalis = { version = "1.0.0-alpha.9" }
-apalis-sqlite = { path = ".", features = ["migrate", "tokio-comp"] }
-apalis-workflow = { version = "0.1.0-alpha.6" }
-
+apalis = { version = "1.0.0-beta.1" }
+apalis-workflow = { version = "0.1.0-beta.1" }
 futures-util = "0.3.31"
 
 [package.metadata.docs.rs]
 # defines the configuration attribute `docsrs`
 rustdoc-args = ["--cfg", "docsrs"]
 all-features = true
+
+[lints.rust]
+unsafe_code = "forbid"
+rust_2018_idioms = { level = "warn", priority = -1 }
+missing_debug_implementations = "warn"
+unreachable_pub = "warn"
+
+[lints.clippy]
+type_complexity = "allow"
+manual_let_else = "warn"
+match_same_arms = "warn"
+match_wildcard_for_single_variants = "warn"
+mem_forget = "warn"
+must_use_candidate = "warn"
+needless_borrow = "warn"
+needless_continue = "warn"
+needless_pass_by_ref_mut = "warn"
+needless_pass_by_value = "warn"
+option_option = "warn"
+redundant_clone = "warn"

Cargo.toml

@@ -1,14 +1,14 @@
 # apalis-sqlite
 
-Background task processing for Rust using apalis and sqlite.
+Background task processing for Rust using `apalis` and `sqlite`.
 
 ## Features
 
 - **Reliable job queue** using SQLite as the backend.
 - **Multiple storage types**: standard polling and event-driven (hooked) storage.
 - **Custom codecs** for serializing/deserializing job arguments as bytes.
 - **Heartbeat and orphaned job re-enqueueing** for robust job processing.
-- **Integration with Apalis workers and middleware.**
+- **Integration with `apalis` workers and middleware.**
 
 ## Storage Types
 
@@ -23,11 +23,17 @@ The naming is designed to clearly indicate the storage mechanism and its capabil
 ### Basic Worker Example
 
 ```rust,no_run
+use std::time::Duration;
+
+use apalis::prelude::*;
+use apalis_sqlite::*;
+use futures::stream::{self, StreamExt};
+
 #[tokio::main]
 async fn main() {
     let pool = SqlitePool::connect(":memory:").await.unwrap();
     SqliteStorage::setup(&pool).await.unwrap();
-    let mut backend = SqliteStorage::new(&pool); // With default config
+    let mut backend = SqliteStorage::new(&pool);
 
     let mut start = 0;
     let mut items = stream::repeat_with(move || {
@@ -36,10 +42,10 @@ async fn main() {
             .run_after(Duration::from_secs(1))
             .with_ctx(SqlContext::new().with_priority(1))
             .build();
-        Ok(task)
+        task
     })
     .take(10);
-    backend.send_all(&mut items).await.unwrap();
+    backend.push_all(&mut items).await.unwrap();
 
     async fn send_reminder(item: usize, wrk: WorkerContext) -> Result<(), BoxDynError> {
         Ok(())
@@ -55,19 +61,24 @@ async fn main() {
 ### Hooked Worker Example (Event-driven)
 
 ```rust,no_run
+use std::time::Duration;
+
+use apalis::prelude::*;
+use apalis_sqlite::*;
+use futures::stream::{self, StreamExt};
 
 #[tokio::main]
 async fn main() {
-    let pool = SqlitePool::connect(":memory:").await.unwrap();
-    SqliteStorage::setup(&pool).await.unwrap();
-
     let lazy_strategy = StrategyBuilder::new()
         .apply(IntervalStrategy::new(Duration::from_secs(5)))
         .build();
     let config = Config::new("queue")
         .with_poll_interval(lazy_strategy)
         .set_buffer_size(5);
-    let backend = SqliteStorage::new_with_callback(&pool, &config).await;
+    let backend = SqliteStorage::new_with_callback(":memory:", &config);
+
+    let pool = backend.pool();
+    SqliteStorage::setup(&pool).await.unwrap();
 
     tokio::spawn({
         let pool = pool.clone();
@@ -77,7 +88,7 @@ async fn main() {
             let mut start = 0;
             let items = stream::repeat_with(move || {
                 start += 1;
-                Task::builder(serde_json::to_value(&start).unwrap())
+                Task::builder(serde_json::to_vec(&start).unwrap())
                     .run_after(Duration::from_secs(1))
                     .with_ctx(SqlContext::new().with_priority(start))
                     .build()
@@ -103,32 +114,38 @@ async fn main() {
 ### Workflow Example
 
 ```rust,no_run
+use std::time::Duration;
+
+use apalis::prelude::*;
+use apalis_sqlite::*;
+use apalis_workflow::*;
+
 #[tokio::main]
 async fn main() {
     let workflow = Workflow::new("odd-numbers-workflow")
-        .then(|a: usize| async move {
-            Ok::<_, WorkflowError>((0..=a).collect::<Vec<_>>())
+        .and_then(|a: usize| async move {
+            Ok::<Vec<usize>, BoxDynError>((0..=a).collect::<Vec<usize>>())
         })
-        .filter_map(|x| async move {
+        .filter_map(|x: usize| async move {
             if x % 2 != 0 { Some(x) } else { None }
         })
-        .filter_map(|x| async move {
+        .filter_map(|x: usize| async move {
             if x % 3 != 0 { Some(x) } else { None }
         })
-        .filter_map(|x| async move {
+        .filter_map(|x: usize| async move {
             if x % 5 != 0 { Some(x) } else { None }
         })
         .delay_for(Duration::from_millis(1000))
-        .then(|a: Vec<usize>| async move {
+        .and_then(|a: Vec<usize>| async move {
             println!("Sum: {}", a.iter().sum::<usize>());
-            Ok::<(), WorkflowError>(())
+            Ok::<(), BoxDynError>(())
         });
 
     let pool = SqlitePool::connect(":memory:").await.unwrap();
     SqliteStorage::setup(&pool).await.unwrap();
     let mut sqlite = SqliteStorage::new_in_queue(&pool, "test-workflow");
 
-    sqlite.push(100usize).await.unwrap();
+    sqlite.push_start(100usize).await.unwrap();
 
     let worker = WorkerBuilder::new("rango-tango")
         .backend(sqlite)
@@ -144,6 +161,56 @@ async fn main() {
 }
 ```
 
+### Shared Example
+
+Full support for sharing the same connection. This example shows how to run multiple types with one function
+
+```rust,no_run
+use std::{collections::HashMap, time::Duration};
+
+use apalis::prelude::*;
+use apalis_sqlite::{SharedSqliteStorage, SqliteStorage};
+
+use futures::stream;
+
+#[tokio::main]
+async fn main() {
+
+    let mut store = SharedSqliteStorage::new(":memory:");
+
+    SqliteStorage::setup(store.pool()).await.unwrap();
+
+    let mut map_store = store.make_shared().unwrap();
+
+    let mut int_store = store.make_shared().unwrap();
+
+    map_store
+        .push_stream(&mut stream::iter(vec![HashMap::<String, String>::new()]))
+        .await
+        .unwrap();
+    int_store.push(99).await.unwrap();
+
+    async fn send_reminder<T, I>(
+        _: T,
+        _task_id: TaskId<I>,
+        wrk: WorkerContext,
+    ) -> Result<(), BoxDynError> {
+        tokio::time::sleep(Duration::from_secs(2)).await;
+        wrk.stop().unwrap();
+        println!("Reminder sent!");
+        Ok(())
+    }
+
+    let int_worker = WorkerBuilder::new("rango-tango-2")
+        .backend(int_store)
+        .build(send_reminder);
+    let map_worker = WorkerBuilder::new("rango-tango-1")
+        .backend(map_store)
+        .build(send_reminder);
+    tokio::try_join!(int_worker.run(), map_worker.run()).unwrap();
+}
+```
+
 ## Observability
 
 You can track your jobs using [apalis-board](https://github.com/apalis-dev/apalis-board).

README.md

@@ -1,3 +1,5 @@
+//! build.rs
+//! Build script to handle database migrations for apalis-sqlite.
 fn main() {
     println!("cargo:rerun-if-changed=migrations");
 }

build.rs

@@ -0,0 +1,22 @@
+use apalis::prelude::*;
+use apalis_sqlite::SqliteStorage;
+use sqlx::SqlitePool;
+
+#[tokio::main]
+async fn main() {
+    let pool = SqlitePool::connect(":memory:").await.unwrap();
+    SqliteStorage::setup(&pool).await.unwrap();
+    let mut backend = SqliteStorage::new(&pool);
+    backend.push(42).await.unwrap();
+
+    async fn task(task: u32, worker: WorkerContext) -> Result<(), BoxDynError> {
+        apalis_core::timer::sleep(std::time::Duration::from_secs(1)).await;
+        assert_eq!(task, 42);
+        worker.stop()?;
+        Ok(())
+    }
+    let worker = WorkerBuilder::new("rango-tango")
+        .backend(backend)
+        .build(task);
+    worker.run().await.unwrap();
+}

examples/basic.rs

@@ -0,0 +1,24 @@
+use apalis::prelude::*;
+use apalis_sqlite::{Config, SqliteStorage};
+
+#[tokio::main]
+async fn main() {
+    let config = Config::new("realtime-queue");
+    let mut backend = SqliteStorage::new_with_callback(":memory:", &config);
+
+    let pool = backend.pool();
+    SqliteStorage::setup(&pool).await.unwrap();
+
+    backend.push(42).await.unwrap();
+
+    async fn task(task: u32, worker: WorkerContext) -> Result<(), BoxDynError> {
+        apalis_core::timer::sleep(std::time::Duration::from_secs(1)).await;
+        assert_eq!(task, 42);
+        worker.stop()?;
+        Ok(())
+    }
+    let worker = WorkerBuilder::new("rango-tango")
+        .backend(backend)
+        .build(task);
+    worker.run().await.unwrap();
+}

examples/realtime.rs

@@ -0,0 +1,42 @@
+use std::{collections::HashMap, time::Duration};
+
+use apalis::prelude::*;
+use apalis_sqlite::{SharedSqliteStorage, SqliteStorage};
+
+use futures::stream;
+
+#[tokio::main]
+async fn main() {
+    let mut store = SharedSqliteStorage::new(":memory:");
+
+    SqliteStorage::setup(store.pool()).await.unwrap();
+
+    let mut map_store = store.make_shared().unwrap();
+
+    let mut int_store = store.make_shared().unwrap();
+
+    map_store
+        .push_stream(&mut stream::iter(vec![HashMap::<String, String>::new()]))
+        .await
+        .unwrap();
+    int_store.push(99).await.unwrap();
+
+    async fn send_reminder<T, I>(
+        _: T,
+        _task_id: TaskId<I>,
+        wrk: WorkerContext,
+    ) -> Result<(), BoxDynError> {
+        tokio::time::sleep(Duration::from_secs(2)).await;
+        wrk.stop().unwrap();
+        println!("Reminder sent!");
+        Ok(())
+    }
+
+    let int_worker = WorkerBuilder::new("rango-tango-2")
+        .backend(int_store)
+        .build(send_reminder);
+    let map_worker = WorkerBuilder::new("rango-tango-1")
+        .backend(map_store)
+        .build(send_reminder);
+    tokio::try_join!(int_worker.run(), map_worker.run()).unwrap();
+}

examples/shared.rs

@@ -0,0 +1 @@
+fn main() {}