Remove all the nightly features

zino-rs · Dec 30, 2023 · 540c3ce · 540c3ce
1 parent 4bc916b
commit 540c3ce
Show file tree

Hide file tree

Showing 54 changed files with 426 additions and 306 deletions.
diff --git a/examples/actix-app/src/main.rs b/examples/actix-app/src/main.rs
@@ -1,5 +1,3 @@
-#![feature(lazy_cell)]
-
 mod controller;
 mod domain;
 mod extension;

diff --git a/examples/axum-app/src/main.rs b/examples/axum-app/src/main.rs
@@ -1,5 +1,3 @@
-#![feature(lazy_cell)]
-
 mod controller;
 mod domain;
 mod extension;

diff --git a/zino-core/Cargo.toml b/zino-core/Cargo.toml
@@ -191,6 +191,7 @@ md-5 = "0.10.6"
 mime = "0.3.17"
 mime_guess = "2.0.4"
 multer = "3.0.0"
+once_cell = "1.19.0"
 parking_lot = "0.12.1"
 percent-encoding = "2.3.1"
 rand = "0.8.5"

diff --git a/zino-core/src/accessor/mod.rs b/zino-core/src/accessor/mod.rs
@@ -38,14 +38,13 @@
 //! | `webhdfs`     | WebHDFS services.                        | `accessor-webhdfs`    |
 //!
 
-use crate::{application::StaticRecord, extension::TomlTableExt, state::State};
+use crate::{application::StaticRecord, extension::TomlTableExt, state::State, LazyLock};
 use opendal::{
     layers::{MetricsLayer, RetryLayer, TracingLayer},
     services, Error,
     ErrorKind::Unsupported,
     Operator,
 };
-use std::sync::LazyLock;
 use toml::Table;
 
 /// Global storage accessor built on the top of [`opendal`](https://crates.io/crates/opendal).

diff --git a/zino-core/src/application/mod.rs b/zino-core/src/application/mod.rs
@@ -8,11 +8,11 @@ use crate::{
     schedule::{AsyncJobScheduler, AsyncScheduler, Scheduler},
     state::{Env, State},
     trace::TraceContext,
-    Map,
+    LazyLock, Map,
 };
 use reqwest::Response;
 use serde::de::DeserializeOwned;
-use std::{env, fs, path::PathBuf, sync::LazyLock, thread};
+use std::{env, fs, path::PathBuf, thread};
 use toml::value::Table;
 use utoipa::openapi::{OpenApi, OpenApiBuilder};
 

