@lithia-js/native 1.0.0-canary.2 → 1.0.0-canary.3

package/src/events/transformer.rs

@@ -1,78 +0,0 @@
-use regex::Regex;
-
-pub trait PathTransformer {
-    /// Normalize a file path by removing extensions, groups, and normalizing
-    /// separators.
-    fn normalize(&self, path: &str) -> String;
-
-    /// Normalize a path and apply an optional global prefix, returning a
-    /// value that always starts with a leading slash.
-    fn normalize_path(&self, path: &str, global_prefix: &str) -> String;
-
-    /// Clone the transformer as a boxed trait object.
-    fn clone_box(&self) -> Box<dyn PathTransformer>;
-}
-
-#[derive(Clone)]
-pub struct NativeEventTransformer {
-    remove_ext: Regex,
-    remove_groups: Regex,
-}
-
-impl NativeEventTransformer {
-    pub fn new() -> Self {
-        Self {
-            remove_ext: Regex::new(r"\.[A-Za-z0-9]+$").unwrap(),
-            remove_groups: Regex::new(r"\(([^(/\\]+)\)[/\\]").unwrap(),
-        }
-    }
-}
-
-impl PathTransformer for NativeEventTransformer {
-    /// Normalize an event file path: remove extension, remove groups and
-    /// normalize separators to `/`.
-    fn normalize(&self, path: &str) -> String {
-        let mut s = path.to_string();
-        s = self.remove_ext.replace(&s, "").to_string();
-        s = self.remove_groups.replace_all(&s, "").to_string();
-        s.replace('\\', "/")
-    }
-
-    /// Normalize a path and apply an optional global prefix, returning a
-    /// value that always starts with a leading slash.
-    fn normalize_path(&self, path: &str, global_prefix: &str) -> String {
-        let combined = if global_prefix.is_empty() {
-            path.to_string()
-        } else {
-            format!("{}/{}", global_prefix.trim_end_matches('/'), path.trim_start_matches('/'))
-        };
-
-        let no_trailing = if combined.ends_with('/') && combined.len() > 1 {
-            combined.trim_end_matches('/').to_string()
-        } else {
-            combined
-        };
-
-        if no_trailing.starts_with('/') {
-            no_trailing
-        } else {
-            format!("/{}", no_trailing)
-        }
-    }
-
-     fn clone_box(&self) -> Box<dyn PathTransformer> {
-        Box::new(self.clone())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn normalize_basic() {
-        let t = NativeEventTransformer::new();
-        assert_eq!(t.normalize("app/events/chat/message.ts"), "app/events/chat/message");
-        assert_eq!(t.normalize("(v1)/events/connection.ts"), "events/connection");
-    }
-}

package/src/lib.rs

@@ -1,54 +0,0 @@
-//! N-API bindings exported by the native crate.
-//!
-//! This module exposes a small surface area to the host (Node) so JavaScript
-//! code can invoke the native builder and scanner implemented in Rust.
-//! Prefer using the higher-level functions exported here rather than calling
-//! into the modules directly from the host.
-
-use napi_derive::napi;
-
-mod builder;
-mod router;
-mod scanner;
-mod events;
-
-/// Compile the project and emit artifacts.
-///
-/// This re-export exposes the native `build_project` entrypoint implemented
-/// in the `builder` module. The function is intended to be invoked from the
-/// host via N-API and performs scanning, compilation and manifest emission.
-pub use builder::build_project;
-
-/// Route and manifest types produced by the native router processor.
-pub use router::{Route, RoutesManifest};
-
-/// Scanner types returned by `scan_dir`.
-pub use scanner::{FileInfo, ScanOptions};
-
-use crate::scanner::FileScanner;
-
-/// Scan a directory tree for files matching the provided `path_components`.
-///
-/// `path_components` is a vector of path segments used as roots for the
-/// scanner (for example `["examples/1-basic-api"]`). `options` may include
-/// include/ignore globs. Returns a list of `FileInfo` describing discovered
-/// files or an error which is converted into a `napi::Error` for the host.
-#[napi]
-pub fn scan_dir(
-  path_components: Vec<String>,
-  options: Option<ScanOptions>,
-) -> napi::Result<Vec<FileInfo>> {
-  let scanner = scanner::NativeFileScanner::new();
-  scanner
-    .scan_dir(&path_components, options)
-    .map_err(|e| napi::Error::from_reason(format!("scan failed: {}", e)))
-}
-
-/// Return the native crate version embedded at compile time.
-///
-/// This returns the value of `CARGO_PKG_VERSION` so the host can verify the
-/// native binary version matches expectations.
-#[napi]
-pub fn schema_version() -> &'static str {
-  env!("CARGO_PKG_VERSION")
-}

