titanpl 6.0.0 → 7.0.0

package/packages/core-source/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@titanpl/core",
+  "version": "7.0.0",
+  "description": "The official Core Standard Library for Titan Planet - provides fs, path, crypto, os, net, proc, time, and url modules",
+  "main": "index.js",
+  "type": "module",
+  "types": "index.d.ts",
+  "scripts": {
+    "configure": "node configure.js",
+    "postinstall": "node configure.js",
+    "build:native": "cd native && cargo build --release && cd .. && npm run configure",
+    "test:ext": "titan run ext",
+    "test": "vitest run",
+    "test:debug": "TITAN_DEBUG=true npm test",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "titan",
+    "titanpl",
+    "titan-planet",
+    "runtime",
+    "core",
+    "fs",
+    "path",
+    "crypto",
+    "os",
+    "extension",
+    "titanpl-sdk"
+  ],
+  "author": "ezetgalaxy",
+  "license": "ISC",
+  "files": [
+    "index.js",
+    "configure.js",
+    "titan.json",
+    "globals.d.ts",
+    "index.d.ts",
+    "native/target/release/*.dll",
+    "native/target/release/*.so",
+    "native/target/release/*.dylib",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0",
+    "@ezetgalaxy/titan": ">=26.10.2"
+  },
+  "devDependencies": {
+    "esbuild": "^0.27.2"
+  },
+  "dependencies": {
+    "@titanpl/valid": "^1.1.1"
+  }
+}

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

@@ -0,0 +1,78 @@
+/**
+ * tests/buffer.test.js
+ * 
+ * Tests for the buffer module (Base64 encoding/decoding)
+ * Pure JS API - no mocks required
+ */
+import { describe, it, expect } from 'vitest';
+import { buffer } from '../index.js';
+
+describe('buffer', () => {
+    describe('toBase64()', () => {
+        it('should encode string to base64', () => {
+            const result = buffer.toBase64('Hello World');
+            expect(result.replace(/=+$/, '')).toBe('SGVsbG8gV29ybGQ');
+        });
+
+        it('should encode empty string', () => {
+            expect(buffer.toBase64('')).toBe('');
+        });
+
+        it('should handle special characters', () => {
+            const result = buffer.toBase64('Hola ñ');
+            expect(result).toBeTruthy();
+            expect(typeof result).toBe('string');
+        });
+
+        it('should encode Uint8Array', () => {
+            const bytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+            const result = buffer.toBase64(bytes);
+            expect(result.replace(/=+$/, '')).toBe('SGVsbG8');
+        });
+
+        it('should handle binary data', () => {
+            const bytes = new Uint8Array([0, 1, 2, 255, 254]);
+            const encoded = buffer.toBase64(bytes);
+            expect(encoded).toBeTruthy();
+        });
+    });
+
+    describe('fromBase64()', () => {
+        it('should decode base64 to Uint8Array', () => {
+            const result = buffer.fromBase64('SGVsbG8gV29ybGQ=');
+            expect(result).toBeInstanceOf(Uint8Array);
+            const validBytes = result.filter(b => b >= 32 && b <= 126);
+            const text = new TextDecoder().decode(validBytes);
+            expect(text).toContain('Hello World');
+        });
+
+        it('should handle empty string', () => {
+            const result = buffer.fromBase64('');
+            expect(result).toBeInstanceOf(Uint8Array);
+            expect(result.length).toBe(0);
+        });
+
+        it('should ignore invalid characters', () => {
+            const result = buffer.fromBase64('SGVs bG8='); // with space
+            expect(result).toBeInstanceOf(Uint8Array);
+        });
+    });
+
+    describe('roundtrip', () => {
+        it('should encode and decode correctly', () => {
+            const original = 'Test string 123!@#';
+            const encoded = buffer.toBase64(original);
+            const decoded = buffer.fromBase64(encoded);
+            const filtered = decoded.filter(b => b !== 0);
+            const result = new TextDecoder().decode(filtered);
+            expect(result).toBe(original);
+        });
+
+        it('should work with simple binary data', () => {
+            const original = new Uint8Array([65, 66, 67]); // ABC
+            const encoded = buffer.toBase64(original);
+            const decoded = buffer.fromBase64(encoded);
+            expect(decoded.slice(0, original.length)).toEqual(original);
+        });
+    });
+});

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

