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

package/src/builder/mod.rs

@@ -1,126 +0,0 @@
-//! Native builder entrypoints and orchestration.
-//!
-//! This module exposes the `build_project` function which is invoked from the
-//! host (Node) via N-API. It wires together scanning, compilation and route
-//! manifest generation using the Rust-based SWC compiler integration.
-//!
-//! Exposes the native `build_project` entrypoint used by the host.
-
-use napi_derive::napi;
-use rayon::prelude::*;
-use std::{fs, time::Instant};
-
-pub mod compiler;
-pub mod config;
-pub mod sourcemap;
-pub mod tsconfig;
-pub mod types;
-
-#[cfg(test)]
-mod tests;
-
-use compiler::TypeScriptCompiler;
-use config::BuildConfig;
-use types::{BuildResult, CompileResult};
-
-#[napi]
-/// Build the project located at `source_root` and emit outputs to `out_root`.
-///
-/// This function is exported to the host via N-API and performs the full
-/// native compilation pipeline:
-/// 1. Reads build configuration from `source_root`.
-/// 2. Scans for TypeScript files matching `.ts`.
-/// 3. Compiles files (in parallel) using the embedded SWC-based compiler.
-/// 4. Aggregates compilation results and fails the build if there are errors.
-/// 5. If route files exist in the output, produces a `routes.json` manifest
-///    containing route metadata consumed by the runtime.
-///
-/// Errors are returned as `napi::Error` to be propagated to the host.
-/// High-level build entrypoint for the native TypeScript builder.
-///
-/// `build_project` coordinates scanning the source tree, applying route
-/// conventions, and producing a `RoutesManifest` that can be consumed by the
-/// runtime. Currently this function is a thin wrapper and may be expanded to
-/// run parallel compilation and emit artifacts to disk.
-pub fn build_project(source_root: String, out_root: String) -> napi::Result<()> {
-    let start = Instant::now();
-
-    // Load configuration
-    let config =
-        BuildConfig::new(source_root, out_root).map_err(napi::Error::from_reason)?;
-
-    fs::remove_dir_all(&config.out_root).ok();
-
-    // Scan TypeScript files using glob patterns
-    use crate::scanner::FileScanner;
-    let ts_files = crate::scanner::NativeFileScanner::new()
-        .scan_dir(
-            &[config.source_root_str()],
-            Some(crate::scanner::ScanOptions {
-                include: Some(vec!["**/*.ts".to_string()]),
-                ignore: Some(config.ignore_patterns.clone()),
-            }),
-        )
-        .map_err(|e| napi::Error::from_reason(format!("scan failed: {}", e)))?;
-
-    // Compile files in parallel
-    let compiler = TypeScriptCompiler::new(config.ts_config.clone());
-
-    let results: Vec<Result<CompileResult, String>> = ts_files
-        .par_iter()
-        .map(|file| {
-            let output_path = config.compute_output_path(&file.path);
-
-            if let Some(parent) = output_path.parent() {
-                std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
-            }
-
-            let file_start = Instant::now();
-            compiler
-                .compile_file(std::path::Path::new(&file.full_path), &output_path)
-                .map(|_| CompileResult {
-                    output_path: output_path.to_string_lossy().to_string(),
-                    duration_ms: file_start.elapsed().as_secs_f64() * 1000.0,
-                })
-        })
-        .collect();
-
-    // Aggregate results
-    let mut build_result = BuildResult::new(start.elapsed().as_secs_f64() * 1000.0);
-    build_result.files_compiled = ts_files.len();
-
-    for result in results {
-        match result {
-            Ok(timing) => build_result.timings.push(timing),
-            Err(e) => build_result.failures.push(e),
-        }
-    }
-
-    // Build summary is emitted to the host (Node) via the native API; avoid printing here.
-
-    if build_result.has_failures() {
-        let failures_msg = build_result
-            .failures
-            .iter()
-            .take(5)
-            .map(|e| e.as_str())
-            .collect::<Vec<_>>()
-            .join("\n\n");
-
-        return Err(napi::Error::from_reason(format!(
-            "Build completed with {} failures:\n\n{}",
-            build_result.failures.len(),
-            failures_msg
-        )));
-    }
-
-    build_result.total_duration_ms = start.elapsed().as_secs_f64() * 1000.0;
-
-    // Generate routes manifest using helper
-    crate::router::write_routes_manifest(&config).map_err(napi::Error::from_reason)?;
-
-    // Events manifest: build from already-scanned `ts_files` (no extra scan)
-    crate::events::write_events_manifest(&config).map_err(napi::Error::from_reason)?;
-
-    Ok(())
-}

package/src/builder/sourcemap.rs

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

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

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

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

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

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

@@ -1,113 +0,0 @@
-//! 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

@@ -1,41 +0,0 @@
-#[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);
-    }
-}