Rename Rust library from php-node to php

Rename the Rust crate and library from php-node/php_node to php for
better clarity and consistency. Updated all references throughout the
codebase including doctests.

Changes:
- Cargo.toml: Changed package name from 'php-node' to 'php'
- Cargo.toml: Changed lib name from 'php_node' to 'php'
- src/lib.rs: Updated doctest to use 'php::' instead of 'php_node::'
- src/embed.rs: Updated all doctests to use 'php::' prefix
- src/main.rs: Updated imports to use 'php::' prefix
- CLAUDE.md: Updated documentation to reflect single-crate structure
  and removed references to old multi-crate workspace

All tests pass with the new naming.

Author: Qard

CLAUDE.md

@@ -37,17 +37,21 @@ npm run version
 # Build with proper rpath for linking libphp
 RUSTFLAGS="-C link-args=-Wl,-rpath,\$ORIGIN" npm run build
 
-# Build specific crate
-cargo build --manifest-path crates/php_node/Cargo.toml --release
+# Run Rust tests
+cargo test
+
+# Run binary directly
+cargo run
 ```
 
 ## Architecture
 
 ### Multi-language Structure
-- **Rust** (`/crates`): Core implementation using Cargo workspace
-  - `lang_handler`: Generic language handler abstractions
-  - `php`: PHP embedding and SAPI implementation  
-  - `php_node`: NAPI bindings exposing Rust to Node.js
+- **Rust** (`/src`): Single-crate implementation
+  - PHP embedding and SAPI implementation
+  - NAPI bindings exposing Rust to Node.js (when `napi-support` feature is enabled)
+  - Binary target for standalone testing (`src/main.rs`)
+  - Library target for NAPI usage (`src/lib.rs`)
 - **JavaScript**: Node.js API layer (`index.js`, `index.d.ts`)
 - **PHP**: Embedded runtime via libphp.{so,dylib}
 
@@ -87,21 +91,22 @@ cargo build --manifest-path crates/php_node/Cargo.toml --release
 
 5. **Platform Support**: x64 Linux, x64/arm64 macOS (pre-built binaries in `/npm`)
 
-6. **Recent Architecture Changes**: 
-   - `lang_handler` crate no longer uses `napi` features directly (removed from dependencies)
-   - `php` crate uses custom fork of ext-php-rs from platformatic GitHub org
+6. **Recent Architecture Changes**:
+   - Consolidated from multi-crate workspace to single crate named `php`
+   - NAPI support is now feature-gated with `napi-support` feature
+   - Binary target supports both library (`rlib`) and dynamic library (`cdylib`) outputs
 
 ## Common Tasks
 
 ### Adding New NAPI Functions
-1. Implement in Rust under `crates/php_node/src/`
+1. Implement in Rust under `src/` with `#[cfg(feature = "napi-support")]`
 2. Use `#[napi]` attributes for exposed functions/classes
 3. Run `npm run build` to regenerate TypeScript definitions
 
 ### Modifying Request/Response Handling
-- Core logic in `crates/php/src/sapi.rs`
+- Core logic in `src/sapi.rs` and `src/embed.rs`
 - JavaScript wrapper in `index.js`
-- Headers handling in `crates/php_node/src/headers.rs`
+- Request/response types from `http-handler` crate
 
 ### Debugging PHP Issues
 - Check INTERNALS.md for PHP embedding details
@@ -118,7 +123,9 @@ The rewriter system supports Apache mod_rewrite-like functionality:
 ## Project Files Reference
 
 - `index.js`: Main JavaScript API, exports PHP, Request, Response, Headers, Rewriter classes
-- `crates/php_node/src/lib.rs`: NAPI bindings entry point
-- `crates/php/src/sapi.rs`: PHP SAPI implementation (core request handling)
-- `crates/lang_handler/src/`: Generic language handler abstractions (request/response/rewriter)
+- `src/lib.rs`: Library entry point, exports core types and NAPI bindings
+- `src/main.rs`: Binary entry point for standalone testing
+- `src/embed.rs`: Core `Embed` type for handling PHP requests
+- `src/sapi.rs`: PHP SAPI implementation (low-level PHP integration)
+- `src/runtime.rs`: NAPI runtime implementation (when `napi-support` feature enabled)
 - `__test__/*.spec.mjs`: Test files for each component

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 edition = "2021"
-name = "php-node"
+name = "php"
 version = "1.4.0"
 authors = ["Platformatic Inc. <[email protected]> (https://platformatic.dev)"]
 license = "MIT"
@@ -11,7 +11,7 @@ default = []
 napi-support = ["dep:napi", "dep:napi-derive", "dep:napi-build", "http-handler/napi-support", "http-rewriter/napi-support"]
 
 [lib]
-name = "php_node"
+name = "php"
 crate-type = ["cdylib", "rlib"]
 path = "src/lib.rs"
 
@@ -26,7 +26,7 @@ hostname = "0.4.1"
 ext-php-rs = { version = "0.14.0", features = ["embed"] }
 http-handler = { git = "https://github.com/platformatic/http-handler.git" }
 # http-handler = { path = "../http-handler" }
