titanpl 6.0.0 → 7.0.0

package/packages/core-source/tests/setup.js

@@ -0,0 +1,325 @@
+/**
+ * tests/setup.js
+ * 
+ * Emulates Rust native functions for testing.
+ * Equivalent to what @t8n/micro-gravity/setup would do.
+ * 
+ * MOCKED:
+ * - DB (PostgreSQL connection) - No way to test without a real DB
+ * 
+ * EMULATED (JS implementation that simulates Rust behavior):
+ * - fs_* (uses Node.js fs)
+ * - crypto_* (uses Node.js crypto)
+ * - ls_* (uses in-memory Map)
+ * - session_* (uses in-memory Map)
+ * - os_*, net_*, proc_*, time_*, path_cwd
+ */
+
+import { vi } from 'vitest';
+import * as nodeFs from 'node:fs';
+import * as nodePath from 'node:path';
+import * as nodeCrypto from 'node:crypto';
+import * as nodeOs from 'node:os';
+
+// In-memory storage for ls and session
+const localStorage = new Map();
+const sessionStorage = new Map();
+
+// Initialize global `t` object with native functions
+globalThis.t = globalThis.t || {};
+globalThis.t["@titanpl/core"] = globalThis.t["@titanpl/core"] || {};
+globalThis.t.native = globalThis.t.native || {};
+globalThis.t.core = globalThis.t.core || {};
+
+const ext = globalThis.t["@titanpl/core"];
+
+// ============================================
+// FILE SYSTEM - Emulation using Node.js fs
+// ============================================
+
+ext.fs_read_file = (path) => {
+    try {
+        return nodeFs.readFileSync(path, 'utf-8');
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.fs_write_file = (path, content) => {
+    nodeFs.writeFileSync(path, content, 'utf-8');
+};
+
+ext.fs_readdir = (path) => {
+    try {
+        return JSON.stringify(nodeFs.readdirSync(path));
+    } catch {
+        return '[]';
+    }
+};
+
+ext.fs_mkdir = (path) => {
+    nodeFs.mkdirSync(path, { recursive: true });
+};
+
+ext.fs_exists = (path) => {
+    return nodeFs.existsSync(path);
+};
+
+ext.fs_stat = (path) => {
+    try {
+        const stat = nodeFs.statSync(path);
+        return JSON.stringify({
+            size: stat.size,
+            isFile: stat.isFile(),
+            isDir: stat.isDirectory(),
+            modified: stat.mtimeMs
+        });
+    } catch {
+        return '{}';
+    }
+};
+
+ext.fs_remove = (path) => {
+    try {
+        const stat = nodeFs.statSync(path);
+        if (stat.isDirectory()) {
+            nodeFs.rmSync(path, { recursive: true });
+        } else {
+            nodeFs.unlinkSync(path);
+        }
+    } catch { }
+};
+
+ext.path_cwd = () => process.cwd();
+
+// ============================================
+// CRYPTO - Emulation using Node.js crypto
+// ============================================
+
+ext.crypto_hash = (algo, data) => {
+    try {
+        const hash = nodeCrypto.createHash(algo);
+        hash.update(data);
+        return hash.digest('hex');
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.crypto_random_bytes = (size) => {
+    return nodeCrypto.randomBytes(size).toString('hex');
+};
+
+ext.crypto_uuid = () => {
+    return nodeCrypto.randomUUID();
+};
+
+ext.crypto_encrypt = (algo, jsonArgs) => {
+    try {
+        const { key, plaintext } = JSON.parse(jsonArgs);
+        const keyBuffer = Buffer.alloc(32);
+        Buffer.from(key).copy(keyBuffer);
+        const iv = nodeCrypto.randomBytes(12);
+        const cipher = nodeCrypto.createCipheriv('aes-256-gcm', keyBuffer, iv);
+        let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        const authTag = cipher.getAuthTag().toString('hex');
+        return iv.toString('hex') + ':' + authTag + ':' + encrypted;
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.crypto_decrypt = (algo, jsonArgs) => {
+    try {
+        const { key, ciphertext } = JSON.parse(jsonArgs);
+        const [ivHex, authTagHex, encrypted] = ciphertext.split(':');
+        const keyBuffer = Buffer.alloc(32);
+        Buffer.from(key).copy(keyBuffer);
+        const iv = Buffer.from(ivHex, 'hex');
+        const authTag = Buffer.from(authTagHex, 'hex');
+        const decipher = nodeCrypto.createDecipheriv('aes-256-gcm', keyBuffer, iv);
+        decipher.setAuthTag(authTag);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.crypto_hash_keyed = (algo, jsonArgs) => {
+    try {
+        const { key, message } = JSON.parse(jsonArgs);
+        const hmac = nodeCrypto.createHmac(algo === 'sha256' ? 'sha256' : 'sha512', key);
+        hmac.update(message);
+        return hmac.digest('hex');
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.crypto_compare = (a, b) => {
+    return nodeCrypto.timingSafeEqual(Buffer.from(a), Buffer.from(b));
+};
+
+// ============================================
+// LOCAL STORAGE - In-memory emulation
+// ============================================
+
+ext.ls_get = (key) => {
+    return localStorage.get(key) || '';
+};
+
+ext.ls_set = (key, value) => {
+    localStorage.set(key, value);
+};
+
+ext.ls_remove = (key) => {
+    localStorage.delete(key);
+};
+
+ext.ls_clear = () => {
+    localStorage.clear();
+};
+
+ext.ls_keys = () => {
+    return JSON.stringify([...localStorage.keys()]);
+};
+
+// Simplified V8 serialization (uses JSON as fallback)
+ext.serialize = (value) => {
+    try {
+        const json = JSON.stringify(value);
+        return new TextEncoder().encode(json);
+    } catch {
+        return null;
+    }
+};
+
+ext.deserialize = (bytes) => {
+    try {
+        const json = new TextDecoder().decode(bytes);
+        return JSON.parse(json);
+    } catch {
+        return null;
+    }
+};
+
+// ============================================
+// SESSION - In-memory emulation
+// ============================================
+
+ext.session_get = (sid, key) => {
+    return sessionStorage.get(`${sid}:${key}`) || '';
+};
+
+ext.session_set = (sid, jsonArgs) => {
+    const { key, value } = JSON.parse(jsonArgs);
+    sessionStorage.set(`${sid}:${key}`, value);
+};
+
+ext.session_delete = (sid, key) => {
+    sessionStorage.delete(`${sid}:${key}`);
+};
+
+ext.session_clear = (sid) => {
+    for (const key of sessionStorage.keys()) {
+        if (key.startsWith(`${sid}:`)) {
+            sessionStorage.delete(key);
+        }
+    }
+};
+
+// ============================================
+// OS - Emulation using Node.js os
+// ============================================
+
+ext.os_info = () => {
+    return JSON.stringify({
+        platform: nodeOs.platform(),
+        cpus: nodeOs.cpus().length,
+        totalMemory: nodeOs.totalmem(),
+        freeMemory: nodeOs.freemem(),
+        tmpdir: nodeOs.tmpdir()
+    });
+};
+
+// ============================================
+// NET - Basic emulation
+// ============================================
+
+ext.net_resolve = (hostname) => {
+    return JSON.stringify(['127.0.0.1']);
+};
+
+ext.net_ip = () => {
+    const interfaces = nodeOs.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name]) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return '127.0.0.1';
+};
+
+// ============================================
+// PROC - Basic emulation
+// ============================================
+
+ext.proc_info = () => {
+    return JSON.stringify({
+        pid: process.pid,
+        uptime: process.uptime()
+    });
+};
+
+ext.proc_run = (jsonArgs) => {
+    return JSON.stringify({ ok: false, error: 'Disabled in tests' });
+};
+
+ext.proc_kill = (pid) => {
+    return false;
+};
+
+ext.proc_list = () => {
+    return JSON.stringify([]);
+};
+
+// ============================================
+// TIME
+// ============================================
+
+ext.time_sleep = (ms) => {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { }
+};
+
+// ============================================
+// DATABASE - MOCK (only real mock)
+// ============================================
+
+globalThis.t.db = {
+    connect: vi.fn().mockReturnValue({
+        query: vi.fn().mockResolvedValue({ rows: [] }),
+        execute: vi.fn().mockResolvedValue({ rowCount: 0 }),
+        close: vi.fn()
+    })
+};
+
+// ============================================
+// Helpers to clear state between tests
+// ============================================
+
+export function clearStorage() {
+    localStorage.clear();
+    sessionStorage.clear();
+}
+
+import { beforeEach } from 'vitest';
+
+beforeEach(() => {
+    clearStorage();
+});

package/packages/core-source/tests/time.test.js

@@ -0,0 +1,57 @@
+/**
+ * tests/time.test.js
+ * 
+ * Tests for the time module
+ * time.now() - Pure JS (Date.now())
+ * time.sleep() - Native emulated
+ */
+import { describe, it, expect } from 'vitest';
+import { time } from '../index.js';
+
+describe('time', () => {
+    describe('now()', () => {
+        it('should return current timestamp', () => {
+            const before = Date.now();
+            const result = time.now();
+            const after = Date.now();
+            
+            expect(result).toBeGreaterThanOrEqual(before);
+            expect(result).toBeLessThanOrEqual(after);
+        });
+
+        it('should return number', () => {
+            expect(typeof time.now()).toBe('number');
+        });
+
+        it('should increment over time', async () => {
+            const first = time.now();
+            await new Promise(r => setTimeout(r, 10));
+            const second = time.now();
+            
+            expect(second).toBeGreaterThan(first);
+        });
+    });
+
+    describe('sleep()', () => {
+        it('should pause execution', () => {
+            const start = Date.now();
+            time.sleep(50);
+            const elapsed = Date.now() - start;
+            
+            // Should have passed at least 40ms (margin of error)
+            expect(elapsed).toBeGreaterThanOrEqual(40);
+        });
+
+        it('should accept small values', () => {
+            expect(() => time.sleep(1)).not.toThrow();
+        });
+
+        it('should handle 0ms', () => {
+            const start = Date.now();
+            time.sleep(0);
+            const elapsed = Date.now() - start;
+            
+            expect(elapsed).toBeLessThan(100);
+        });
+    });
+});

package/packages/core-source/tests/url.test.js

@@ -0,0 +1,82 @@
+/**
+ * tests/url.test.js
+ * 
+ * Tests for the url module
+ * Pure JS API - uses native URL and URLSearchParams
+ */
+import { describe, it, expect } from 'vitest';
+import { url } from '../index.js';
+
+describe('url', () => {
+    describe('parse()', () => {
+        it('should parse complete URL', () => {
+            const parsed = url.parse('https://example.com:8080/path?query=value#hash');
+            
+            expect(parsed.protocol).toBe('https:');
+            expect(parsed.hostname).toBe('example.com');
+            expect(parsed.port).toBe('8080');
+            expect(parsed.pathname).toBe('/path');
+            expect(parsed.search).toBe('?query=value');
+            expect(parsed.hash).toBe('#hash');
+        });
+
+        it('should parse simple URL', () => {
+            const parsed = url.parse('https://example.com');
+            
+            expect(parsed.hostname).toBe('example.com');
+            expect(parsed.pathname).toBe('/');
+        });
+
+        it('should return null for invalid URL', () => {
+            expect(url.parse('not-a-url')).toBeNull();
+            expect(url.parse('')).toBeNull();
+        });
+
+        it('should handle query params', () => {
+            const parsed = url.parse('https://api.example.com/search?q=test&page=1');
+            
+            expect(parsed.searchParams.get('q')).toBe('test');
+            expect(parsed.searchParams.get('page')).toBe('1');
+        });
+
+        it('should handle URLs with authentication', () => {
+            const parsed = url.parse('https://user:pass@example.com/path');
+            
+            expect(parsed.username).toBe('user');
+            expect(parsed.password).toBe('pass');
+        });
+    });
+
+    describe('SearchParams', () => {
+        it('should create URLSearchParams instance', () => {
+            const params = new url.SearchParams('foo=bar&baz=qux');
+            
+            expect(params.get('foo')).toBe('bar');
+            expect(params.get('baz')).toBe('qux');
+        });
+
+        it('should serialize to string', () => {
+            const params = new url.SearchParams();
+            params.append('key', 'value');
+            params.append('another', 'test');
+            
+            expect(params.toString()).toContain('key=value');
+            expect(params.toString()).toContain('another=test');
+        });
+
+        it('should handle encoded values', () => {
+            const params = new url.SearchParams();
+            params.set('message', 'Hello World!');
+            
+            expect(params.toString()).toContain('Hello');
+        });
+
+        it('should iterate over entries', () => {
+            const params = new url.SearchParams('a=1&b=2&c=3');
+            const entries = [...params.entries()];
+            
+            expect(entries).toHaveLength(3);
+            expect(entries[0]).toEqual(['a', '1']);
+        });
+    });
+});

package/packages/core-source/titan-ext.d.ts

@@ -0,0 +1,2 @@
+// titan-ext.d.ts
+/// <reference path="./globals.d.ts" />

package/packages/core-source/titan.json

@@ -0,0 +1,9 @@
+{
+    "name": "@titanpl/core",
+    "type": "native",
+    "entry": "index.js",
+    "native": {
+        "windows": "native/target/release/titan_core.dll",
+        "linux": "native/target/release/libtitan_core.so"
+    }
+}

package/packages/core-source/vitest.config.js

@@ -0,0 +1,8 @@
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        setupFiles: ['@tgrv/microgravity/setup'],
+    }
+});

package/packages/engine-darwin-arm64/README.md

@@ -9,5 +9,3 @@ This package is the compiled core Rust + Axum server embedded with the Boa JavaS
 This package is listed as an "optional dependency" in `@titanpl/cli`. During package installation, your package manager identifies the OS and automatically downloads this binary if it matches `darwin` + `arm64`. You do not need to install it directly. 
 
 When you run `titan start`, the CLI locates this binary and executes it as your web server.
-
-**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux and macOS versions are in development (dev only) for the new architecture and will be launched later.

package/packages/engine-darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/engine-darwin-arm64",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "os": [
     "darwin"
   ],

package/packages/engine-linux-x64/README.md

@@ -7,5 +7,3 @@ This package holds the core Rust + Axum high-performance web server tightly coup
 
 ## How it works
 You don't need to manually interact with this module. It acts as an optional dependency resolved by `#titanpl/cli`. If you run TitanPlanet on a Linux x64 machine, npm/yarn automatically downloads this native binary to run your application.
-
-**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/engine-linux-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/engine-linux-x64",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "os": [
     "linux"
   ],

package/packages/engine-win32-x64/README.md

@@ -8,4 +8,3 @@ This module provides the highly concurrent Rust-based server binary (`titan.exe`
 ## How it works
 Like the other engine packages, this works entirely behind the scenes. When `@titanpl/cli` is installed on a Windows instance, it fetches this `.exe` runtime. The CLI then maps your built assets and JS routes into the binary for deployment.
 
-**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/engine-win32-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/engine-win32-x64",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "os": [
     "win32"
   ],

package/packages/native/README.md

@@ -8,4 +8,3 @@ It acts as the low-level communication bridge offering type definitions and util
 ## How it works
 You can import tools and primitives from this package into your server-side actions alongside `@titanpl/core` when you want direct low-level interaction or need access to platform operations that interact directly with the C/Rust engine.
 
-**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/native/index.d.ts

@@ -22,12 +22,22 @@ export function defineAction<T = any>(handler: (req: Request) => T | Promise<T>)
 export function fetch(url: string, options?: any): any;
 export function drift<T>(op: any): T;
 
+export interface ShareContext {
+    get(key: string): any;
+    set(key: string, value: any): void;
+    delete(key: string): void;
+    keys(): string[];
+    broadcast(event: string, payload: any): void;
+}
+
 // Add more as needed based on native/index.js
-export const db: any;
-export const ws: {
-    send(id: string, message: string): void;
+export interface WebSocketModule {
+    send(socketId: string, message: string): void;
     broadcast(message: string): void;
-};
+}
+
+export const db: any;
+export const ws: WebSocketModule;
 export const path: any;
 export const jwt: any;
 export const password: any;
@@ -36,6 +46,7 @@ export const buffer: any;
 export const ls: any;
 export const session: any;
 export const cookies: any;
+export const shareContext: ShareContext;
 export const os: any;
 export const net: any;
 export const proc: any;
@@ -43,3 +54,13 @@ export const time: any;
 export const url: any;
 export const response: any;
 export const valid: any;
+
+// Serialization
+/** Binary-serializes a JavaScript value using V8's fast internal format. */
+export function serialize(value: any): Uint8Array;
+/** Binary-serializes a JavaScript value using V8's fast internal format. Alias for serialize. */
+export function serialise(value: any): Uint8Array;
+/** Deserializes a Uint8Array back into its original JavaScript value/object. */
+export function deserialize(buffer: Uint8Array): any;
+/** Deserializes a Uint8Array back into its original JavaScript value/object. Alias for deserialize. */
+export function deserialise(buffer: Uint8Array): any;

package/packages/native/index.js

@@ -27,6 +27,7 @@ export const ls = t.ls;
 export const localStorage = t.localStorage;
 export const session = t.session;
 export const cookies = t.cookies;
+export const shareContext = t.shareContext;
 
 // System
 export const os = t.os;
@@ -39,4 +40,10 @@ export const url = t.url;
 export const response = t.response;
 export const valid = t.valid;
 
+// Serialization
+export const serialize = t.serialize;
+export const serialise = t.serialise;
+export const deserialize = t.deserialize;
+export const deserialise = t.deserialise;
+
 export const defineAction = (handler) => handler;

package/packages/native/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/native",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "Titan native utilities package",
   "type": "module",
   "keywords": [
@@ -20,7 +20,7 @@
     }
   },
   "dependencies": {
-    "@titanpl/core": "latest",
+    "@titanpl/core": "7.0.0",
     "@titanpl/node": "latest"
   }
 }