npm - @ezetgalaxy/titan - Versions diffs - 26.7.2 → 26.7.5 - Mend

@ezetgalaxy/titan 26.7.2 → 26.7.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/README.md +4 -1
package/index.js +488 -489
package/package.json +3 -3
package/templates/Dockerfile +17 -4
package/templates/_gitignore +25 -0
package/templates/package.json +1 -1
package/templates/server/action_map.json +3 -0
package/templates/server/actions/hello.jsbundle +45 -0
package/templates/server/routes.json +16 -0
package/templates/server/src/extensions.rs +433 -216
package/templates/server/src/main.rs +134 -68
package/titanpl-sdk/README.md +14 -6
package/titanpl-sdk/assets/titanpl-sdk.png +0 -0
package/titanpl-sdk/package.json +2 -1
package/titanpl-sdk/templates/Dockerfile +17 -4
package/titanpl-sdk/templates/server/src/extensions.rs +423 -218
package/titanpl-sdk/templates/server/src/main.rs +134 -68
package/scripts/make_dist.sh +0 -71

package/templates/server/src/main.rs CHANGED Viewed

@@ -1,28 +1,27 @@
-use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
 use anyhow::Result;
 use axum::{
-    body::{to_bytes, Body},
+    Router,
+    body::{Body, to_bytes},
     extract::State,
     http::{Request, StatusCode},
     response::{IntoResponse, Json},
     routing::any,
-    Router,
 };
 use serde_json::Value;
-use tokio::net::TcpListener;
 use std::time::Instant;
+use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
+use tokio::net::TcpListener;
 mod utils;
-mod extensions;
 mod action_management;
+mod extensions;
-use utils::{blue, white, yellow, green, gray, red};
-use extensions::{init_v8, inject_extensions};
 use action_management::{
-    resolve_actions_dir, find_actions_dir, match_dynamic_route,
-    DynamicRoute, RouteVal
+    DynamicRoute, RouteVal, find_actions_dir, match_dynamic_route, resolve_actions_dir,
 };