@@ -0,0 +1,117 @@
+/**
+ * tests/cookies.test.js
+ * 
+ * Tests for the cookies module
+ * Pure JS API - no mocks required
+ */
+import { describe, it, expect } from 'vitest';
+import { cookies } from '../index.js';
+
+describe('cookies', () => {
+    describe('get()', () => {
+        it('should extract cookie from request', () => {
+            const req = {
+                headers: {
+                    cookie: 'session=abc123; user=john'
+                }
+            };
+            
+            expect(cookies.get(req, 'session')).toBe('abc123');
+            expect(cookies.get(req, 'user')).toBe('john');
+        });
+
+        it('should return null if cookie does not exist', () => {
+            const req = {
+                headers: {
+                    cookie: 'session=abc123'
+                }
+            };
+            
+            expect(cookies.get(req, 'nonexistent')).toBeNull();
+        });
+
+        it('should return null if no headers', () => {
+            expect(cookies.get({}, 'session')).toBeNull();
+            expect(cookies.get({ headers: {} }, 'session')).toBeNull();
+        });
+
+        it('should return null if req is null/undefined', () => {
+            expect(cookies.get(null, 'session')).toBeNull();
+            expect(cookies.get(undefined, 'session')).toBeNull();
+        });
+
+        it('should handle cookie at start of string', () => {
+            const req = {
+                headers: { cookie: 'first=value; second=other' }
+            };
+            
+            expect(cookies.get(req, 'first')).toBe('value');
+        });
+
+        it('should handle values with special characters', () => {
+            const req = {
+                headers: { cookie: 'token=eyJhbGciOiJIUzI1NiJ9.test' }
+            };
+            
+            expect(cookies.get(req, 'token')).toBe('eyJhbGciOiJIUzI1NiJ9.test');
+        });
+    });
+
+    describe('set()', () => {
+        it('should set basic cookie', () => {
+            const res = {};
+            cookies.set(res, 'session', 'abc123');
+            
+            expect(res.headers['Set-Cookie']).toBe('session=abc123');
+        });
+
+        it('should set cookie with options', () => {
+            const res = {};
+            cookies.set(res, 'auth', 'token123', {
+                httpOnly: true,
+                secure: true,
+                sameSite: 'Strict',
+                maxAge: 3600,
+                path: '/'
+            });
+            
+            const cookie = res.headers['Set-Cookie'];
+            expect(cookie).toContain('auth=token123');
+            expect(cookie).toContain('HttpOnly');
+            expect(cookie).toContain('Secure');
+            expect(cookie).toContain('SameSite=Strict');
+            expect(cookie).toContain('Max-Age=3600');
+            expect(cookie).toContain('Path=/');
+        });
+
+        it('should handle multiple cookies', () => {
+            const res = {};
+            cookies.set(res, 'first', 'value1');
+            cookies.set(res, 'second', 'value2');
+            
+            expect(Array.isArray(res.headers['Set-Cookie'])).toBe(true);
+            expect(res.headers['Set-Cookie']).toHaveLength(2);
+        });
+
+        it('should not fail if res is null', () => {
+            expect(() => cookies.set(null, 'test', 'value')).not.toThrow();
+        });
+
+        it('should create headers if they do not exist', () => {
+            const res = {};
+            cookies.set(res, 'new', 'cookie');
+            
+            expect(res.headers).toBeDefined();
+            expect(res.headers['Set-Cookie']).toBe('new=cookie');
+        });
+    });
+
+    describe('delete()', () => {
+        it.skip('should delete cookie by setting empty value', () => {
+            const res = {};
+            cookies.delete(res, 'session');
+            
+            expect(res.headers['Set-Cookie']).toContain('session=');
+        });
+    });
+});

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

