@ezetgalaxy/titan 26.9.1 → 26.9.3

package/templates/ts/titan/titan.d.ts

@@ -1,117 +1,117 @@
-
-// -- Module Definitions (for imports from "titan") --
-
-export interface RouteHandler {
-    reply(value: any): void;
-    action(name: string): void;
-}
-
-export interface TitanBuilder {
-    get(route: string): RouteHandler;
-    post(route: string): RouteHandler;
-    log(module: string, msg: string): void;
-    start(port?: number, msg?: string): Promise<void>;
-}
-
-// The default export from titan.js is the Builder
-declare const builder: TitanBuilder;
-export default builder;
-
-/**
- * Define a Titan Action with type inference.
- */
-export declare function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
-
-
-// -- Global Definitions (Runtime Environment) --
-
-declare global {
-    /**
-     * The Titan Request Object passed to actions.
-     */
-    interface TitanRequest {
-        body: any;
-        method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-        path: string;
-        headers: {
-            host?: string;
-            "content-type"?: string;
-            "user-agent"?: string;
-            authorization?: string;
-            [key: string]: string | undefined;
-        };
-        params: Record<string, string>;
-        query: Record<string, string>;
-    }
-
-    interface DbConnection {
-        /**
-         * Execute a SQL query.
-         * @param sql The SQL query string.
-         * @param params (Optional) Parameters for the query ($1, $2, etc).
-         */
-        query(sql: string, params?: any[]): any[];
-    }
-
-    /**
-     * Global defineAction (available without import in runtime, though imports are preferred in TS)
-     */
-    function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
-
-    /**
-     * Global Request Object
-     * Available automatically in actions.
-     */
-    var req: TitanRequest;
-
-    /**
-     * Titan Runtime Utilities
-     * (Available globally in the runtime, e.g. inside actions)
-     */
-    const t: {
-        /**
-         * Log messages to the server console with Titan formatting.
-         */
-        log(...args: any[]): void;
-
-        /**
-         * Read a file contents as string.
-         * @param path Relative path to the file from project root.
-         */
-        read(path: string): string;
-
-        fetch(url: string, options?: {
-            method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-            headers?: Record<string, string>;
-            body?: string | object;
-        }): {
-            ok: boolean;
-            status?: number;
-            body?: string;
-            error?: string;
-        };
-
-        jwt: {
-            sign(
-                payload: object,
-                secret: string,
-                options?: { expiresIn?: string | number }
-            ): string;
-            verify(token: string, secret: string): any;
-        };
-
-        password: {
-            hash(password: string): string;
-            verify(password: string, hash: string): boolean;
-        };
-
-        db: {
-            connect(url: string): DbConnection;
-        };
-
-        /**
-         * Titan Validator (Zod-compatible)
-         */
-        valid: any;
-    };
-}
+
+// -- Module Definitions (for imports from "titan") --
+
+export interface RouteHandler {
+    reply(value: any): void;
+    action(name: string): void;
+}
+
+export interface TitanBuilder {
+    get(route: string): RouteHandler;
+    post(route: string): RouteHandler;
+    log(module: string, msg: string): void;
+    start(port?: number, msg?: string): Promise<void>;
+}
+
+// The default export from titan.js is the Builder
+declare const builder: TitanBuilder;
+export default builder;
+
+/**
+ * Define a Titan Action with type inference.
+ */
+export declare function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
+
+
+// -- Global Definitions (Runtime Environment) --
+
+declare global {
+    /**
+     * The Titan Request Object passed to actions.
+     */
+    interface TitanRequest {
+        body: any;
+        method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+        path: string;
+        headers: {
+            host?: string;
+            "content-type"?: string;
+            "user-agent"?: string;
+            authorization?: string;
+            [key: string]: string | undefined;
+        };
+        params: Record<string, string>;
+        query: Record<string, string>;
+    }
+
+    interface DbConnection {
+        /**
+         * Execute a SQL query.
+         * @param sql The SQL query string.
+         * @param params (Optional) Parameters for the query ($1, $2, etc).
+         */
+        query(sql: string, params?: any[]): any[];
+    }
+
+    /**
+     * Global defineAction (available without import in runtime, though imports are preferred in TS)
+     */
+    function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
+
+    /**
+     * Global Request Object
+     * Available automatically in actions.
+     */
+    var req: TitanRequest;
+
+    /**
+     * Titan Runtime Utilities
+     * (Available globally in the runtime, e.g. inside actions)
+     */
+    const t: {
+        /**
+         * Log messages to the server console with Titan formatting.
+         */
+        log(...args: any[]): void;
+
+        /**
+         * Read a file contents as string.
+         * @param path Relative path to the file from project root.
+         */
+        read(path: string): string;
+
+        fetch(url: string, options?: {
+            method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            headers?: Record<string, string>;
+            body?: string | object;
+        }): {
+            ok: boolean;
+            status?: number;
+            body?: string;
+            error?: string;
+        };
+
+        jwt: {
+            sign(
+                payload: object,
+                secret: string,
+                options?: { expiresIn?: string | number }
+            ): string;
+            verify(token: string, secret: string): any;
+        };
+
+        password: {
+            hash(password: string): string;
+            verify(password: string, hash: string): boolean;
+        };
+
+        db: {
+            connect(url: string): DbConnection;
+        };
+
+        /**
+         * Titan Validator (Zod-compatible)
+         */
+        valid: any;
+    };
+}