+use extensions::{init_v8, inject_extensions};
+use utils::{blue, gray, green, red, white, yellow};
 #[derive(Clone)]
 struct AppState {
@@ -45,7 +44,6 @@ async fn dynamic_handler_inner(
     State(state): State<AppState>,
     req: Request<Body>,
 ) -> impl IntoResponse {
     // ---------------------------
     // BASIC REQUEST INFO
     // ---------------------------
@@ -70,10 +68,7 @@ async fn dynamic_handler_inner(
             q.split('&')
                 .filter_map(|pair| {
                     let mut it = pair.splitn(2, '=');
-                    Some((
-                        it.next()?.to_string(),
-                        it.next().unwrap_or("").to_string(),
-                    ))
+                    Some((it.next()?.to_string(), it.next().unwrap_or("").to_string()))
                 })
                 .collect()
         })
@@ -83,7 +78,7 @@ async fn dynamic_handler_inner(
     // HEADERS & BODY
     // ---------------------------
     let (parts, body) = req.into_parts();
     let headers = parts
         .headers
         .iter()
@@ -92,9 +87,7 @@ async fn dynamic_handler_inner(
     let body_bytes = match to_bytes(body, usize::MAX).await {
         Ok(b) => b,
-        Err(_) => {
-            return (StatusCode::BAD_REQUEST, "Failed to read request body").into_response()
-        }
+        Err(_) => return (StatusCode::BAD_REQUEST, "Failed to read request body").into_response(),
     };
     let body_str = String::from_utf8_lossy(&body_bytes).to_string();
@@ -119,18 +112,32 @@ async fn dynamic_handler_inner(
             action_name = Some(name);
         } else if route.r#type == "json" {
             let elapsed = start.elapsed();
-            println!("{} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→ json"), gray(&format!("in {:.2?}", elapsed)));
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ json"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
             return Json(route.value.clone()).into_response();
         } else if let Some(s) = route.value.as_str() {
             let elapsed = start.elapsed();
-            println!("{} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→ reply"), gray(&format!("in {:.2?}", elapsed)));
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ reply"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
             return s.to_string().into_response();
         }
     }
     // Dynamic route
     if action_name.is_none() {
-        if let Some((action, p)) = match_dynamic_route(&method, &path, state.dynamic_routes.as_slice()) {
+        if let Some((action, p)) =
+            match_dynamic_route(&method, &path, state.dynamic_routes.as_slice())
+        {
             route_kind = "dynamic";
             route_label = action.clone();
             action_name = Some(action);
@@ -142,7 +149,13 @@ async fn dynamic_handler_inner(
         Some(a) => a,
         None => {
             let elapsed = start.elapsed();
-            println!("{} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→ 404"), gray(&format!("in {:.2?}", elapsed)));
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ 404"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
             return (StatusCode::NOT_FOUND, "Not Found").into_response();
         }
     };
@@ -151,7 +164,8 @@ async fn dynamic_handler_inner(
     // LOAD ACTION
     // ---------------------------
     let resolved = resolve_actions_dir();
-    let actions_dir = resolved.exists()
+    let actions_dir = resolved
+        .exists()
         .then(|| resolved)
         .or_else(|| find_actions_dir(&state.project_root))
         .unwrap();
@@ -164,17 +178,24 @@ async fn dynamic_handler_inner(
         }
     }
-    let js_code = match fs::read_to_string(&action_path) {
-        Ok(c) => c,
-        Err(_) => {
-             return (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": "Action bundle not found", "action": action_name}))).into_response()
-        }
-    };
+    let js_code =
+        match fs::read_to_string(&action_path) {
+            Ok(c) => c,
+            Err(_) => return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(
+                    serde_json::json!({"error": "Action bundle not found", "action": action_name}),
+                ),
+            )
+                .into_response(),
+        };
     // ---------------------------
     // EXECUTE IN V8
     // ---------------------------
-    let env_json = std::env::vars().map(|(k, v)| (k, Value::String(v))).collect::<serde_json::Map<_, _>>();
+    let env_json = std::env::vars()
+        .map(|(k, v)| (k, Value::String(v)))
+        .collect::<serde_json::Map<_, _>>();
     let injected = format!(
         r#"
@@ -215,43 +236,42 @@ async fn dynamic_handler_inner(
     // We can use `task::spawn_blocking`.
     let root = state.project_root.clone();
     let action_name_for_v8 = action_name.clone();
     let result_json: Value = tokio::task::spawn_blocking(move || {
         let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
         let handle_scope = &mut v8::HandleScope::new(isolate);
         let context = v8::Context::new(handle_scope, v8::ContextOptions::default());
         let scope = &mut v8::ContextScope::new(handle_scope, context);
         let global = context.global(scope);
         // Inject extensions (t.read, etc)
         inject_extensions(scope, global);
-        // Set metadata globals
         // Set metadata globals
         let root_str = v8::String::new(scope, root.to_str().unwrap_or(".")).unwrap();
         let root_key = v8::String::new(scope, "__titan_root").unwrap();
         global.set(scope, root_key.into(), root_str.into());
         let action_str = v8::String::new(scope, &action_name_for_v8).unwrap();
         let action_key = v8::String::new(scope, "__titan_action").unwrap();
         global.set(scope, action_key.into(), action_str.into());
         let source = v8::String::new(scope, &injected).unwrap();
         let try_catch = &mut v8::TryCatch::new(scope);
         let script = match v8::Script::compile(try_catch, source, None) {
-             Some(s) => s,
-             None => {
-                 let err = try_catch.message().unwrap();
-                 let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
-                 return serde_json::json!({ "error": msg, "phase": "compile" });
-             }
+            Some(s) => s,
+            None => {
+                let err = try_catch.message().unwrap();
+                let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
+                return serde_json::json!({ "error": msg, "phase": "compile" });
+            }
         };
         let result = script.run(try_catch);
         match result {
             Some(val) => {
                 // Convert v8 Value to Serde JSON
@@ -259,37 +279,59 @@ async fn dynamic_handler_inner(
                 let json_obj = v8::json::stringify(try_catch, val).unwrap();
                 let json_str = json_obj.to_rust_string_lossy(try_catch);
                 serde_json::from_str(&json_str).unwrap_or(Value::Null)
-            },
+            }
             None => {
-                 let err = try_catch.message().unwrap();
-                 let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
-                 serde_json::json!({ "error": msg, "phase": "execution" })
+                let err = try_catch.message().unwrap();
+                let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
+                serde_json::json!({ "error": msg, "phase": "execution" })
             }
         }
-    }).await.unwrap_or(serde_json::json!({"error": "V8 task failed"}));
+    })
+    .await
+    .unwrap_or(serde_json::json!({"error": "V8 task failed"}));
     // ---------------------------
     // FINAL LOG
     // ---------------------------
     let elapsed = start.elapsed();
     // Check for errors in result
     if let Some(err) = result_json.get("error") {
-        println!("{} {} {} {}", blue("[Titan]"), red(&format!("{} {}", method, path)), red("→ error"), gray(&format!("in {:.2?}", elapsed)));
+        println!(
+            "{} {} {} {}",
+            blue("[Titan]"),
+            red(&format!("{} {}", method, path)),
+            red("→ error"),
+            gray(&format!("in {:.2?}", elapsed))
+        );
         println!("{}", red(err.as_str().unwrap_or("Unknown")));
         return (StatusCode::INTERNAL_SERVER_ERROR, Json(result_json)).into_response();
     }
     match route_kind {
-        "dynamic" => println!("{} {} {} {} {} {}", blue("[Titan]"), green(&format!("{} {}", method, path)), white("→"), green(&route_label), white("(dynamic)"), gray(&format!("in {:.2?}", elapsed))),
-        "exact" => println!("{} {} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→"), yellow(&route_label), gray(&format!("in {:.2?}", elapsed))),
+        "dynamic" => println!(
+            "{} {} {} {} {} {}",
+            blue("[Titan]"),
+            green(&format!("{} {}", method, path)),
+            white("→"),
+            green(&route_label),
+            white("(dynamic)"),
+            gray(&format!("in {:.2?}", elapsed))
+        ),
+        "exact" => println!(
+            "{} {} {} {} {}",
+            blue("[Titan]"),
+            white(&format!("{} {}", method, path)),
+            white("→"),
+            yellow(&route_label),
+            gray(&format!("in {:.2?}", elapsed))
+        ),
         _ => {}
     }
     Json(result_json).into_response()
 }
 // Entrypoint ---------------------------------------------------------------
 #[tokio::main]
