@lithia-js/native 1.0.0-canary.2

package/src/builder/sourcemap.rs

@@ -0,0 +1,36 @@
+use std::path::Path;
+
+/// Write compiled `code` and its optional `source_map` to disk.
+///
+/// When `source_map` is `Some`, this function writes both the `.js` file and
+/// the corresponding `.js.map` alongside it. The `.js` file will include a
+/// `//# sourceMappingURL=<file>.map` comment so runtimes and devtools can
+/// automatically discover the map. If `source_map` is `None`, only the
+/// `.js` file is written.
+pub fn write_sourcemap_and_code(output: &Path, code: &str, source_map: Option<String>) -> Result<(), String> {
+    let map_file_name = format!(
+        "{}.map",
+        output
+            .file_name()
+            .ok_or("Invalid output file name")?
+            .to_string_lossy()
+    );
+
+    // When a sourcemap is present, append the sourceMappingURL comment.
+    let code_with_map = if source_map.is_some() {
+        format!("{}\n//# sourceMappingURL={}\n", code, map_file_name)
+    } else {
+        code.to_string()
+    };
+
+    std::fs::write(output, code_with_map)
+        .map_err(|e| format!("Failed to write output file: {}", e))?;
+
+    if let Some(map) = source_map {
+        let map_path = output.with_extension("js.map");
+        std::fs::write(&map_path, map)
+            .map_err(|e| format!("Failed to write sourcemap file: {}", e))?;
+    }
+
+    Ok(())
+}

package/src/builder/tests.rs