diff --git a/zino-core/src/application/secret_key.rs b/zino-core/src/application/secret_key.rs
@@ -7,7 +7,7 @@ pub(super) fn init<APP: Application + ?Sized>() {
     let config = APP::config();
     let checksum: [u8; 32] = config
         .get_str("checksum")
-        .and_then(|checksum| checksum.as_bytes().first_chunk().copied())
+        .and_then(|checksum| checksum.as_bytes().try_into().ok())
         .unwrap_or_else(|| {
             let secret = config
                 .get_str("secret")

diff --git a/zino-core/src/application/system_monitor.rs b/zino-core/src/application/system_monitor.rs
@@ -1,6 +1,5 @@
-use crate::{datetime::DateTime, extension::JsonObjectExt, Map};
+use crate::{datetime::DateTime, extension::JsonObjectExt, LazyLock, Map};
 use parking_lot::RwLock;
-use std::sync::LazyLock;
 use sysinfo::{Disks, Networks, System};
 
 /// Refreshes the system and retrieves the information.

diff --git a/zino-core/src/auth/access_key.rs b/zino-core/src/auth/access_key.rs
@@ -3,13 +3,14 @@ use crate::{
     encoding::base64,
     extension::TomlTableExt,
     state::State,
+    LazyLock,
 };
 use hmac::{
     digest::{FixedOutput, KeyInit, MacMarker, Update},
     Hmac, Mac,
 };
 use rand::{distributions::Alphanumeric, Rng};
-use std::{borrow::Cow, fmt, iter, sync::LazyLock};
+use std::{borrow::Cow, fmt, iter};
 
 #[cfg(feature = "auth-totp")]
 use totp_rs::{Algorithm, TOTP};
@@ -128,7 +129,7 @@ static SECRET_KEY: LazyLock<[u8; 64]> = LazyLock::new(|| {
     let config = app_config.get_table("access-key").unwrap_or(app_config);
     let checksum: [u8; 32] = config
         .get_str("checksum")
-        .and_then(|checksum| checksum.as_bytes().first_chunk().copied())
+        .and_then(|checksum| checksum.as_bytes().try_into().ok())
         .unwrap_or_else(|| {
             let secret = config.get_str("secret").unwrap_or_else(|| {
                 tracing::warn!("an auto-generated `secret` is used for deriving a secret key");

diff --git a/zino-core/src/auth/jwt_claims.rs b/zino-core/src/auth/jwt_claims.rs
@@ -4,15 +4,15 @@ use crate::{
     error::Error,
     extension::{JsonObjectExt, TomlTableExt},
     state::State,
-    JsonValue, Map,
+    JsonValue, LazyLock, Map,
 };
 use jwt_simple::{
     algorithms::MACLike,
     claims::{self, Claims, JWTClaims},
     common::VerificationOptions,
 };
 use serde::{de::DeserializeOwned, Serialize};
-use std::{sync::LazyLock, time::Duration};
+use std::time::Duration;
 
 /// JWT Claims.
 #[derive(Debug, Clone)]
@@ -196,7 +196,7 @@ static SECRET_KEY: LazyLock<JwtHmacKey> = LazyLock::new(|| {
     let config = app_config.get_table("jwt").unwrap_or(app_config);
     let checksum: [u8; 32] = config
         .get_str("checksum")
-        .and_then(|checksum| checksum.as_bytes().first_chunk().copied())
+        .and_then(|checksum| checksum.as_bytes().try_into().ok())
         .unwrap_or_else(|| {
             let secret = config.get_str("secret").unwrap_or_else(|| {
                 tracing::warn!("an auto-generated `secret` is used for deriving a secret key");

diff --git a/zino-core/src/chatbot/mod.rs b/zino-core/src/chatbot/mod.rs
@@ -7,8 +7,9 @@
 //! | `openai`         | OpenAI                 | `chatbot-openai`       |
 //!
 
-use crate::{application::StaticRecord, error::Error, extension::TomlTableExt, state::State, Map};
-use std::sync::LazyLock;
+use crate::{
+    application::StaticRecord, error::Error, extension::TomlTableExt, state::State, LazyLock, Map,
+};
 use toml::Table;
 
 mod client;

diff --git a/zino-core/src/connector/connector_arrow/mod.rs b/zino-core/src/connector/connector_arrow/mod.rs
@@ -6,7 +6,7 @@ use crate::{
     bail,
     error::Error,
     extension::TomlTableExt,
-    helper, warn, Map, Record,
+    helper, warn, LazyLock, Map, Record,
 };
 use datafusion::{
     arrow::{datatypes::Schema, record_batch::RecordBatch},
@@ -24,7 +24,7 @@ use std::{
     fs::File,
     io::Write,
     path::PathBuf,
-    sync::{Arc, LazyLock, OnceLock},
+    sync::{Arc, OnceLock},
 };
 use toml::value::{Array, Table};
 

diff --git a/zino-core/src/connector/connector_mysql.rs b/zino-core/src/connector/connector_mysql.rs
@@ -1,5 +1,7 @@
-use super::{Connector, DataSource, DataSourceConnector::MySql};
-use crate::{error::Error, extension::TomlTableExt, state::State};
+use super::{sqlx_common::SerializeRow, Connector, DataSource, DataSourceConnector::MySql};
+use crate::{error::Error, extension::TomlTableExt, helper, state::State, AvroValue, Map, Record};
+use futures::TryStreamExt;
+use serde::de::DeserializeOwned;
 use sqlx::mysql::{MySqlPool, MySqlPoolOptions};
 use std::time::Duration;
 use toml::Table;
@@ -33,5 +35,92 @@ impl Connector for MySqlPool {
         Ok(data_source)
     }
 
-    super::sqlx_common::impl_sqlx_connector!(MySqlPool);
+    async fn execute(&self, query: &str, params: Option<&Map>) -> Result<Option<u64>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        let query_result = query.execute(self).await?;
+        Ok(Some(query_result.rows_affected()))
+    }
+
+    async fn query(&self, query: &str, params: Option<&Map>) -> Result<Vec<Record>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        let mut rows = query.fetch(self);
+        let mut records = Vec::new();
+        while let Some(row) = rows.try_next().await? {
+            let value = apache_avro::to_value(&SerializeRow(row))?;
+            if let AvroValue::Record(record) = value {
+                records.push(record);
+            }
+        }
+        Ok(records)
+    }
+
+    async fn query_as<T: DeserializeOwned>(
+        &self,
+        query: &str,
+        params: Option<&Map>,
+    ) -> Result<Vec<T>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        let mut rows = query.fetch(self);
+        let mut data = Vec::new();
+        while let Some(row) = rows.try_next().await? {
+            let json_value = serde_json::to_value(&SerializeRow(row))?;
+            let value = serde_json::from_value(json_value)?;
+            data.push(value);
+        }
+        Ok(data)
+    }
+
+    async fn query_one(&self, query: &str, params: Option<&Map>) -> Result<Option<Record>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        let data = if let Some(row) = query.fetch_optional(self).await? {
+            let value = apache_avro::to_value(&SerializeRow(row))?;
+            if let AvroValue::Record(record) = value {
+                Some(record)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+        Ok(data)
+    }
+
+    async fn query_one_as<T: DeserializeOwned>(
+        &self,
+        query: &str,
+        params: Option<&Map>,
+    ) -> Result<Option<T>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        if let Some(row) = query.fetch_optional(self).await? {
+            let json_value = serde_json::to_value(&SerializeRow(row))?;
+            serde_json::from_value(json_value).map_err(Error::from)
+        } else {
+            Ok(None)
+        }
+    }
 }
diff --git a/zino-core/src/connector/connector_sqlite.rs b/zino-core/src/connector/connector_sqlite.rs
@@ -1,5 +1,7 @@
-use super::{Connector, DataSource, DataSourceConnector::Sqlite};
-use crate::{error::Error, extension::TomlTableExt};
+use super::{sqlx_common::SerializeRow, Connector, DataSource, DataSourceConnector::Sqlite};
+use crate::{error::Error, extension::TomlTableExt, helper, AvroValue, Map, Record};
+use futures::TryStreamExt;
+use serde::de::DeserializeOwned;
 use sqlx::sqlite::{SqlitePool, SqlitePoolOptions};
 use std::time::Duration;
 use toml::Table;
@@ -32,5 +34,92 @@ impl Connector for SqlitePool {
         Ok(data_source)
     }
 
-    super::sqlx_common::impl_sqlx_connector!(SqlitePool);
+    async fn execute(&self, query: &str, params: Option<&Map>) -> Result<Option<u64>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        let query_result = query.execute(self).await?;
+        Ok(Some(query_result.rows_affected()))
+    }
+
+    async fn query(&self, query: &str, params: Option<&Map>) -> Result<Vec<Record>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        let mut rows = query.fetch(self);
+        let mut records = Vec::new();
+        while let Some(row) = rows.try_next().await? {
+            let value = apache_avro::to_value(&SerializeRow(row))?;
+            if let AvroValue::Record(record) = value {
+                records.push(record);
+            }
+        }
+        Ok(records)
+    }
+
+    async fn query_as<T: DeserializeOwned>(
+        &self,
+        query: &str,
+        params: Option<&Map>,
+    ) -> Result<Vec<T>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        let mut rows = query.fetch(self);
+        let mut data = Vec::new();
+        while let Some(row) = rows.try_next().await? {
+            let json_value = serde_json::to_value(&SerializeRow(row))?;
+            let value = serde_json::from_value(json_value)?;
+            data.push(value);
+        }
+        Ok(data)
+    }
+
+    async fn query_one(&self, query: &str, params: Option<&Map>) -> Result<Option<Record>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        let data = if let Some(row) = query.fetch_optional(self).await? {
+            let value = apache_avro::to_value(&SerializeRow(row))?;
+            if let AvroValue::Record(record) = value {
+                Some(record)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+        Ok(data)
+    }
+
+    async fn query_one_as<T: DeserializeOwned>(
+        &self,
+        query: &str,
+        params: Option<&Map>,
+    ) -> Result<Option<T>, Error> {
+        let (sql, values) = helper::prepare_sql_query(query, params, '?');
+        let mut query = sqlx::query(&sql);
+        for value in values {
+            query = query.bind(value.to_string());
+        }
+
+        if let Some(row) = query.fetch_optional(self).await? {
+            let json_value = serde_json::to_value(&SerializeRow(row))?;
+            serde_json::from_value(json_value).map_err(Error::from)
+        } else {
+            Ok(None)
+        }
+    }
 }
diff --git a/zino-core/src/connector/mod.rs b/zino-core/src/connector/mod.rs
@@ -25,11 +25,10 @@
 //!
 
 use crate::{
-    application::StaticRecord, error::Error, extension::TomlTableExt, state::State, AvroValue, Map,
-    Record,
+    application::StaticRecord, error::Error, extension::TomlTableExt, state::State, AvroValue,
+    LazyLock, Map, Record,
 };
 use serde::de::DeserializeOwned;
-use std::sync::LazyLock;
 use toml::Table;
 
 mod data_source;