package/templates/ts/titan/titan.js

@@ -2,7 +2,7 @@ import { bundle } from "./bundle.js";
 import fs from "fs";
 import path from "path";
 
-export const defineAction = (handler) => handler;
+export * from "./runtime.js";
 
 const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
 const green = (t) => `\x1b[32m${t}\x1b[0m`;

package/titanpl-sdk/node_modules/.package-lock.json

@@ -0,0 +1,17 @@
+{
+    "name": "titanpl-sdk",
+    "version": "0.1.7",
+    "lockfileVersion": 3,
+    "requires": true,
+    "packages": {
+        "node_modules/@titanpl/core": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/@titanpl/core/-/core-1.0.1.tgz",
+            "integrity": "sha512-5zcDMNnf+oghKkQMiPBFuhLlRy2IASyWMAAMgfqa4AzoXxiw2BzzfN0B2EA76Dy9AhCeK2mY84Zm+FSE7ANVFg==",
+            "license": "ISC",
+            "engines": {
+                "node": ">=18.0.0"
+            }
+        }
+    }
+}

package/titanpl-sdk/node_modules/@titanpl/core/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025, Ezet Galaxy
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/titanpl-sdk/node_modules/@titanpl/core/README.md

@@ -0,0 +1,127 @@
+# @titanpl/core
+
+The official Core Standard Library for **Titan Planet** - a high-performance JavaScript runtime.
+
+## Installation
+
+```bash
+npm install @titanpl/core
+```
+
+## Overview
+
+`@titanpl/core` provides essential standard library modules for Titan applications:
+
+| Module | Description |
+|--------|-------------|
+| `fs` | File system operations (read, write, mkdir, exists, stat, remove) |
+| `path` | Path manipulation utilities (join, resolve, extname, dirname, basename) |
+| `crypto` | Cryptographic functions (hash, randomBytes, uuid, base64) |
+| `os` | Operating system information (platform, cpus, memory) |
+| `net` | Network utilities (DNS resolve, IP address) |
+| `proc` | Process information (pid, uptime) |
+| `time` | Time utilities (sleep, now, timestamp) |
+| `url` | URL parsing and manipulation |
+
+## Usage
+
+Once installed, the extension automatically attaches to the Titan runtime:
+
+```javascript
+// Access via t.core
+const content = t.core.fs.readFile("config.json");
+const joined = t.core.path.join("foo", "bar", "baz.txt");
+const uuid = t.core.crypto.uuid();
+
+// Or via individual modules on t
+const exists = t.fs.exists("./data");
+const now = t.time.now();
+```
+
+## API Reference
+
+### fs (File System)
+
+```javascript
+t.fs.readFile(path)          // Read file contents as string
+t.fs.writeFile(path, content) // Write string to file
+t.fs.readdir(path)           // List directory contents
+t.fs.mkdir(path)             // Create directory
+t.fs.exists(path)            // Check if path exists
+t.fs.stat(path)              // Get file/directory stats
+t.fs.remove(path)            // Remove file or directory
+```
+
+### path
+
+```javascript
+t.path.join(...parts)        // Join path segments
+t.path.resolve(...parts)     // Resolve to absolute path
+t.path.extname(path)         // Get file extension
+t.path.dirname(path)         // Get directory name
+t.path.basename(path)        // Get file name
+```
+
+### crypto
+
+```javascript
+t.crypto.hash(algo, data)    // Hash data (sha256, sha512, etc.)
+t.crypto.randomBytes(size)   // Generate random bytes
+t.crypto.uuid()              // Generate UUID v4
+t.crypto.base64.encode(str)  // Base64 encode
+t.crypto.base64.decode(str)  // Base64 decode
+t.crypto.compare(a, b)       // Constant-time string comparison
+```
+
+### os
+
+```javascript
+t.os.platform()              // Get OS platform
+t.os.cpus()                  // Get CPU count
+t.os.totalMemory()           // Get total memory
+t.os.freeMemory()            // Get free memory
+t.os.tmpdir()                // Get temp directory path
+```
+
+### net
+
+```javascript
+t.net.resolveDNS(hostname)   // Resolve DNS
+t.net.ip()                   // Get local IP address
+```
+
+### proc
+
+```javascript
+t.proc.pid()                 // Get process ID
+t.proc.uptime()              // Get process uptime
+```
+
+### time
+
+```javascript
+t.time.sleep(ms)             // Sleep for milliseconds
+t.time.now()                 // Get current timestamp (ms)
+t.time.timestamp()           // Get ISO timestamp string
+```
+
+### url
+
+```javascript
+t.url.parse(urlString)       // Parse URL string
+t.url.format(urlObject)      // Format URL object to string
+new t.url.SearchParams(query) // Parse query string
+```
+
+## Native Bindings
+
+This extension includes native Rust bindings for high-performance file system and OS operations. The native library is automatically loaded when available.
+
+## Requirements
+
+- Titan SDK >= 0.1.7
+- Node.js >= 18.0.0 (for development)
+
+## License
+
+ISC © ezetgalaxy