@@ -304,28 +346,22 @@ async fn main() -> Result<()> {
     let port = json["__config"]["port"].as_u64().unwrap_or(3000);
     let routes_json = json["routes"].clone();
     let map: HashMap<String, RouteVal> = serde_json::from_value(routes_json).unwrap_or_default();
-    let dynamic_routes: Vec<DynamicRoute> = serde_json::from_value(json["__dynamic_routes"].clone()).unwrap_or_default();
+    let dynamic_routes: Vec<DynamicRoute> =
+        serde_json::from_value(json["__dynamic_routes"].clone()).unwrap_or_default();
-    // Project root — heuristics
-    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
-    // Ensure we find the 'app' directory as sibling if running from 'server'
-    let project_root = if cwd.join("../app").exists() {
-        cwd.join("../app")
-    } else {
-        cwd
-    };
+    // Identify project root (where .ext or node_modules lives)
+    let project_root = resolve_project_root();
     let state = AppState {
         routes: Arc::new(map),
         dynamic_routes: Arc::new(dynamic_routes),
         project_root: project_root.clone(),
     };
     // Load extensions
     extensions::load_project_extensions(project_root.clone());
     let app = Router::new()
         .route("/", any(root_route))
         .fallback(any(dynamic_route))
         .with_state(state);
@@ -338,8 +374,38 @@ async fn main() -> Result<()> {
     println!("   ██║   ██║   ██║   ██╔══██║██║╚██╗██║");
     println!("   ██║   ██║   ██║   ██║  ██║██║ ╚████║");
     println!("   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝\x1b[0m\n");
-    println!("\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}", port);
+    println!(
+        "\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}",
+        port
+    );
     axum::serve(listener, app).await?;
     Ok(())
 }
+fn resolve_project_root() -> PathBuf {
+    // 1. Check CWD (preferred for local dev/tooling)
+    if let Ok(cwd) = std::env::current_dir() {
+        if cwd.join("node_modules").exists()
+            || cwd.join("package.json").exists()
+            || cwd.join(".ext").exists()
+        {
+            return cwd;
+        }
+    }
+    // 2. Check executable persistence (Docker / Production)
+    // Walk up from the executable to find .ext or node_modules
+    if let Ok(exe) = std::env::current_exe() {
+        let mut current = exe.parent();
+        while let Some(dir) = current {
+            if dir.join(".ext").exists() || dir.join("node_modules").exists() {
+                return dir.to_path_buf();
+            }
+            current = dir.parent();
+        }
+    }
+    // 3. Fallback to CWD
+    std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
+}

package/titanpl-sdk/README.md CHANGED Viewed

@@ -1,11 +1,19 @@
-# 🛠️ Titan SDK
+<div align="center">
+  <img src="./assets/titanpl-sdk.png" alt="Titan SDK Logo" width="120" />
+  <h1>Titan SDK</h1>
+  <p>
+    <b>The Developer Toolkit for Titan Planet. Type safety, IntelliSense, and Extension Testing.</b>
+  </p>
+</div>
-**The Developer Toolkit for Titan Planet. Type safety, IntelliSense, and Extension Testing.**
+<div align="center">
-[![npm version](https://img.shields.io/npm/v/titan-sdk.svg?style=flat-square)](https://www.npmjs.com/package/titan-sdk)
+[![npm version](https://img.shields.io/npm/v/titanpl-sdk.svg?style=flat-square)](https://www.npmjs.com/package/titanpl-sdk)
 [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg?style=flat-square)](https://opensource.org/licenses/ISC)
+</div>
 ---
 ## 🌌 Overview
@@ -14,7 +22,7 @@
 It provides the necessary **Type Definitions** to make your IDE understand the global `t` object and a **Lite Test Harness** to verify your extensions before they ever touch a production binary.
-> **Note:** The actual implementation of `t.log`, `t.fetch`, and other APIs are embedded directly into the [Titan Planet Binary](https://github.com/ezet-galaxy/-ezetgalaxy-titan). This SDK simply provides the "blueprints" (types) and a "sandbox" (test runner).
+> **Note:** The actual implementation of `t.log`, `t.fetch`, and other APIs are embedded directly into the [Titan Planet Binary](https://github.com/ezet-galaxy/titanpl). This SDK simply provides the "blueprints" (types) and a "sandbox" (test runner).
 ---
@@ -90,12 +98,12 @@ The SDK provides types for the native APIs provided by the Titan Planet engine:
 ## 🌍 Community & Documentation
-- **Core Framework**: [Titan Planet](https://github.com/ezet-galaxy/-ezetgalaxy-titan)
+- **Core Framework**: [Titan Planet](https://github.com/ezet-galaxy/titanpl)
 - **Official Docs**: [Titan Planet Docs](https://titan-docs-ez.vercel.app/docs)
 - **Author**: [ezetgalaxy](https://github.com/ezet-galaxy)
 ---
 <p align="center">
-  Built with ❤️ for the <a href="https://github.com/ezet-galaxy/-ezetgalaxy-titan">Titan Planet</a> ecosystem.
+  Built with ❤️ for the <a href="https://titan-docs-ez.vercel.app/">Titan Planet</a> ecosystem.
 </p>

package/titanpl-sdk/assets/titanpl-sdk.png ADDED Viewed

Binary file

package/titanpl-sdk/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
     "name": "titanpl-sdk",
-    "version": "0.1.1",
+    "version": "0.1.6",
     "description": "Development SDK for Titan Planet. Provides TypeScript type definitions for the global 't' runtime object and a 'lite' test-harness runtime for building and verifying extensions.",
     "main": "index.js",
     "type": "module",
@@ -12,6 +12,7 @@
         "bin/",
         "templates/",
         "titan",
+        "assets",
         "index.js",
         "index.d.ts",
         "README.md"

package/titanpl-sdk/templates/Dockerfile CHANGED Viewed

@@ -18,6 +18,20 @@ COPY . .
 # Install JS dependencies (needed for Titan DSL + bundler)
 RUN npm install
+SHELL ["/bin/bash", "-c"]
+# Extract Titan extensions into .ext
+RUN mkdir -p /app/.ext && \
+    find /app/node_modules -maxdepth 5 -type f -name "titan.json" -print0 | \
+    while IFS= read -r -d '' file; do \
+    pkg_dir="$(dirname "$file")"; \
+    pkg_name="$(basename "$pkg_dir")"; \
+    echo "Copying Titan extension: $pkg_name from $pkg_dir"; \
+    cp -r "$pkg_dir" "/app/.ext/$pkg_name"; \
+    done && \
+    echo "Extensions in .ext:" && \
+    ls -R /app/.ext
 # Build Titan metadata + bundle JS actions
 RUN titan build
@@ -34,7 +48,7 @@ FROM debian:stable-slim
 WORKDIR /app
 # Copy Rust binary from builder stage
-COPY --from=builder /app/server/target/release/server ./titan-server
+COPY --from=builder /app/server/target/release/titan-server ./titan-server
 # Copy Titan routing metadata
 COPY --from=builder /app/server/routes.json ./routes.json
@@ -44,10 +58,9 @@ COPY --from=builder /app/server/action_map.json ./action_map.json
 RUN mkdir -p /app/actions
 COPY --from=builder /app/server/actions /app/actions
-COPY --from=builder /app/db /app/assets
+# Copy only Titan extensions
+COPY --from=builder /app/.ext ./.ext
-# Expose Titan port
 EXPOSE 3000
-# Start Titan
 CMD ["./titan-server"]