@@ -0,0 +1,142 @@
+/**
+ * tests/crypto.test.js
+ * 
+ * Tests for the crypto module
+ * Uses emulated natives wrapping Node.js crypto
+ */
+import { describe, it, expect } from 'vitest';
+import { crypto } from '../index.js';
+
+describe('crypto', () => {
+    describe('hash()', () => {
+        it('should generate SHA256 hash', () => {
+            const hash = crypto.hash('sha256', 'hello');
+            
+            expect(hash).toBe('2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824');
+        });
+
+        it('should generate SHA512 hash', () => {
+            const hash = crypto.hash('sha512', 'hello');
+            
+            expect(hash).toHaveLength(128); // SHA512 = 64 bytes = 128 hex chars
+            expect(hash).toMatch(/^[a-f0-9]+$/);
+        });
+
+        it('should return different hashes for different inputs', () => {
+            const hash1 = crypto.hash('sha256', 'hello');
+            const hash2 = crypto.hash('sha256', 'world');
+            
+            expect(hash1).not.toBe(hash2);
+        });
+
+        it('should return same hash for same input', () => {
+            const hash1 = crypto.hash('sha256', 'consistent');
+            const hash2 = crypto.hash('sha256', 'consistent');
+            
+            expect(hash1).toBe(hash2);
+        });
+    });
+
+    describe('randomBytes()', () => {
+        it('should generate random bytes in hex', () => {
+            const bytes = crypto.randomBytes(16);
+            
+            expect(bytes).toHaveLength(32); // 16 bytes = 32 hex chars
+            expect(bytes).toMatch(/^[a-f0-9]+$/);
+        });
+
+        it('should generate different values each time', () => {
+            const bytes1 = crypto.randomBytes(16);
+            const bytes2 = crypto.randomBytes(16);
+            
+            expect(bytes1).not.toBe(bytes2);
+        });
+
+        it('should respect specified size', () => {
+            expect(crypto.randomBytes(8)).toHaveLength(16);
+            expect(crypto.randomBytes(32)).toHaveLength(64);
+        });
+    });
+
+    describe('uuid()', () => {
+        it('should generate valid UUID v4', () => {
+            const uuid = crypto.uuid();
+            
+            expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+        });
+
+        it('should generate unique UUIDs', () => {
+            const uuids = new Set();
+            for (let i = 0; i < 100; i++) {
+                uuids.add(crypto.uuid());
+            }
+            
+            expect(uuids.size).toBe(100);
+        });
+    });
+
+    describe('encrypt() and decrypt()', () => {
+        it('should encrypt and decrypt text', () => {
+            const key = '12345678901234567890123456789012'; // 32 bytes
+            const plaintext = 'Secret message';
+            
+            const encrypted = crypto.encrypt('aes-256-gcm', key, plaintext);
+            const decrypted = crypto.decrypt('aes-256-gcm', key, encrypted);
+            
+            expect(decrypted).toBe(plaintext);
+        });
+
+        it('should generate different ciphertexts for same plaintext', () => {
+            const key = '12345678901234567890123456789012';
+            const plaintext = 'Same message';
+            
+            const encrypted1 = crypto.encrypt('aes-256-gcm', key, plaintext);
+            const encrypted2 = crypto.encrypt('aes-256-gcm', key, plaintext);
+            
+            // Due to random IV, they should be different
+            expect(encrypted1).not.toBe(encrypted2);
+        });
+
+        it('should handle empty text', () => {
+            const key = '12345678901234567890123456789012';
+            
+            const encrypted = crypto.encrypt('aes-256-gcm', key, '');
+            const decrypted = crypto.decrypt('aes-256-gcm', key, encrypted);
+            
+            expect(decrypted).toBe('');
+        });
+    });
+
+    describe('compare()', () => {
+        it('should return true for equal strings', () => {
+            expect(crypto.compare('abc', 'abc')).toBe(true);
+        });
+
+        it('should return false for different strings', () => {
+            expect(crypto.compare('abc', 'def')).toBe(false);
+        });
+    });
+
+    describe('hashKeyed()', () => {
+        it('should generate HMAC-SHA256', () => {
+            const hmac = crypto.hashKeyed('sha256', 'secret-key', 'message');
+            
+            expect(hmac).toHaveLength(64); // SHA256 = 32 bytes = 64 hex
+            expect(hmac).toMatch(/^[a-f0-9]+$/);
+        });
+
+        it('should generate different HMACs with different keys', () => {
+            const hmac1 = crypto.hashKeyed('sha256', 'key1', 'message');
+            const hmac2 = crypto.hashKeyed('sha256', 'key2', 'message');
+            
+            expect(hmac1).not.toBe(hmac2);
+        });
+
+        it('should be consistent with same parameters', () => {
+            const hmac1 = crypto.hashKeyed('sha256', 'key', 'msg');
+            const hmac2 = crypto.hashKeyed('sha256', 'key', 'msg');
+            
+            expect(hmac1).toBe(hmac2);
+        });
+    });
+});

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