-http-rewriter = { git = "https://github.com/platformatic/http-rewriter.git", branch = "add-docroot-parameter-support" }
+http-rewriter = { git = "https://github.com/platformatic/http-rewriter.git" }
 # http-rewriter = { path = "../http-rewriter" }
 libc = "0.2.171"
 # Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix

src/embed.rs

@@ -12,7 +12,7 @@ use ext_php_rs::{
   zend::{try_catch, try_catch_first, ExecutorGlobals, SapiGlobals},
 };
 
-use http_handler::{Handler, Request, Response};
+use http_handler::{Handler, Request, Response, ResponseBuilderExt};
 
 use super::{
   sapi::{ensure_sapi, Sapi},
@@ -90,7 +90,7 @@ impl Embed {
   ///
   /// ```
   /// use std::env::current_dir;
-  /// use php_node::Embed;
+  /// use php::Embed;
   ///
   /// let docroot = current_dir()
   ///   .expect("should have current_dir");
@@ -113,7 +113,7 @@ impl Embed {
   ///
   /// ```
   /// use std::env::{args, current_dir};
-  /// use php_node::Embed;
+  /// use php::Embed;
   ///
   /// let docroot = current_dir()
   ///   .expect("should have current_dir");
@@ -137,7 +137,7 @@ impl Embed {
   ///
   /// ```
   /// use std::env::current_dir;
-  /// use php_node::{Embed, Handler, Request, Response};
+  /// use php::{Embed, Handler, Request, Response};
   ///
   /// let docroot = current_dir()
   ///   .expect("should have current_dir");
@@ -174,7 +174,7 @@ impl Embed {
   ///
   /// ```rust
   /// use std::env::current_dir;
-  /// use php_node::Embed;
+  /// use php::Embed;
   ///
   /// let docroot = current_dir()
   ///   .expect("should have current_dir");
@@ -199,7 +199,7 @@ impl Handler for Embed {
   ///
   /// ```
   /// use std::{env::temp_dir, fs::File, io::Write};
-  /// use php_node::{Embed, Handler, Request, Response, MockRoot};
+  /// use php::{Embed, Handler, Request, Response, MockRoot};
   ///
   /// let docroot = MockRoot::builder()
   ///   .file("index.php", "<?php echo \"Hello, World!\"; ?>")
@@ -321,10 +321,13 @@ impl Handler for Embed {
 
         let ex = Error::Exception(err);
 
-        // Fixed exception handling (FIXME.md #3) by using ResponseExt::set_exception
         if let Some(ctx) = RequestContext::current() {
-          ctx.set_response_exception(ex.to_string());
-          ctx.set_response_status(500);
+          let builder = std::mem::replace(
+            ctx.response_builder_mut(),
+            http_handler::response::Builder::new(),
+          );
+          let builder = builder.exception(ex.to_string()).status(500);
+          *ctx.response_builder_mut() = builder;
         }
 
         return Err(EmbedRequestError::Exception(ex.to_string()));
@@ -351,10 +354,16 @@ impl Handler for Embed {
         efree(mimetype.cast::<u8>());
       }
 
-      // Set the final status and content-type header using the new clean API (FIXME.md #4)
+      // Set the final status and content-type header
       if let Some(ctx) = RequestContext::current() {
-        ctx.set_response_status(http_response_code as u16);
-        ctx.add_response_header("Content-Type", mime);
+        let builder = std::mem::replace(
+          ctx.response_builder_mut(),
+          http_handler::response::Builder::new(),
+        );
+        let builder = builder
+          .status(http_response_code as u16)
+          .header("Content-Type", mime);
+        *ctx.response_builder_mut() = builder;
       }
 
       // Build the final response with accumulated data using the extension system

src/lib.rs

@@ -8,8 +8,8 @@
 //! ```rust
 //! use std::env::{args, current_dir};
 //! # use std::path::PathBuf;
-//! # use php_node::MockRoot;
-//! use php_node::{
+//! # use php::MockRoot;
+//! use php::{
 //!   rewrite::{PathRewriter, Rewriter},
 //!   Embed, Handler, Request,
 //! };

src/main.rs

@@ -1,7 +1,7 @@
 use std::{env::current_dir, fs::File, io::Write, path::PathBuf};
 
 use bytes::BytesMut;
-use php_node::{rewrite::PathRewriter, Embed, Handler, Request, RequestRewriter};
+use php::{rewrite::PathRewriter, Embed, Handler, Request, RequestRewriter};
 
 #[tokio::main]
 async fn main() {

src/request_context.rs

@@ -1,49 +1,23 @@
-use bytes::BytesMut;
 use ext_php_rs::zend::SapiGlobals;
-use http_handler::request::Parts;
-use http_handler::{
-  BodyBuffer, HeaderMap, HeaderName, HeaderValue, Request, ResponseBuilderExt, ResponseLog,
-  StatusCode,
-};
+use http_handler::{BodyBuffer, Request};
 use std::{ffi::c_void, path::PathBuf};
 
 /// The request context for the PHP SAPI.
-///
-/// This has been redesigned to address all issues in FIXME.md:
-/// - Uses request Parts to avoid RefUnwindSafe issues (#1)
-/// - Stores mutable body for proper consumption (#2)
-/// - Uses extension types to accumulate response data (#3, #4)
-#[derive(Debug)]
 pub struct RequestContext {
-  request_parts: Parts,
-  request_body: BytesMut,
-  response_status: StatusCode,
-  response_headers: HeaderMap,
-  response_body: BodyBuffer,
-  response_log: ResponseLog,
-  response_exception: Option<String>,
+  request: Request,
+  response_builder: http_handler::response::Builder,
   docroot: PathBuf,
 }
 
 impl RequestContext {
   /// Sets the current request context for the PHP SAPI.
-  ///
-  /// Uses into_parts() to avoid RefUnwindSafe issues (FIXME.md #1).
   pub fn for_request<S>(request: Request, docroot: S)
   where
     S: Into<PathBuf>,
   {
-    // Use into_parts() to avoid RefUnwindSafe issues (FIXME.md #1)
-    let (parts, body) = request.into_parts();
-
     let context = Box::new(RequestContext {
-      request_parts: parts,
-      request_body: body,
-      response_status: StatusCode::OK,
-      response_headers: HeaderMap::new(),
-      response_body: BodyBuffer::new(),
-      response_log: ResponseLog::new(),
-      response_exception: None,
+      request,
+      response_builder: http_handler::response::Builder::new(),
       docroot: docroot.into(),
     });
     let mut globals = SapiGlobals::get_mut();
@@ -76,86 +50,32 @@ impl RequestContext {
     Some(unsafe { Box::from_raw(ptr as *mut RequestContext) })
   }
 
-  /// Returns a reference to the request parts.
-  /// This replaces the old request() method since we now use parts.
-  pub fn request_parts(&self) -> &Parts {
-    &self.request_parts
-  }
-
-  /// Returns a mutable reference to the request body.
-  /// This allows proper consumption of the body (FIXME.md #2).
-  pub fn request_body_mut(&mut self) -> &mut BytesMut {
-    &mut self.request_body
+  /// Returns a reference to the request.
+  pub fn request(&self) -> &Request {
+    &self.request
   }
 
-  /// Returns a reference to the request body.
-  pub fn request_body(&self) -> &BytesMut {
-    &self.request_body
-  }
-
-  /// Add a header to the response.
-  pub fn add_response_header<K, V>(&mut self, key: K, value: V)
-  where
-    K: TryInto<HeaderName>,
-    V: TryInto<HeaderValue>,
-  {
-    if let (Ok(header_name), Ok(header_value)) = (key.try_into(), value.try_into()) {
-      self.response_headers.insert(header_name, header_value);
-    }
-  }
-
-  /// Set the response status code.
-  pub fn set_response_status(&mut self, status: u16) {
-    if let Ok(status_code) = StatusCode::from_u16(status) {
-      self.response_status = status_code;
-    }
+  /// Returns a mutable reference to the request.
+  pub fn request_mut(&mut self) -> &mut Request {
+    &mut self.request
   }
 
-  /// Write data to the response body.
-  pub fn write_response_body(&mut self, data: &[u8]) {
-    self.response_body.append(data);
-  }
-
-  /// Write to the response log.
-  /// This uses extension types to accumulate log data (FIXME.md #4).
-  pub fn write_response_log(&mut self, data: &[u8]) {
-    self.response_log.append(data);
-  }
-
-  /// Set an exception on the response.
-  /// This stores the exception to be added via ResponseBuilderExt (FIXME.md #3).
-  pub fn set_response_exception(&mut self, exception: impl Into<String>) {
-    self.response_exception = Some(exception.into());
+  /// Returns a mutable reference to the response builder.
+  pub fn response_builder_mut(&mut self) -> &mut http_handler::response::Builder {
+    &mut self.response_builder
   }
 
   /// Build the final response using the accumulated data.
-  /// This properly uses ResponseBuilderExt for logs and exceptions (FIXME.md #3, #4).
-  pub fn build_response(self) -> Result<http_handler::Response, http_handler::Error> {
-    // Start building the response
-    let mut builder = http_handler::response::Response::builder().status(self.response_status);
-
-    // Add all headers
-    for (key, value) in &self.response_headers {
-      builder = builder.header(key, value);
-    }
-
-    // Add extensions using ResponseBuilderExt
-    builder = builder
-      .body_buffer(self.response_body)
-      .log(self.response_log.into_bytes());
-
-    if let Some(exception) = self.response_exception {
-      builder = builder.exception(exception);
-    }
-
-    // Get the body buffer from extensions and build final response
-    let body = builder
+  pub fn build_response(mut self) -> Result<http_handler::Response, http_handler::Error> {
+    // Extract the body buffer from extensions (if any was accumulated)
+    let body = self
+      .response_builder
       .extensions_mut()
       .and_then(|ext| ext.remove::<BodyBuffer>())
       .unwrap_or_default()
       .into_bytes_mut();
 
-    builder.body(body)
+    self.response_builder.body(body)
   }
 
   /// Returns the docroot associated with this request context