castrum 0.9.3 → 0.9.4

package/rust/http/method.rs

@@ -0,0 +1,200 @@
+// rust/http/method.rs — HTTP method classification
+// Uses the shared word-at-a-time byte helpers from `bytes.rs`.
+
+use crate::util::bytes::{ascii_eq_ignore_case, load_u64_padded};
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum MethodKind {
+    Get,
+    Head,
+    Post,
+    Put,
+    Patch,
+    Delete,
+    Options,
+    Other,
+}
+
+const METHOD_GET: u64 = u64::from_le_bytes(*b"GET\0\0\0\0\0");
+const METHOD_HEAD: u64 = u64::from_le_bytes(*b"HEAD\0\0\0\0");
+const METHOD_POST: u64 = u64::from_le_bytes(*b"POST\0\0\0\0");
+const METHOD_PUT: u64 = u64::from_le_bytes(*b"PUT\0\0\0\0\0");
+const METHOD_PATCH: u64 = u64::from_le_bytes(*b"PATCH\0\0\0");
+const METHOD_DELETE: u64 = u64::from_le_bytes(*b"DELETE\0\0");
+const METHOD_OPTIONS: u64 = u64::from_le_bytes(*b"OPTIONS\0");
+
+impl MethodKind {
+    /// Classify HTTP method from a `&str` (case-sensitive, exact match).
+    #[allow(clippy::should_implement_trait)]
+    #[inline(always)]
+    pub fn from_str(method: &str) -> Self {
+        let bytes = method.as_bytes();
+        let loaded = load_u64_padded(bytes);
+
+        match bytes.len() {
+            3 if loaded == METHOD_GET => Self::Get,
+            3 if loaded == METHOD_PUT => Self::Put,
+            4 if loaded == METHOD_POST => Self::Post,
+            4 if loaded == METHOD_HEAD => Self::Head,
+            5 if loaded == METHOD_PATCH => Self::Patch,
+            6 if loaded == METHOD_DELETE => Self::Delete,
+            7 if loaded == METHOD_OPTIONS => Self::Options,
+            _ => Self::Other,
+        }
+    }
+
+    /// Classify HTTP method from raw bytes, case-insensitively, with zero
+    /// allocation (delegates to the shared word-at-a-time comparator).
+    #[inline(always)]
+    pub fn from_bytes_ignore_case(bytes: &[u8]) -> Self {
+        if bytes.len() > 7 {
+            return Self::Other;
+        }
+        if ascii_eq_ignore_case(bytes, b"GET") {
+            Self::Get
+        } else if ascii_eq_ignore_case(bytes, b"HEAD") {
+            Self::Head
+        } else if ascii_eq_ignore_case(bytes, b"POST") {
+            Self::Post
+        } else if ascii_eq_ignore_case(bytes, b"PUT") {
+            Self::Put
+        } else if ascii_eq_ignore_case(bytes, b"PATCH") {
+            Self::Patch
+        } else if ascii_eq_ignore_case(bytes, b"DELETE") {
+            Self::Delete
+        } else if ascii_eq_ignore_case(bytes, b"OPTIONS") {
+            Self::Options
+        } else {
+            Self::Other
+        }
+    }
+
+    /// Classify from u8 discriminator (0-6).
+    #[inline(always)]
+    pub fn from_u8(v: u8) -> Self {
+        match v {
+            0 => Self::Get,
+            1 => Self::Head,
+            2 => Self::Post,
+            3 => Self::Put,
+            4 => Self::Patch,
+            5 => Self::Delete,
+            6 => Self::Options,
+            _ => Self::Other,
+        }
+    }
+
+    /// Returns true if the method may carry a body.
+    #[inline(always)]
+    pub fn may_have_body(&self) -> bool {
+        matches!(self, Self::Post | Self::Put | Self::Patch | Self::Delete)
+    }
+
+    /// Returns u8 discriminant for packed format.
+    #[inline(always)]
+    pub fn to_u8(&self) -> u8 {
+        match self {
+            Self::Get => 0,
+            Self::Head => 1,
+            Self::Post => 2,
+            Self::Put => 3,
+            Self::Patch => 4,
+            Self::Delete => 5,
+            Self::Options => 6,
+            Self::Other => 7,
+        }
+    }
+}
+
+impl MethodKind {
+    /// Bitmask representation for fast CORS method matching.
+    #[inline(always)]
+    pub fn bit(&self) -> u16 {
+        1u16 << (self.to_u8() as u16)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::MethodKind;
+
+    #[test]
+    fn method_from_bytes_ignore_case_upper() {
+        assert_eq!(MethodKind::from_bytes_ignore_case(b"GET"), MethodKind::Get);
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"HEAD"),
+            MethodKind::Head
+        );
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"POST"),
+            MethodKind::Post
+        );
+        assert_eq!(MethodKind::from_bytes_ignore_case(b"PUT"), MethodKind::Put);
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"PATCH"),
+            MethodKind::Patch
+        );
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"DELETE"),
+            MethodKind::Delete
+        );
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"OPTIONS"),
+            MethodKind::Options
+        );
+    }
+
+    #[test]
+    fn method_from_bytes_ignore_case_lower() {
+        assert_eq!(MethodKind::from_bytes_ignore_case(b"get"), MethodKind::Get);
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"post"),
+            MethodKind::Post
+        );
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"options"),
+            MethodKind::Options
+        );
+    }
+
+    #[test]
+    fn method_from_bytes_ignore_case_unknown() {
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"FETCH"),
+            MethodKind::Other
+        );
+        assert_eq!(MethodKind::from_bytes_ignore_case(b""), MethodKind::Other);
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"GETX"),
+            MethodKind::Other
+        );
+        assert_eq!(
+            MethodKind::from_bytes_ignore_case(b"POSTING"),
+            MethodKind::Other
+        );
+    }
+
+    #[test]
+    fn method_from_str_upper() {
+        assert_eq!(MethodKind::from_str("GET"), MethodKind::Get);
+        assert_eq!(MethodKind::from_str("DELETE"), MethodKind::Delete);
+        assert_eq!(MethodKind::from_str("WEIRD"), MethodKind::Other);
+    }
+
+    #[test]
+    fn method_bits_are_distinct() {
+        let bits: std::collections::HashSet<u16> = [
+            MethodKind::Get,
+            MethodKind::Head,
+            MethodKind::Post,
+            MethodKind::Put,
+            MethodKind::Patch,
+            MethodKind::Delete,
+            MethodKind::Options,
+        ]
+        .iter()
+        .map(|m| m.bit())
+        .collect();
+        assert_eq!(bits.len(), 7, "each method must have a unique bit");
+    }
+}