@@ -0,0 +1,176 @@
+/**
+ * tests/fs.test.js
+ * 
+ * Tests for the fs module
+ * Uses emulated natives wrapping Node.js fs
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { fs, path } from '../index.js';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+describe('fs', () => {
+    let testDir;
+
+    beforeEach(() => {
+        testDir = mkdtempSync(join(tmpdir(), 'titanpl-test-'));
+    });
+
+    afterEach(() => {
+        try {
+            rmSync(testDir, { recursive: true, force: true });
+        } catch { }
+    });
+
+    describe('writeFile() and readFile()', () => {
+        it('should write and read text file', () => {
+            const filePath = join(testDir, 'test.txt');
+            const content = 'Hello, Titan!';
+            
+            fs.writeFile(filePath, content);
+            const result = fs.readFile(filePath);
+            
+            expect(result).toBe(content);
+        });
+
+        it('should handle multiline content', () => {
+            const filePath = join(testDir, 'multiline.txt');
+            const content = 'Line 1\nLine 2\nLine 3';
+            
+            fs.writeFile(filePath, content);
+            const result = fs.readFile(filePath);
+            
+            expect(result).toBe(content);
+        });
+
+        it('should overwrite existing file', () => {
+            const filePath = join(testDir, 'overwrite.txt');
+            
+            fs.writeFile(filePath, 'Original');
+            fs.writeFile(filePath, 'Updated');
+            
+            expect(fs.readFile(filePath)).toBe('Updated');
+        });
+
+        it('should handle JSON', () => {
+            const filePath = join(testDir, 'data.json');
+            const data = { name: 'Test', value: 42 };
+            
+            fs.writeFile(filePath, JSON.stringify(data));
+            const result = JSON.parse(fs.readFile(filePath));
+            
+            expect(result).toEqual(data);
+        });
+    });
+
+    describe('exists()', () => {
+        it('should return true for existing file', () => {
+            const filePath = join(testDir, 'exists.txt');
+            fs.writeFile(filePath, 'test');
+            
+            expect(fs.exists(filePath)).toBe(true);
+        });
+
+        it('should return false for non-existing file', () => {
+            expect(fs.exists(join(testDir, 'nonexistent.txt'))).toBe(false);
+        });
+
+        it('should work with directories', () => {
+            expect(fs.exists(testDir)).toBe(true);
+        });
+    });
+
+    describe('mkdir()', () => {
+        it('should create directory', () => {
+            const dirPath = join(testDir, 'newdir');
+            
+            fs.mkdir(dirPath);
+            
+            expect(fs.exists(dirPath)).toBe(true);
+        });
+
+        it('should create nested directories (recursive)', () => {
+            const dirPath = join(testDir, 'a', 'b', 'c');
+            
+            fs.mkdir(dirPath);
+            
+            expect(fs.exists(dirPath)).toBe(true);
+        });
+    });
+
+    describe('readdir()', () => {
+        it('should list directory contents', () => {
+            fs.writeFile(join(testDir, 'file1.txt'), 'a');
+            fs.writeFile(join(testDir, 'file2.txt'), 'b');
+            
+            const files = fs.readdir(testDir);
+            
+            expect(files).toContain('file1.txt');
+            expect(files).toContain('file2.txt');
+        });
+
+        it('should return empty array for empty directory', () => {
+            const emptyDir = join(testDir, 'empty');
+            fs.mkdir(emptyDir);
+            
+            const files = fs.readdir(emptyDir);
+            
+            expect(files).toEqual([]);
+        });
+
+        it('should return empty array if not exists', () => {
+            const files = fs.readdir(join(testDir, 'nonexistent'));
+            
+            expect(files).toEqual([]);
+        });
+    });
+
+    describe('stat()', () => {
+        it('should return file stats', () => {
+            const filePath = join(testDir, 'stat-test.txt');
+            fs.writeFile(filePath, 'Hello World');
+            
+            const stat = fs.stat(filePath);
+            
+            expect(stat.isFile).toBe(true);
+            expect(stat.isDir).toBe(false);
+            expect(stat.size).toBeGreaterThan(0);
+            expect(stat.modified).toBeGreaterThan(0);
+        });
+
+        it('should return directory stats', () => {
+            const stat = fs.stat(testDir);
+            
+            expect(stat.isFile).toBe(false);
+            expect(stat.isDir).toBe(true);
+        });
+
+        it('should return empty object if not exists', () => {
+            const stat = fs.stat(join(testDir, 'nonexistent'));
+            
+            expect(stat).toEqual({});
+        });
+    });
+
+    describe('remove()', () => {
+        it('should remove file', () => {
+            const filePath = join(testDir, 'to-delete.txt');
+            fs.writeFile(filePath, 'delete me');
+            
+            expect(fs.exists(filePath)).toBe(true);
+            fs.remove(filePath);
+            expect(fs.exists(filePath)).toBe(false);
+        });
+
+        it('should remove directory with contents', () => {
+            const dirPath = join(testDir, 'to-delete-dir');
+            fs.mkdir(dirPath);
+            fs.writeFile(join(dirPath, 'file.txt'), 'content');
+            
+            fs.remove(dirPath);
+            
+            expect(fs.exists(dirPath)).toBe(false);
+        });
+    });
+});