@@ -0,0 +1,78 @@
+use super::compiler::TypeScriptCompiler;
+use super::tsconfig::TsConfigOptions;
+use std::fs;
+use swc_ecma_ast::EsVersion;
+use tempfile::TempDir;
+
+#[test]
+fn test_compile_with_paths() {
+    let dir = TempDir::new().unwrap();
+    let root = dir.path();
+    
+    let src = root.join("src");
+    fs::create_dir(&src).unwrap();
+    
+    let services = src.join("services");
+    fs::create_dir(&services).unwrap();
+    
+    // Define target file that the alias points to
+    fs::write(services.join("user-service.ts"), "export class UserService {}").unwrap();
+    
+    // Define source file interacting with alias
+    let input_path = src.join("main.ts");
+    fs::write(&input_path, "import { UserService } from '@/services/user-service'; console.log(UserService);").unwrap();
+    
+    let dist = root.join("dist");
+    fs::create_dir(&dist).unwrap();
+    let output_path = dist.join("main.js");
+
+    // Setup compiler with path mapping
+    // Mapping: "@/*" -> ["./src/*"]
+    // BaseUrl: root
+    let ts_config = TsConfigOptions {
+        emit_sourcemap: false,
+        target: EsVersion::Es2020,
+        base_url: Some(root.to_path_buf()),
+        paths: vec![("@/*".to_string(), vec!["./src/*".to_string()])],
+    };
+
+    let compiler = TypeScriptCompiler::new(ts_config);
+    
+    // Compile
+    compiler.compile_file(&input_path, &output_path).expect("compile failed");
+    
+    // Check output based on behavior
+    let js = fs::read_to_string(&output_path).unwrap();
+    
+    assert!(js.contains(r#"require("./services/user-service")"#), "Output JS did not contain expected relative require. Got:\n{}", js);
+}
+
+#[test]
+fn test_compile_no_paths() {
+     let dir = TempDir::new().unwrap();
+     let root = dir.path();
+     let src = root.join("src");
+     fs::create_dir(&src).unwrap();
+     
+     let input_path = src.join("index.ts");
+     // Normal relative import shouldn't change
+     fs::write(&input_path, "import { x } from './utils'; console.log(x);").unwrap();
+     fs::write(src.join("utils.ts"), "export const x = 1;").unwrap();
+     
+     let dist = root.join("dist");
+     fs::create_dir(&dist).unwrap();
+     let output_path = dist.join("index.js");
+
+     let ts_config = TsConfigOptions {
+         emit_sourcemap: false,
+         target: EsVersion::Es2020,
+         base_url: None,
+         paths: vec![],
+     };
+
+     let compiler = TypeScriptCompiler::new(ts_config);
+     compiler.compile_file(&input_path, &output_path).expect("compile failed");
+     
+     let js = fs::read_to_string(&output_path).unwrap();
+     assert!(js.contains(r#"require("./utils")"#));
+}

package/src/builder/tsconfig.rs

@@ -0,0 +1,100 @@
+use serde_json::Value;
+use std::path::Path;
+
+use swc_ecma_ast::EsVersion;
+
+/// Parsed TypeScript configuration options relevant for the native builder.
+/// This struct captures only the small subset of `tsconfig.json` that the
+/// builder needs: whether to emit source maps and the target ECMAScript
+/// version.
+#[derive(Debug, Clone)]
+pub struct TsConfigOptions {
+    /// Whether to generate source maps during compilation.
+    pub emit_sourcemap: bool,
+
+    /// SWC `EsVersion` target inferred from `compilerOptions.target`.
+    pub target: EsVersion,
+
+    /// Base URL for non-relative module resolution.
+    pub base_url: Option<std::path::PathBuf>,
+
+    /// Path mappings for module resolution.
+    pub paths: Vec<(String, Vec<String>)>,
+}
+
+/// Parse a `tsconfig.json` file from `path` (optional) and return
+/// `TsConfigOptions` used by the builder.
+/// 
+/// If `path` is `None`, the function will attempt to read `tsconfig.json`
+/// from the current working directory. If the file does not exist or cannot be
+/// parsed, reasonable defaults are returned and an `Ok` result is produced
+/// (the builder treats missing or invalid config as non-fatal by design).
+pub fn parse_tsconfig(path: Option<&Path>) -> Result<TsConfigOptions, String> {
+    let default_config = TsConfigOptions {
+        emit_sourcemap: true,
+        target: EsVersion::Es2022,
+        base_url: None,
+        paths: Vec::new(),
+    };
+
+    let path = match path {
+        Some(p) => p.to_path_buf(),
+        None => {
+            let cwd = std::env::current_dir().unwrap();
+            cwd.join("tsconfig.json")
+        }
+    };
+
+    if !path.exists() {
+        // do not print from native side; using default config
+        return Ok(default_config);
+    }
+
+    let s = std::fs::read_to_string(&path)
+        .map_err(|e| format!("failed to read tsconfig {}: {}", path.display(), e))?;
+
+    let v: Value = serde_json::from_str(&s)
+        .map_err(|e| format!("failed to parse tsconfig {}: {}", path.display(), e))?;
+
+    // Hardcoded options as per requirements
+    let emit_sourcemap = true;
+    let target = EsVersion::Es2022;
+    
+    let mut base_url = None;
+    let mut paths = Vec::new();
+
+    if let Some(opts) = v.get("compilerOptions") {
+        // Enforce sourceMap and target:
+        // We do *not* read sourceMap or target from tsconfig anymore.
+        // They are always true and ES2022 respectively.
+
+        if let Some(base) = opts.get("baseUrl").and_then(|v| v.as_str()) {
+             let tsconfig_dir = path.parent().unwrap_or_else(|| Path::new("."));
+             base_url = Some(tsconfig_dir.join(base));
+        }
+
+        if let Some(p) = opts.get("paths").and_then(|v| v.as_object()) {
+            // implicit baseUrl if paths are present but baseUrl is missing
+            if base_url.is_none() {
+                 let tsconfig_dir = path.parent().unwrap_or_else(|| Path::new("."));
+                 base_url = Some(tsconfig_dir.to_path_buf());
+            }
+
+            for (k, v) in p {
+                let targets = if let Some(arr) = v.as_array() {
+                    arr.iter().filter_map(|x| x.as_str().map(|s| s.to_string())).collect()
+                } else {
+                    vec![]
+                };
+                paths.push((k.clone(), targets));
+            }
+        }
+    }
+
+    Ok(TsConfigOptions {
+        emit_sourcemap,
+        target,
+        base_url,
+        paths,
+    })
+}

package/src/builder/types.rs

@@ -0,0 +1,53 @@
+/// Result information for a single compiled file.
+/// `CompileResult` contains small statistics about an individual compilation
+/// unit such as the `output_path` produced and the time taken in
+/// milliseconds. Fields are public to allow the caller to serialize or log
+/// results as needed.
+#[derive(Debug, Clone)]
+pub struct CompileResult {
+    #[allow(dead_code)]
+    /// Absolute or relative filesystem path to the compiled output.
+    pub output_path: String,
+    #[allow(dead_code)]
+    /// Duration of the compilation in milliseconds.
+    pub duration_ms: f64,
+}
+
+/// Overall build result with statistics.
+/// `BuildResult` aggregates per-file `CompileResult` entries and provides a
+/// simple API to inspect whether failures occurred, and totals such as the
+/// number of files compiled and total duration.
+#[derive(Debug)]
+pub struct BuildResult {
+    /// Number of files that were processed during the build.
+    pub files_compiled: usize,
+
+    /// Collected failure messages for files that failed to compile.
+    pub failures: Vec<String>,
+
+    /// Timeline entries for successful compilations.
+    pub timings: Vec<CompileResult>,
+
+    /// Total elapsed build time in milliseconds.
+    pub total_duration_ms: f64,
+}
+
+impl BuildResult {
+    pub fn new(total_duration_ms: f64) -> Self {
+        Self {
+            files_compiled: 0,
+            failures: Vec::new(),
+            timings: Vec::new(),
+            total_duration_ms,
+        }
+    }
+
+    pub fn has_failures(&self) -> bool {
+        !self.failures.is_empty()
+    }
+
+    #[allow(dead_code)]
+    pub fn success_count(&self) -> usize {
+        self.files_compiled - self.failures.len()
+    }
+}

package/src/events/convention.rs

@@ -0,0 +1,36 @@
+use crate::events::transformer::{NativeEventTransformer, PathTransformer};
+
+/// Trait that defines how filesystem event filenames are converted into a
+/// normalized event identifier used by the runtime.
+pub trait EventConvention {
+    /// Transform a filesystem path (relative, may include `app/events/...`)
+    /// into a normalized event path (no extension, forward slashes).
+    fn transform_path(&self, path: &str) -> String;
+}
+
+/// Native event convention implementation that reuses the router's
+/// `PathTransformer` for common filesystem transformations and then
+/// returns a normalized path used to derive the event name.
+pub struct NativeEventConvention {
+    transformer: Box<dyn PathTransformer>,
+}
+
+impl NativeEventConvention {
+    pub fn new(transformer: Option<Box<dyn PathTransformer>>) -> Self {
+        let transformer = transformer.unwrap_or_else(|| Box::new(NativeEventTransformer::new()));
+        Self { transformer }
+    }
+}
+
+impl EventConvention for NativeEventConvention {
+    fn transform_path(&self, path: &str) -> String {
+        // Remove leading prefix if present
+        let mut p = path.trim_start_matches("app/events/").to_string();
+
+        // Delegate file -> normalized path transformations to the event transformer
+        p = self.transformer.normalize(&p);
+
+        // Ensure forward slashes
+        p.replace('\\', "/")
+    }
+}

package/src/events/mod.rs

@@ -0,0 +1,87 @@
+use napi_derive::napi;
+use serde::Serialize;
+
+use crate::builder::config::BuildConfig;
+use crate::scanner::FileScanner;
+use crate::schema_version;
+use std::fs;
+
+pub mod convention;
+pub mod processor;
+pub mod transformer;
+
+/// Serializable event representation sent to the host (N-API).
+#[napi(object)]
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Event {
+    /// Event name (e.g., "chat:message" or "connection")
+    pub name: String,
+
+    /// Absolute filesystem path to the compiled handler (JS) file.
+    pub file_path: String,
+
+    /// Optional namespace (e.g., "chat" for "chat:message").
+    pub namespace: Option<String>,
+}
+
+/// Manifest containing all discovered events, serializable to the host.
+#[napi(object)]
+#[derive(Serialize, Debug)]
+pub struct EventsManifest {
+    /// Manifest version string.
+    pub version: String,
+
+    /// List of events.
+    pub events: Vec<Event>,
+}
+
+/// Generate and write `events.json` manifest based on scanned TypeScript files.
+///
+/// Uses the already-scanned `ts_files` (source files) and the provided
+/// `BuildConfig` to map source files to their compiled output and produce the
+/// final manifest next to `routes.json`.
+pub fn write_events_manifest(config: &BuildConfig) -> Result<(), String> {
+    let events_path = config.out_root.join("app").join("events");
+    if !events_path.exists() {
+        return Ok(());
+    }
+
+    let event_files = crate::scanner::NativeFileScanner::new()
+        .scan_dir(
+            &[
+                config.output_path_str(),
+                "app".to_string(),
+                "events".to_string(),
+            ],
+            Some(crate::scanner::ScanOptions {
+                include: Some(vec!["**/*.js".to_string()]),
+                ignore: None,
+            }),
+        )
+        .map_err(|e| format!("scan failed: {}", e))?;
+
+    let processor = processor::NativeEventProcessor::new(None, None);
+    let events = processor.process(&event_files);
+
+    if events.is_empty() {
+        return Ok(());
+    }
+
+    let manifest = EventsManifest {
+        version: schema_version().to_string(),
+        events,
+    };
+
+    let json = serde_json::to_string(&manifest)
+        .map_err(|e| format!("Failed to serialize events: {}", e))?;
+
+    let out = config.out_root.join("events.json");
+    fs::write(&out, json)
+        .map_err(|e| format!("Failed to write events manifest {}: {}", out.display(), e))?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests;

package/src/events/processor.rs

@@ -0,0 +1,113 @@
+//! Event file processor utilities mirroring the router processor design.
+//!
+//! Converts scanned `FileInfo` entries for `app/events` into `Event`
+//! structures suitable for serialization into `events.json`.
+
+use crate::scanner::FileInfo;
+
+use crate::events::convention::{EventConvention, NativeEventConvention};
+use crate::events::transformer::{NativeEventTransformer, PathTransformer};
+use crate::events::Event;
+
+/// Trait that converts a discovered `FileInfo` into an `Event` structure.
+pub trait EventProcessor {
+    fn process_event_file(&self, file: &FileInfo) -> Event;
+}
+
+/// Native implementation of `EventProcessor` that composes a
+/// `PathTransformer` and an `EventConvention` similar to the route
+/// processor.
+pub struct NativeEventProcessor {
+    transformer: Box<dyn PathTransformer>,
+    convention: Box<dyn EventConvention>,
+}
+
+impl NativeEventProcessor {
+    /// Create a new `NativeEventProcessor`.
+    /// Optional components may be provided for testing.
+    pub fn new(
+        opt_transformer: Option<Box<dyn PathTransformer>>,
+        opt_convention: Option<Box<dyn EventConvention>>,
+    ) -> Self {
+        let transformer =
+            opt_transformer.unwrap_or_else(|| Box::new(NativeEventTransformer::new()));
+        let convention = opt_convention
+            .unwrap_or_else(|| Box::new(NativeEventConvention::new(Some(transformer.clone_box()))));
+
+        Self {
+            transformer,
+            convention,
+        }
+    }
+
+    /// Convenience: process a collection of files into events.
+    pub fn process(&self, files: &[FileInfo]) -> Vec<Event> {
+        files.iter().map(|f| self.process_event_file(f)).collect()
+    }
+}
+
+impl EventProcessor for NativeEventProcessor {
+    fn process_event_file(&self, file: &FileInfo) -> Event {
+        // Convert the scanned file path into a normalized event path using
+        // the convention and then apply the PathTransformer normalization
+        // (mirrors the route processor pipeline).
+        let intermediate = self.convention.transform_path(&file.path);
+        let normalized = self.transformer.normalize_path(&intermediate, "");
+
+        // Build event name: `a/b/c` -> `a:b:c` except for standalone names
+        let parts: Vec<&str> = normalized
+            .trim_start_matches('/')
+            .split('/')
+            .filter(|s| !s.is_empty())
+            .collect();
+        let event_name = if parts.is_empty() {
+            "".to_string()
+        } else if parts.len() == 1 {
+            parts[0].to_string()
+        } else {
+            let last = parts.last().unwrap();
+            if *last == "connection" || *last == "disconnect" {
+                last.to_string()
+            } else {
+                format!("{}:{}", parts[..parts.len() - 1].join(":"), last)
+            }
+        };
+
+        let namespace = if event_name.contains(":") {
+            Some(event_name.split(':').next().unwrap().to_string())
+        } else {
+            None
+        };
+
+        Event {
+            name: event_name,
+            file_path: file.full_path.clone(),
+            namespace,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::scanner::FileInfo;
+
+    fn file_info(path: &str, full: &str) -> FileInfo {
+        FileInfo {
+            path: path.to_string(),
+            full_path: full.to_string(),
+        }
+    }
+
+    #[test]
+    fn processor_creates_event() {
+        let p = NativeEventProcessor::new(None, None);
+        let f = file_info(
+            "app/events/chat/message.js",
+            "/out/app/events/chat/message.js",
+        );
+        let e = p.process_event_file(&f);
+        assert_eq!(e.name, "chat:message");
+        assert_eq!(e.namespace.unwrap(), "chat");
+    }
+}

package/src/events/tests.rs

@@ -0,0 +1,41 @@
+#[cfg(test)]
+mod tests {
+    use super::super::processor::NativeEventProcessor;
+    use crate::{events::processor::EventProcessor, scanner::FileInfo};
+    use std::fs;
+    use tempfile::TempDir;
+
+    #[test]
+    fn processor_generates_event_manifest_items() {
+        let temp = TempDir::new().unwrap();
+        let src_root = temp.path().join("src");
+        let out_root = temp.path().join("out");
+        fs::create_dir_all(&src_root).unwrap();
+        fs::create_dir_all(&out_root).unwrap();
+
+        // create a dummy tsconfig so BuildConfig::new can parse
+        fs::write(temp.path().join("tsconfig.json"), "{}").unwrap();
+
+        // Create a sample event file path entry
+        // Use compiled JS path as the processor expects files from the output
+        let relative = "app/events/chat/message.js".to_string();
+        let full = out_root.join(&relative).to_string_lossy().to_string();
+
+        // touch the compiled file on disk
+        fs::create_dir_all(std::path::Path::new(&full).parent().unwrap()).unwrap();
+        fs::write(&full, "module.exports = {};").unwrap();
+
+        let file_info = FileInfo {
+            path: relative.clone(),
+            full_path: full.clone(),
+        };
+
+        let processor = NativeEventProcessor::new(None, None);
+        let e = processor.process_event_file(&file_info);
+
+        assert_eq!(e.name, "chat:message");
+        assert_eq!(e.namespace.as_ref().unwrap(), "chat");
+        assert!(e.file_path.ends_with("message.js"));
+        assert_eq!(e.file_path, full);
+    }
+}

package/src/events/transformer.rs

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,54 @@
+//! 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")
+}