package/rust/http/mime_lookup.rs

@@ -0,0 +1,130 @@
+// rust/http/mime_lookup.rs — file extension → MIME type (phf table).
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use phf::{phf_map, Map};
+
+const OCTET_STREAM: &str = "application/octet-stream";
+
+static MIME_TABLE: Map<&'static str, &'static str> = phf_map! {
+    "json" => "application/json",
+    "js" => "text/javascript",
+    "mjs" => "text/javascript",
+    "cjs" => "text/javascript",
+    "html" => "text/html",
+    "htm" => "text/html",
+    "css" => "text/css",
+    "csv" => "text/csv",
+    "xml" => "application/xml",
+    "txt" => "text/plain",
+    "png" => "image/png",
+    "jpg" => "image/jpeg",
+    "jpeg" => "image/jpeg",
+    "gif" => "image/gif",
+    "webp" => "image/webp",
+    "avif" => "image/avif",
+    "svg" => "image/svg+xml",
+    "ico" => "image/x-icon",
+    "pdf" => "application/pdf",
+    "zip" => "application/zip",
+    "gz" => "application/gzip",
+    "wasm" => "application/wasm",
+    "map" => "application/json",
+    "woff" => "font/woff",
+    "woff2" => "font/woff2",
+    "ttf" => "font/ttf",
+    "otf" => "font/otf",
+    "mp4" => "video/mp4",
+    "webm" => "video/webm",
+    "mp3" => "audio/mpeg",
+    "ogg" => "audio/ogg",
+};
+
+/// MIME lookup core over a raw byte slice. Shared by the scalar napi path and
+/// the packed batch path. Unknown extensions fall back to mime_guess, then to
+/// `application/octet-stream`.
+pub fn mime_from_extension_bytes(ext: &[u8]) -> Vec<u8> {
+    let text = match std::str::from_utf8(ext) {
+        Ok(text) => text,
+        Err(_) => return OCTET_STREAM.as_bytes().to_vec(),
+    };
+
+    let text = text.trim_start_matches('.');
+
+    let mut stack = [0u8; 64];
+
+    let lower_owned: String;
+
+    let lower: &str = if text.len() <= stack.len() {
+        for (i, b) in text.bytes().enumerate() {
+            stack[i] = b.to_ascii_lowercase();
+        }
+
+        match std::str::from_utf8(&stack[..text.len()]) {
+            Ok(s) => s,
+            Err(_) => return OCTET_STREAM.as_bytes().to_vec(),
+        }
+    } else {
+        lower_owned = text.to_ascii_lowercase();
+        &lower_owned
+    };
+
+    if let Some(mime) = MIME_TABLE.get(lower) {
+        return mime.as_bytes().to_vec();
+    }
+
+    let guessed = mime_guess::from_ext(lower).first_or_octet_stream();
+    guessed.essence_str().as_bytes().to_vec()
+}
+
+#[napi]
+pub fn mime_from_extension(ext: Uint8Array) -> Buffer {
+    Buffer::from(mime_from_extension_bytes(ext.as_ref()))
+}
+
+/// Packed MIME-lookup batch: `[u32 count]{[u32 len][ext]}` in →
+/// `[u32 count]{[u32 len][mime]}` out (octet-stream for unknown/empty).
+#[napi]
+pub fn mime_from_extension_batch_packed(input: Uint8Array) -> Result<Buffer> {
+    crate::util::run_packed_batch(input.as_ref(), mime_from_extension_bytes).map(Buffer::from)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn mime(input: &str) -> String {
+        let out = mime_from_extension(Uint8Array::new(input.as_bytes().to_vec()));
+        String::from_utf8_lossy(out.as_ref()).into_owned()
+    }
+
+    #[test]
+    fn known_extensions() {
+        assert_eq!(mime(".js"), "text/javascript");
+        assert_eq!(mime("json"), "application/json");
+        assert_eq!(mime(".html"), "text/html");
+        assert_eq!(mime(".png"), "image/png");
+        assert_eq!(mime(".pdf"), "application/pdf");
+    }
+
+    #[test]
+    fn case_insensitive() {
+        assert_eq!(mime(".JS"), "text/javascript");
+        assert_eq!(mime(".Jpg"), "image/jpeg");
+    }
+
+    #[test]
+    fn unknown_and_empty_fall_back_to_octet_stream() {
+        assert_eq!(mime(".xkrq"), "application/octet-stream");
+        assert_eq!(mime(""), "application/octet-stream");
+    }
+
+    #[test]
+    fn non_utf8_falls_back_to_octet_stream() {
+        let out = mime_from_extension(Uint8Array::new(vec![0xff, 0xfe, 0xfd]));
+        assert_eq!(
+            String::from_utf8_lossy(out.as_ref()),
+            "application/octet-stream"
+        );
+    }
+}