package/titanpl-sdk/node_modules/@titanpl/core/globals.d.ts

@@ -0,0 +1,17 @@
+declare var t: any;
+declare var fs_read_file: any;
+declare var fs_write_file: any;
+declare var fs_readdir: any;
+declare var fs_mkdir: any;
+declare var fs_exists: any;
+declare var fs_stat: any;
+declare var fs_remove: any;
+declare var path_cwd: any;
+declare var crypto_hash: any;
+declare var crypto_random_bytes: any;
+declare var crypto_uuid: any;
+declare var os_info: any;
+declare var net_resolve: any;
+declare var net_ip: any;
+declare var proc_info: any;
+declare var time_sleep: any;

package/titanpl-sdk/node_modules/@titanpl/core/index.js

@@ -0,0 +1,250 @@
+// Titan Core Library
+// Provides standard library features using native bindings.
+
+// Native bindings are expected to be available globally or via t.native
+// adjusting based on typical Titan behavior.
+// We bind them to local variables for cleaner usage.
+
+const native_fs_read_file = globalThis.fs_read_file;
+const native_fs_write_file = globalThis.fs_write_file;
+const native_fs_readdir = globalThis.fs_readdir;
+const native_fs_mkdir = globalThis.fs_mkdir;
+const native_fs_exists = globalThis.fs_exists;
+const native_fs_stat = globalThis.fs_stat;
+const native_fs_remove = globalThis.fs_remove;
+const native_path_cwd = globalThis.path_cwd;
+const native_crypto_hash = globalThis.crypto_hash;
+const native_crypto_random_bytes = globalThis.crypto_random_bytes;
+const native_crypto_uuid = globalThis.crypto_uuid;
+const native_os_info = globalThis.os_info;
+const native_net_resolve = globalThis.net_resolve;
+const native_net_ip = globalThis.net_ip;
+const native_proc_info = globalThis.proc_info;
+const native_time_sleep = globalThis.time_sleep;
+
+// --- FS ---
+const fs = {
+    readFile: (path) => {
+        if (!native_fs_read_file) throw new Error("Native fs_read_file not found");
+        return native_fs_read_file(path);
+    },
+    writeFile: (path, content) => {
+        if (!native_fs_write_file) throw new Error("Native fs_write_file not found");
+        native_fs_write_file(path, content);
+    },
+    readdir: (path) => {
+        if (!native_fs_readdir) throw new Error("Native fs_readdir not found");
+        return JSON.parse(native_fs_readdir(path));
+    },
+    mkdir: (path) => {
+        if (!native_fs_mkdir) throw new Error("Native fs_mkdir not found");
+        native_fs_mkdir(path);
+    },
+    exists: (path) => {
+        if (!native_fs_exists) throw new Error("Native fs_exists not found");
+        return native_fs_exists(path);
+    },
+    stat: (path) => {
+        if (!native_fs_stat) throw new Error("Native fs_stat not found");
+        return JSON.parse(native_fs_stat(path));
+    },
+    remove: (path) => {
+        if (!native_fs_remove) throw new Error("Native fs_remove not found");
+        native_fs_remove(path);
+    }
+};
+
+// --- Path ---
+// Basic implementation for POSIX-like paths (Titan mostly runs on servers/containers)
+const path = {
+    join: (...args) => {
+        return args
+            .map((part, i) => {
+                if (i === 0) return part.trim().replace(/[\/]*$/g, '');
+                return part.trim().replace(/(^[\/]*|[\/]*$)/g, '');
+            })
+            .filter(x => x.length)
+            .join('/');
+    },
+    resolve: (...args) => {
+        let resolved = '';
+        for (let arg of args) {
+            resolved = path.join(resolved, arg);
+        }
+        if (!resolved.startsWith('/') && native_path_cwd) {
+            resolved = path.join(native_path_cwd(), resolved);
+        }
+        return resolved;
+    },
+    extname: (p) => {
+        const parts = p.split('.');
+        return parts.length > 1 && !p.startsWith('.') ? '.' + parts.pop() : '';
+    },
+    dirname: (p) => {
+        const parts = p.split('/');
+        parts.pop();
+        return parts.join('/') || '.';
+    },
+    basename: (p) => p.split('/').pop()
+};
+
+// --- Crypto ---
+const crypto = {
+    hash: (algo, data) => native_crypto_hash(algo, data),
+    randomBytes: (size) => native_crypto_random_bytes(size),
+    uuid: () => native_crypto_uuid(),
+    base64: {
+        encode: (str) => btoa(str), // Boa supports btoa/atob
+        decode: (str) => atob(str),
+    },
+    compare: (a, b) => {
+        if (a.length !== b.length) return false;
+        // Constant time comparison not guaranteed here in JS easily without specialized tricks
+        let mismatch = 0;
+        for (let i = 0; i < a.length; ++i) {
+            mismatch |= (a.charCodeAt(i) ^ b.charCodeAt(i));
+        }
+        return mismatch === 0;
+    }
+};
+
+// --- OS ---
+const os = {
+    platform: () => {
+        const info = JSON.parse(native_os_info());
+        return info.platform;
+    },
+    cpus: () => {
+        const info = JSON.parse(native_os_info());
+        return info.cpus;
+    },
+    totalMemory: () => {
+        const info = JSON.parse(native_os_info());
+        return info.totalMemory;
+    },
+    freeMemory: () => {
+        const info = JSON.parse(native_os_info());
+        return info.freeMemory;
+    },
+    tmpdir: () => '/tmp' // Default for now, generic
+};
+
+// --- Net ---
+const net = {
+    resolveDNS: (hostname) => JSON.parse(native_net_resolve(hostname)),
+    ip: () => native_net_ip(),
+    ping: (host) => {
+        // Mock ping or simple verify
+        return true;
+    }
+};
+
+// --- Proc ---
+// Memoize static info if needed, but here we call native
+const proc = {
+    pid: () => {
+        const info = JSON.parse(native_proc_info());
+        return info.pid;
+    },
+    uptime: () => {
+        const info = JSON.parse(native_proc_info());
+        return info.uptime;
+    },
+    memory: () => {
+        // Optional: return full memory usage if possible
+        return {};
+    }
+};
+
+// --- Time ---
+const time = {
+    sleep: (ms) => native_time_sleep(ms),
+    now: () => Date.now(),
+    timestamp: () => new Date().toISOString()
+};
+
+// --- URL ---
+// Simple URLSearchParams polyfill for V8 runtime
+class TitanURLSearchParams {
+    constructor(init = '') {
+        this._params = {};
+        if (typeof init === 'string') {
+            const query = init.startsWith('?') ? init.slice(1) : init;
+            query.split('&').forEach(pair => {
+                const [key, value] = pair.split('=').map(decodeURIComponent);
+                if (key) this._params[key] = value || '';
+            });
+        } else if (typeof init === 'object') {
+            Object.assign(this._params, init);
+        }
+    }
+    get(key) { return this._params[key] || null; }
+    set(key, value) { this._params[key] = String(value); }
+    has(key) { return key in this._params; }
+    delete(key) { delete this._params[key]; }
+    toString() {
+        return Object.entries(this._params)
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+            .join('&');
+    }
+    entries() { return Object.entries(this._params); }
+    keys() { return Object.keys(this._params); }
+    values() { return Object.values(this._params); }
+}
+
+const url = {
+    parse: (str) => {
+        // Basic URL parsing if native URL is available
+        if (typeof URL !== 'undefined') {
+            return new URL(str);
+        }
+        // Simple fallback parser
+        const match = str.match(/^(https?:)\/\/([^/:]+)(?::(\d+))?(\/[^?#]*)?(\?[^#]*)?(#.*)?$/);
+        if (!match) throw new Error('Invalid URL');
+        return {
+            protocol: match[1],
+            hostname: match[2],
+            port: match[3] || '',
+            pathname: match[4] || '/',
+            search: match[5] || '',
+            hash: match[6] || ''
+        };
+    },
+    format: (obj) => obj.toString ? obj.toString() : String(obj),
+    SearchParams: TitanURLSearchParams
+};
+
+
+// Create the main core export object (following titan-valid pattern)
+const core = {
+    fs,
+    path,
+    crypto,
+    os,
+    net,
+    proc,
+    time,
+    url
+};
+
+
+t.fs = fs;
+t.path = path;
+t.crypto = crypto;
+t.os = os;
+t.net = net;
+t.proc = proc;
+t.time = time;
+t.url = url;
+
+// Attach core as unified namespace (main access point)
+t.core = core;
+
+// Register as extension under multiple names for compatibility
+t["titan-core"] = core;
+t["@titanpl/core"] = core;
+
+// Also register in t.exts
+if (!t.exts) t.exts = {};
+t.exts["titan-core"] = core;
+t.exts["@titanpl/core"] = core;