package/src/router/convention.rs

@@ -1,239 +0,0 @@
-//! Route filename conventions and helpers.
-//!
-//! This module defines how route filenames are interpreted by the framework.
-//! It provides:
-//! - `RouteConvention` trait used to normalize filesystem paths and extract
-//!   optional HTTP method suffixes.
-//! - `NativeRouteConvention` default implementation that follows the project's
-//!   filename conventions (e.g. `route.get.ts`, route groups, dynamic
-//!   segments).
-//!
-//! The convention is intentionally small and pluggable so the routing
-//! behaviour can be adapted for different project layouts.
-
-use regex::Regex;
-
-use crate::router::transformer::{NativePathTransformer, PathTransformer};
-
-/// Trait that defines how filenames are converted into runtime route paths.
-/// Implementors should remove route-specific filename suffixes and perform
-/// any normalization required before the `PathTransformer` is applied.
-pub trait RouteConvention {
-    /// Transform a filesystem location into a normalized route path.
-    ///
-    /// The returned path should include a leading `/`.
-    fn transform_path(&self, path: &str) -> String;
-
-    /// Extract an optional HTTP method suffix from a filename and return the
-    /// sanitized path alongside the detected method.
-    fn extract_method(&self, path: &str) -> ExtractedMethod;
-}
-
-/// Supported HTTP method suffixes that can be encoded in filenames.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum MatchedMethodSuffix {
-    Delete,
-    Get,
-    Head,
-    Options,
-    Patch,
-    Post,
-    Put,
-}
-
-impl MatchedMethodSuffix {
-    /// Parse a method name (case-insensitive) into a `MatchedMethodSuffix`.
-    pub fn from_str(method: &str) -> Option<Self> {
-        match method.to_lowercase().as_str() {
-            "delete" => Some(MatchedMethodSuffix::Delete),
-            "get" => Some(MatchedMethodSuffix::Get),
-            "head" => Some(MatchedMethodSuffix::Head),
-            "options" => Some(MatchedMethodSuffix::Options),
-            "patch" => Some(MatchedMethodSuffix::Patch),
-            "post" => Some(MatchedMethodSuffix::Post),
-            "put" => Some(MatchedMethodSuffix::Put),
-            _ => None,
-        }
-    }
-
-    /// Return the uppercase HTTP method string (e.g. `GET`).
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            MatchedMethodSuffix::Delete => "DELETE",
-            MatchedMethodSuffix::Get => "GET",
-            MatchedMethodSuffix::Head => "HEAD",
-            MatchedMethodSuffix::Options => "OPTIONS",
-            MatchedMethodSuffix::Patch => "PATCH",
-            MatchedMethodSuffix::Post => "POST",
-            MatchedMethodSuffix::Put => "PUT",
-        }
-    }
-}
-
-/// Result of extracting an optional method suffix from a filename.
-#[derive(Debug)]
-pub struct ExtractedMethod {
-    /// Detected method if the filename contained a method suffix.
-    pub method: Option<MatchedMethodSuffix>,
-
-    /// The sanitized path with the method suffix removed. Always starts with
-    /// a leading `/`.
-    pub updated_path: String,
-}
-
-/// Default route filename convention implementation.
-/// Recognizes filenames like `/users/route.ts` and `/users/route.post.ts` and
-/// removes the convention-specific suffixes. It delegates general path
-/// transformations (groups, dynamic segments, extension removal) to a
-/// `PathTransformer`.
-pub struct NativeRouteConvention {
-    route_regex: Regex,
-    transformer: Box<dyn PathTransformer>,
-}
-
-impl NativeRouteConvention {
-    /// Create a new `NativeRouteConvention`.
-    /// `transformer` can be used to inject a custom `PathTransformer`; if
-    /// omitted the default `NativePathTransformer` is used.
-    pub fn new(transformer: Option<Box<dyn PathTransformer>>) -> Self {
-        Self {
-            // Allow matching "route.get.ts" at the start of string OR after a slash
-            route_regex: Regex::new(
-                r"(^|/)route(\.(delete|get|head|options|patch|post|put))?\.(ts|js)$",
-            )
-            .unwrap(),
-            transformer: transformer.unwrap_or_else(|| Box::new(NativePathTransformer::new())),
-        }
-    }
-}
-
-impl RouteConvention for NativeRouteConvention {
-    fn transform_path(&self, path: &str) -> String {
-        let mut result = path.to_string();
-
-        // Normalize to use forward slashes first
-        result = result.replace('\\', "/");
-
-        // Remove /route.ts and /route.{method}.ts (convention-specific)
-        result = self.route_regex.replace(&result, "").to_string();
-
-        // Delegate generic transformations to transformer
-        result = self.transformer.transform_file_path(&result);
-
-        // Ensure leading slash
-        if !result.starts_with('/') {
-            result = format!("/{}", result);
-        }
-
-        result
-    }
-
-    fn extract_method(&self, path: &str) -> ExtractedMethod {
-        if let Some(caps) = self.route_regex.captures(path) {
-            let method = caps
-                .get(3) // Capture group 3 is the method name (without dot)
-                .and_then(|m| MatchedMethodSuffix::from_str(m.as_str()));
-
-            let mut updated_path = self.route_regex.replace(path, "").to_string();
-
-            // Ensure leading slash
-            if !updated_path.starts_with('/') {
-                updated_path = format!("/{}", updated_path);
-            }
-
-            return ExtractedMethod { method, updated_path };
-        }
-
-        let mut updated_path = path.to_string();
-
-        // Ensure leading slash
-        if !updated_path.starts_with('/') {
-            updated_path = format!("/{}", updated_path);
-        }
-
-        ExtractedMethod { method: None, updated_path }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn convention() -> NativeRouteConvention {
-        NativeRouteConvention::new(None)
-    }
-
-    #[test]
-    fn transform_removes_route_ts() {
-        let c = convention();
-        assert_eq!(c.transform_path("users/route.ts"), "/users");
-    }
-
-    #[test]
-    fn transform_removes_method_suffix() {
-        let c = convention();
-        assert_eq!(c.transform_path("users/route.get.ts"), "/users");
-    }
-
-    #[test]
-    fn transform_removes_route_groups() {
-        let c = convention();
-        assert_eq!(c.transform_path("(v1)/users/route.ts"), "/users");
-    }
-
-    #[test]
-    fn transform_dynamic_segments() {
-        let c = convention();
-        assert_eq!(c.transform_path("users/[id]/route.ts"), "/users/:id");
-    }
-
-    #[test]
-    fn transform_normalizes_windows_separators() {
-        let c = convention();
-        assert_eq!(c.transform_path(r"users\[id]\route.ts"), "/users/:id");
-    }
-
-    #[test]
-    fn transform_ensures_leading_slash() {
-        let c = convention();
-        assert_eq!(c.transform_path("users/route.ts"), "/users");
-    }
-
-    #[test]
-    fn extract_method_from_route_filename() {
-        let c = convention();
-        let extracted = c.extract_method("users/route.post.ts");
-        assert_eq!(extracted.method, Some(MatchedMethodSuffix::Post));
-        assert_eq!(extracted.updated_path, "/users");
-    }
-
-    #[test]
-    fn extract_method_without_method_suffix() {
-        let c = convention();
-        let extracted = c.extract_method("users/route.ts");
-        assert_eq!(extracted.method, None);
-        assert_eq!(extracted.updated_path, "/users");
-    }
-
-    #[test]
-    fn extract_then_transform_produces_clean_route() {
-        let c = convention();
-
-        let extracted = c.extract_method("/(auth)/users/[id]/route.put.ts");
-        let path = c.transform_path(&extracted.updated_path);
-
-        assert_eq!(extracted.method, Some(MatchedMethodSuffix::Put));
-        assert_eq!(path, "/users/:id");
-    }
-
-    #[test]
-    fn full_static_route_pipeline() {
-        let c = convention();
-
-        let extracted = c.extract_method("/health/route.ts");
-        let path = c.transform_path(&extracted.updated_path);
-
-        assert_eq!(extracted.method, None);
-        assert_eq!(path, "/health");
-    }
-}

package/src/router/mod.rs

@@ -1,118 +0,0 @@
-//! Router core types and interop structures.
-//!
-//! This module defines the small set of types used by the router and the
-//! native build pipeline to represent discovered routes and the manifest
-//! exported to the host environment (Node). It exposes:
-//! - `Route`: serializable representation exposed to JavaScript via N-API.
-//! - `RoutesManifest`: top-level manifest object sent to the host.
-//! - `RouteCore`: internal representation used inside the Rust codebase.
-
-use std::fs;
-
-use napi_derive::napi;
-use serde::Serialize;
-
-use crate::{builder::config::BuildConfig, router::{convention::MatchedMethodSuffix, processor::{NativeRouteProcessor, RouteProcessor}}, scanner::FileScanner, schema_version};
-
-pub mod convention;
-pub mod processor;
-pub mod transformer;
-
-/// Serializable route representation sent to the host (N-API).
-/// Fields are camel-cased to be idiomatic on the JavaScript side.
-#[napi(object)]
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Route {
-    /// Uppercase HTTP method name, e.g. `GET` or `POST`, when present.
-    pub method: Option<String>,
-
-    /// Normalized route path (always starting with `/`).
-    pub path: String,
-
-    /// True when the route contains dynamic segments.
-    pub dynamic: bool,
-
-    /// Absolute filesystem path to the source file backing the route.
-    pub file_path: String,
-
-    /// Generated route matching regex as a string.
-    pub regex: String,
-}
-
-/// Manifest containing all discovered routes, serializable to the host.
-#[napi(object)]
-#[derive(Serialize)]
-pub struct RoutesManifest {
-    /// Manifest version string.
-    pub version: String,
-
-    /// List of routes.
-    pub routes: Vec<Route>,
-}
-
-/// Internal representation of a route used within Rust code.
-/// `RouteCore` contains a typed `MatchedMethodSuffix` for internal routing
-/// logic; it is converted to the exported `Route` when communicating with the
-/// host.
-pub struct RouteCore {
-    pub method: Option<MatchedMethodSuffix>,
-    pub path: String,
-    pub dynamic: bool,
-    pub file_path: String,
-    pub regex: String,
-}
-
-impl From<RouteCore> for Route {
-    fn from(core: RouteCore) -> Self {
-        Self {
-            method: core.method.map(|m| m.as_str().to_string()),
-            path: core.path,
-            dynamic: core.dynamic,
-            file_path: core.file_path,
-            regex: core.regex,
-        }
-    }
-}
-
-
-pub fn write_routes_manifest(config: &BuildConfig) -> Result<(), String> {
-    let routes_path = config.out_root.join("app").join("routes");
-    if !routes_path.exists() {
-        return Ok(());
-    }
-
-    let route_files = crate::scanner::NativeFileScanner::new()
-        .scan_dir(
-            &[
-                config.output_path_str(),
-                "app".to_string(),
-                "routes".to_string(),
-            ],
-            Some(crate::scanner::ScanOptions {
-                include: Some(vec!["**/*.js".to_string()]),
-                ignore: None,
-            }),
-        )
-        .map_err(|e| format!("scan failed: {}", e))?;
-
-    let processor = NativeRouteProcessor::new(None, None);
-
-    let version = schema_version().to_string();
-    let routes: Vec<Route> = route_files
-        .iter()
-        .map(|file| processor.process_route_file(file))
-        .filter(|route| route.method.is_some())
-        .map(Route::from)
-        .collect();
-
-    let manifest = RoutesManifest { version, routes };
-
-    let json = serde_json::to_string(&manifest)
-        .map_err(|e| format!("Failed to serialize routes: {}", e))?;
-
-    fs::write(config.out_root.join("routes.json"), json)
-        .map_err(|e| format!("Failed to write file: {}", e))?;
-
-    Ok(())
-}

package/src/router/processor.rs

@@ -1,201 +0,0 @@
-//! Route file processor utilities.
-//!
-//! This module exposes the `RouteProcessor` trait and a concrete
-//! `NativeRouteProcessor` implementation. The processor is responsible for
-//! converting a scanned filesystem `FileInfo` (a file that follows the route
-//! file conventions) into a `RouteCore` structure used by the router.
-//!
-//! Behaviour highlights:
-//! - Extracts optional HTTP method suffix (e.g. `route.post.ts`).
-//! - Transforms filesystem path patterns into normalized runtime paths
-//!   (e.g. `users/[id]/route.ts` -> `/users/:id`).
-//! - Removes trailing `/index` segments and ensures leading slash.
-//! - Produces a regex string for route matching and indicates whether a
-//!   route is dynamic.
-
-use crate::scanner::FileInfo;
-use crate::router::{
-    convention::{NativeRouteConvention, RouteConvention},
-    transformer::{NativePathTransformer, PathTransformer},
-    RouteCore,
-};
-
-/// Trait that converts a discovered `FileInfo` into framework `RouteCore`.
-/// Implementations encapsulate how filenames and paths are interpreted as
-/// runtime routes.
-pub trait RouteProcessor {
-    /// Process a scanned `file` and return a `RouteCore` describing the
-    /// route's HTTP method (if any), normalized path, whether it's dynamic,
-    /// the original file path and the generated regex.
-    fn process_route_file(&self, file: &FileInfo) -> RouteCore;
-}
-
-/// Native implementation of `RouteProcessor` used by the default router.
-/// `NativeRouteProcessor` composes a `PathTransformer` and a
-/// `RouteConvention` to implement the file -> route conversion logic. Both
-/// components are replaceable for testing or customization.
-pub struct NativeRouteProcessor {
-    transformer: Box<dyn PathTransformer>,
-    convention: Box<dyn RouteConvention>,
-}
-
-impl NativeRouteProcessor {
-    /// Create a new `NativeRouteProcessor`.
-    /// `opt_transformer` and `opt_convention` are optional boxed trait
-    /// instances. When omitted, default native implementations are used.
-    pub fn new(
-        opt_transformer: Option<Box<dyn PathTransformer>>,
-        opt_convention: Option<Box<dyn RouteConvention>>,
-    ) -> Self {
-        let transformer = opt_transformer.unwrap_or_else(|| Box::new(NativePathTransformer::new()));
-        let convention = opt_convention
-            .unwrap_or_else(|| Box::new(NativeRouteConvention::new(Some(transformer.clone_box()))));
-
-        Self {
-            transformer,
-            convention,
-        }
-    }
-}
-
-impl RouteProcessor for NativeRouteProcessor {
-    /// Convert a filesystem `FileInfo` into a `RouteCore`.
-    /// Steps:
-    /// 1. Use the `RouteConvention` to extract any method suffix and the
-    ///    canonical path.
-    /// 2. Normalize the path (apply prefix, remove trailing `/index`, ensure
-    ///    leading slash).
-    /// 3. Determine whether the route is dynamic and generate the route regex.
-    fn process_route_file(&self, file: &FileInfo) -> RouteCore {
-        let extracted = self.convention.extract_method(&file.path);
-        let mut path = self.convention.transform_path(&extracted.updated_path);
-
-        path = self.transformer.normalize_path(&path, "");
-
-        let dynamic = self.transformer.is_dynamic_route(&path);
-        let regex = self.transformer.generate_route_regex(&path);
-
-        RouteCore {
-            method: extracted.method,
-            path,
-            dynamic,
-            file_path: file.full_path.clone(),
-            regex,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::router::convention::MatchedMethodSuffix;
-
-    fn processor() -> NativeRouteProcessor {
-        NativeRouteProcessor::new(None, None)
-    }
-
-    fn file_info(path: &str, full_path: &str) -> FileInfo {
-        FileInfo {
-            path: path.to_string(),
-            full_path: full_path.to_string(),
-        }
-    }
-
-    #[test]
-    fn processes_static_routes_with_methods() {
-        let p = processor();
-        
-        // Simple route without method
-        let route = p.process_route_file(&file_info("users/route.ts", "/project/src/users/route.ts"));
-        assert_eq!(route.path, "/users");
-        assert_eq!(route.method, None);
-        assert!(!route.dynamic);
-        assert_eq!(route.file_path, "/project/src/users/route.ts");
-        assert_eq!(route.regex, r"^\/users$");
-
-        // Route with POST method
-        let route = p.process_route_file(&file_info("users/route.post.ts", "/project/src/users/route.post.ts"));
-        assert_eq!(route.path, "/users");
-        assert_eq!(route.method, Some(MatchedMethodSuffix::Post));
-        assert!(!route.dynamic);
-        assert_eq!(route.file_path, "/project/src/users/route.post.ts");
-
-        // Route with GET method
-        let route = p.process_route_file(&file_info("about/route.get.ts", "/project/src/about/route.get.ts"));
-        assert_eq!(route.path, "/about");
-        assert_eq!(route.method, Some(MatchedMethodSuffix::Get));
-        assert_eq!(route.regex, r"^\/about$");
-    }
-
-    #[test]
-    fn processes_dynamic_routes() {
-        let p = processor();
-        
-        // Single dynamic segment
-        let route = p.process_route_file(&file_info("users/[id]/route.ts", "/project/src/users/[id]/route.ts"));
-        assert_eq!(route.path, "/users/:id");
-        assert_eq!(route.method, None);
-        assert!(route.dynamic);
-        assert_eq!(route.file_path, "/project/src/users/[id]/route.ts");
-        assert_eq!(route.regex, r"^\/users\/([^\/]+)$");
-
-        // Multiple dynamic segments with method
-        let route = p.process_route_file(&file_info(
-            "users/[userId]/posts/[postId]/route.get.ts",
-            "/project/src/users/[userId]/posts/[postId]/route.get.ts",
-        ));
-        assert_eq!(route.path, "/users/:userId/posts/:postId");
-        assert_eq!(route.method, Some(MatchedMethodSuffix::Get));
-        assert!(route.dynamic);
-        assert_eq!(route.file_path, "/project/src/users/[userId]/posts/[postId]/route.get.ts");
-        assert_eq!(route.regex, r"^\/users\/([^\/]+)\/posts\/([^\/]+)$");
-    }
-
-    #[test]
-    fn processes_index_routes_as_regular_routes() {
-        let p = processor();
-        
-        // Root "index" is just "index" now
-        let route = p.process_route_file(&file_info("index/route.ts", "/project/src/index/route.ts"));
-        assert_eq!(route.path, "/index");
-        assert_eq!(route.method, None);
-        assert!(!route.dynamic);
-
-        // Nested index
-        let route = p.process_route_file(&file_info("users/index/route.ts", "/project/src/users/index/route.ts"));
-        assert_eq!(route.path, "/users/index");
-    }
-
-    #[test]
-    fn processes_route_groups() {
-        let p = processor();
-        
-        // Simple group
-        let route = p.process_route_file(&file_info("(v1)/users/route.ts", "/project/src/(v1)/users/route.ts"));
-        assert_eq!(route.path, "/users");
-        assert!(!route.dynamic);
-        assert_eq!(route.file_path, "/project/src/(v1)/users/route.ts");
-
-        // Group with dynamic route and method
-        let route = p.process_route_file(&file_info(
-            "(api)/users/[id]/route.delete.ts",
-            "/project/src/(api)/users/[id]/route.delete.ts",
-        ));
-        assert_eq!(route.path, "/users/:id");
-        assert_eq!(route.method, Some(MatchedMethodSuffix::Delete));
-        assert!(route.dynamic);
-        assert_eq!(route.file_path, "/project/src/(api)/users/[id]/route.delete.ts");
-    }
-
-    #[test]
-    fn handles_windows_paths() {
-        let p = processor();
-        let route = p.process_route_file(&file_info(
-            r"users\[id]\route.ts",
-            r"C:\project\src\users\[id]\route.ts",
-        ));
-        assert_eq!(route.path, "/users/:id");
-        assert!(route.dynamic);
-        assert_eq!(route.file_path, r"C:\project\src\users\[id]\route.ts");
-    }
-}