titanpl 4.0.0 → 4.0.2

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://titan-docs-ez.vercel.app/" target="_blank">
+  <a href="https://titanpl.vercel.app/" target="_blank">
     <img src="https://i.ibb.co/VpBsTg6m/tpl-Logo.png" width="120" alt="TitanPl Logo" />
   </a>
 </p>
@@ -292,4 +292,4 @@ You can customize the build process in your `tanfig.json`:
 ---
 
 
-**To know more read docs 💟 **Titan Planet docs:** https://titan-docs-ez.vercel.app/docs**
+**To know more read docs 💟 **Titan Planet docs:** https://titanpl.vercel.app/docs**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "titanpl",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "Titan Planet is a JavaScript-first backend framework that embeds JS actions into a Rust + Axum server and ships as a single native binary. Routes are compiled to static metadata; only actions run in the embedded JS runtime. No Node.js. No event loop in production.",
   "license": "ISC",
   "author": "ezetgalaxy",

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/cli",
-  "version": "4.0.0",
+  "version": "5.0.6",
   "description": "The unified CLI for Titan Planet. Use it to create, manage, build, and deploy high-performance backend projects.",
   "keywords": [
     "titanpl",
@@ -33,7 +33,7 @@
     "@titanpl/engine-linux-x64": "2.0.4"
   },
   "dependencies": {
-    "@titanpl/packet": "2.0.4",
+    "@titanpl/packet": "4.0.2",
     "prompts": "^2.4.2",
     "commander": "^11.0.0",
     "chalk": "^4.1.2"

package/packages/cli/src/commands/update.js

@@ -58,9 +58,30 @@ export async function updateCommand() {
         console.log(chalk.yellow(`  ⚠️ Failed to update package.json: ${e.message}`));
     }
 
-    // 2. Refresh Dockerfile and dotfiles from templates
-    const commonDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'common');
-    if (fs.existsSync(commonDir)) {
+    // 2. Migration: rename titan.json to tanfig.json if needed
+    const oldConfigPath = path.join(root, 'titan.json');
+    const newConfigPath = path.join(root, 'tanfig.json');
+    if (fs.existsSync(oldConfigPath) && !fs.existsSync(newConfigPath)) {
+        fs.renameSync(oldConfigPath, newConfigPath);
+        console.log(chalk.green(`  ✔ Migrated titan.json to tanfig.json`));
+    }
+
+    // 3. Refresh Dockerfile and dotfiles from templates
+    let commonDir = null;
+    const tryCommonPaths = [
+        path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'common'), // Monorepo
+        path.resolve(__dirname, '..', '..', 'templates', 'common'), // NPM cli package
+        path.resolve(__dirname, '..', '..', '..', 'templates', 'common') // Fallback
+    ];
+
+    for (const p of tryCommonPaths) {
+        if (fs.existsSync(p)) {
+            commonDir = p;
+            break;
+        }
+    }
+
+    if (commonDir) {
         const filesToSync = [
             ['Dockerfile', 'Dockerfile'],
             ['_dockerignore', '.dockerignore'],

package/packages/cli/src/engine.js

@@ -19,6 +19,7 @@ export function resolveEngineBinaryPath() {
   const arch = os.arch();
   const pkgName = `@titanpl/engine-${platform}-${arch}`;
   const binName = platform === 'win32' ? 'titan-server.exe' : 'titan-server';
+  const shortPkgName = pkgName.split('/').pop();
 
   // 1. Monorepo search (local dev)
   const searchPaths = [
@@ -31,8 +32,14 @@ export function resolveEngineBinaryPath() {
   for (let startPath of searchPaths) {
     let current = startPath;
     for (let i = 0; i < 8; i++) {
-      const potential = path.join(current, 'engine', 'target', 'release', binName);
-      if (fs.existsSync(potential)) return potential;
+      // Check built binary (engine/target/release/...)
+      const builtBin = path.join(current, 'engine', 'target', 'release', binName);
+      if (fs.existsSync(builtBin)) return builtBin;
+
+      // Check package binary (packages/engine-*/bin/...)
+      const pkgBin = path.join(current, 'packages', shortPkgName, 'bin', binName);
+      if (fs.existsSync(pkgBin)) return pkgBin;
+
       const parent = path.dirname(current);
       if (parent === current) break;
       current = parent;
@@ -47,9 +54,22 @@ export function resolveEngineBinaryPath() {
   } catch (e) { }
 
   // 3. Fallback: sibling in node_modules (global install layout)
-  const cliParent = path.dirname(path.dirname(__dirname)); // up from cli/src → cli → parent
-  const siblingBin = path.join(cliParent, pkgName, 'bin', binName);
-  if (fs.existsSync(siblingBin)) return siblingBin;
+  // We need to handle scoped packages correctly. 
+  // If we are at .../node_modules/@titanpl/cli/src
+  // Up 1: .../node_modules/@titanpl/cli
+  // Up 2: .../node_modules/@titanpl
+  // Up 3: .../node_modules (This is where the engine package should be)
+  let current = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const potentialNm = path.join(current, 'node_modules');
+    if (fs.existsSync(potentialNm)) {
+      const siblingBin = path.join(potentialNm, pkgName, 'bin', binName);
+      if (fs.existsSync(siblingBin)) return siblingBin;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
 
   // 4. Walk upwards from current dir searching for binary in root or .ext/node_modules
   let searchDir = process.cwd();

package/packages/packet/js/titan/bundle.js

@@ -33,20 +33,32 @@ const NODE_BUILTIN_MAP = {
   "node:util": "@titanpl/node/util",
 };
 
-const titanNodeCompatPlugin = {
-  name: "titan-node-compat",
-  setup(build) {
-    build.onResolve({ filter: /.*/ }, args => {
-      if (NODE_BUILTIN_MAP[args.path]) {
-        try {
-          const resolved = require.resolve(NODE_BUILTIN_MAP[args.path]);
-          return { path: resolved };
-        } catch (e) {
-          throw new Error(`[TitanPL] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`);
+const createTitanNodeCompatPlugin = (root) => {
+  const rootRequire = createRequire(path.join(root, 'package.json'));
+
+  return {
+    name: "titan-node-compat",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, args => {
+        if (NODE_BUILTIN_MAP[args.path]) {
+          const shimPkg = NODE_BUILTIN_MAP[args.path];
+          try {
+            // 1. Try to resolve from project root (local node_modules)
+            const resolved = rootRequire.resolve(shimPkg);
+            return { path: resolved };
+          } catch (e) {
+            try {
+              // 2. Fallback to CLI's own context
+              const resolved = require.resolve(shimPkg);
+              return { path: resolved };
+            } catch (e2) {
+              throw new Error(`[TitanPL] Failed to resolve Node shim: ${shimPkg}. Ensure @titanpl/node is installed.`);
+            }
+          }
         }
-      }
-    });
-  }
+      });
+    }
+  };
 };
 
 function getTitanVersion() {
@@ -96,7 +108,7 @@ export async function bundleFile(options) {
       platform: 'node',
       target,
       logLevel: 'silent',
-      plugins: [titanNodeCompatPlugin],
+      plugins: [createTitanNodeCompatPlugin(options.root || process.cwd())],
       banner: { js: "var Titan = t;" },
       footer: options.footer || {}
     });
@@ -135,6 +147,7 @@ export async function bundle(options = {}) {
 
     try {
       await bundleFile({
+        root,
         entryPoint,
         outfile,
         footer: {

package/packages/packet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/packet",
-  "version": "2.0.4",
+  "version": "4.0.2",
   "description": "The bundler for TitanPl servers.",
   "keywords": [
     "bundler",

package/packages/packet/ts/titan/bundle.js

@@ -34,20 +34,32 @@ const NODE_BUILTIN_MAP = {
     "node:util": "@titanpl/node/util",
 };
 
-const titanNodeCompatPlugin = {
-    name: "titan-node-compat",
-    setup(build) {
-        build.onResolve({ filter: /.*/ }, args => {
-            if (NODE_BUILTIN_MAP[args.path]) {
-                try {
-                    const resolved = require.resolve(NODE_BUILTIN_MAP[args.path]);
-                    return { path: resolved };
-                } catch (e) {
-                    throw new Error(`[TitanPL] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`);
+const createTitanNodeCompatPlugin = (root) => {
+    const rootRequire = createRequire(path.join(root, 'package.json'));
+
+    return {
+        name: "titan-node-compat",
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, args => {
+                if (NODE_BUILTIN_MAP[args.path]) {
+                    const shimPkg = NODE_BUILTIN_MAP[args.path];
+                    try {
+                        // 1. Try to resolve from project root (local node_modules)
+                        const resolved = rootRequire.resolve(shimPkg);
+                        return { path: resolved };
+                    } catch (e) {
+                        try {
+                            // 2. Fallback to CLI's own context
+                            const resolved = require.resolve(shimPkg);
+                            return { path: resolved };
+                        } catch (e2) {
+                            throw new Error(`[TitanPL] Failed to resolve Node shim: ${shimPkg}. Ensure @titanpl/node is installed.`);
+                        }
+                    }
                 }
-            }
-        });
-    }
+            });
+        }
+    };
 };
 
 function getTitanVersion() {
@@ -140,7 +152,7 @@ export async function bundleFile(options) {
             platform: 'node',
             target,
             logLevel: 'silent',
-            plugins: [titanNodeCompatPlugin],
+            plugins: [createTitanNodeCompatPlugin(options.root || process.cwd())],
             banner: { js: "var Titan = t;" },
             footer: options.footer || {}
         });
@@ -198,6 +210,7 @@ export async function bundle(options = {}) {
 
         try {
             await bundleFile({
+                root,
                 entryPoint,
                 outfile,
                 footer: {

package/templates/common/Dockerfile

@@ -14,14 +14,33 @@ ENV NODE_ENV=production
 
 COPY package.json package-lock.json* ./
 
-# Install dependencies (including optional engines)
+# Install with optional dependencies so it grabs the correct engine for the Linux builder
+RUN npm install -g @titanpl/cli
+
 RUN npm install --include=optional
 
+# ------------------------------------------------
+# Extract Titan Extensions (packages with titan.json)
+# ------------------------------------------------
+RUN mkdir -p /app/.ext && \
+    find node_modules -mindepth 2 -maxdepth 3 -type f -name "titan.json" | while read file; do \
+    pkg_dir=$(dirname "$file"); \
+    pkg_name=$(basename "$pkg_dir"); \
+    echo "Extracting Titan extension: $pkg_name"; \
+    cp -a "$pkg_dir" "/app/.ext/$pkg_name"; \
+    rm -rf "/app/.ext/$pkg_name/node_modules"; \
+    done
+
+# ------------------------------------------------
+# Copy ANY installed Titan Engine (Architecture agnostic)
+# ------------------------------------------------
+RUN mkdir -p /app/.ext/@titanpl && \
+    cp -r node_modules/@titanpl/engine-linux-* /app/.ext/@titanpl/
+
 COPY . .
 
-# Run the Titan release build step
-# This extracts extensions to .ext and prepares the 'build/' folder
-RUN npx titan build --release
+# Run the Titan build step
+RUN npx titan build
 
 
 # ================================================================
@@ -38,11 +57,31 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     ca-certificates curl \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy the entire release build folder prepared by Stage 1
-COPY --from=builder /app/build ./
+# copy dist contents into /app/dist
+COPY --from=builder /app/dist/ ./dist/
+
+# titan extensions + engine
+COPY --from=builder /app/.ext ./.ext
+
+# runtime assets
+COPY --from=builder /app/package.json ./package.json
+
+# ---------------- OPTIONAL APP FOLDERS ----------------
+# Static assets
+# COPY --from=builder /app/app/static ./static
+
+# Public assets
+# COPY --from=builder /app/app/public ./public
+
+# DB
+# COPY --from=builder /app/app/db ./db
 
-# Ensure permissions
-RUN chown -R titan:titan /app
+# CRITICAL SYSTEM SETUP:
+# 1. Mandatory .env file (Engine requires it for config parsing)
+# 2. Node modules symlink for extension JS dependency resolution
+RUN echo "TITAN_DEV=0" > .env && \
+    ln -s /app/.ext /app/node_modules && \
+    chown -R titan:titan /app
 
 # Standard environment variables
 ENV HOST=0.0.0.0
@@ -52,9 +91,10 @@ ENV TITAN_DEV=0
 USER titan
 EXPOSE 5100
 
-# Health check
+# Health check to ensure the server is alive
 HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
     CMD curl -f http://localhost:5100/ || exit 1
 
-# Start the server using the 'titan-server' binary created by the release process
-CMD ["./titan-server", "run", "dist"]
+# DYNAMIC ENTRYPOINT: Finds the correct architecture binary and starts it
+# This allows the SAME image to work on x64 vs ARM64 servers.
+CMD ["/bin/sh", "-c", "exec $(find .ext/@titanpl/engine-linux-* -name titan-server -type f | head -n 1) run dist"]

package/templates/common/README.md

@@ -78,7 +78,7 @@ docker run -p 5100:5100 my-titan-app
 
 ## 🌐 Community & Support
 
-- **Documentation**: [docs.titanpl.com](https://docs.titanpl.com)
+- **Documentation**: [titanpl.vercel.app](https://titanpl.vercel.app)
 - **GitHub**: [github.com/t8nlab/titanpl](https://github.com/t8nlab/titanpl)
 - **Discord**: [Join our community](https://discord.gg/titanpl)
 

package/titanpl-sdk/templates/server/src/extensions/builtin.rs

@@ -472,20 +472,37 @@ fn native_db_connect(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArgu
     }
 
     if DB_POOL.get().is_none() {
-        let cfg: Config = conn_string.parse().unwrap();
+        let cfg: Config = match conn_string.parse() {
+            Ok(c) => c,
+            Err(e) => {
+                throw(scope, &format!("t.db.connect(): Invalid connection string: {}", e));
+                return;
+            }
+        };
         let mgr = Manager::new(cfg, NoTls);
     
-        let pool = Pool::builder(mgr)
+        let pool = match Pool::builder(mgr)
             .max_size(max_size)
-            .build()
-            .unwrap();
+            .build() {
+                Ok(p) => p,
+                Err(e) => {
+                    throw(scope, &format!("t.db.connect(): Failed to build connection pool: {}", e));
+                    return;
+                }
+            };
     
         DB_POOL.set(pool).ok();
     }
 
     let db_conn_obj = v8::Object::new(scope);
 
-    let query_fn = v8::Function::new(scope, native_db_query).unwrap();
+    let query_fn = match v8::Function::new(scope, native_db_query) {
+        Some(f) => f,
+        None => {
+            throw(scope, "t.db.connect(): Failed to create query function");
+            return;
+        }
+    };
     let query_key = v8_str(scope, "query");
     db_conn_obj.set(scope, query_key.into(), query_fn.into());