package/rust/http/mod.rs

@@ -0,0 +1,32 @@
+//! HTTP wire formats & parsing (zero-alloc parsers + wire helpers).
+//
+// Zero-alloc parsers and wire-format helpers for the HTTP surface:
+//   - headers.rs       zero-alloc packed-header parser (HeaderRefs)
+//   - method.rs        HTTP method classification
+//   - http_parser.rs   HTTP request line + headers → packed request
+//   - cookie_parser.rs cookie header → packed pairs
+//   - query_parser.rs  query/form-string → packed pairs
+//   - form.rs          x-www-form-urlencoded body parser (FormParser instance)
+//   - media_type.rs    Content-Type parser + wildcard matching instances
+//   - url_codec.rs     percent-encoding encode/decode
+//   - url_join.rs      RFC 3986 url_resolve + query builder (UrlBuilder)
+//   - etag.rs          HTTP cache semantics (etag / conditional / 304)
+//   - http_date.rs     HTTP-date (IMF-fixdate) format + parse
+//   - accept.rs        Accept-Encoding negotiation (AcceptNegotiator)
+//   - mime_lookup.rs   extension → MIME type (phf table)
+//   - multipart.rs     multipart/form-data parser (+ limits)
+
+pub mod accept;
+pub mod cookie_parser;
+pub mod etag;
+pub mod form;
+pub mod headers;
+pub mod http_date;
+pub mod http_parser;
+pub mod media_type;
+pub mod method;
+pub mod mime_lookup;
+pub mod multipart;
+pub mod query_parser;
+pub mod url_codec;
+pub mod url_join;