roster-server 1.9.4 → 1.9.6

package/README.md

@@ -205,27 +205,11 @@ const roster = new Roster({
 });
 ```
 
-### Getting Local URLs
+### Getting URLs
 
-RosterServer provides two methods to get the local URL for a domain:
+RosterServer provides a method to get the URL for a domain that adapts automatically to your environment:
 
-**1. Static Method (Predictable, No Instance Required):**
-
-```javascript
-// Get the URL before starting the server (using default range 4000-9999)
-const url = Roster.getLocalUrl('example.com');
-console.log(url); // http://localhost:9465
-
-// Or specify custom port range
-const customUrl = Roster.getLocalUrl('example.com', { 
-    minLocalPort: 5000, 
-    maxLocalPort: 6000 
-});
-```
-
-This static method calculates the port deterministically using CRC32, so you can predict the URL before even creating a Roster instance.
-
-**2. Instance Method (After Registration):**
+**Instance Method: `roster.getUrl(domain)`**
 
 ```javascript
 const roster = new Roster({ local: true });
@@ -233,29 +217,43 @@ roster.register('example.com', handler);
 
 await roster.start();
 
-// Get the actual URL assigned to the domain
-const url = roster.getLocalUrl('example.com');
-console.log(url); // http://localhost:9465
+// Get the URL - automatically adapts to environment
+const url = roster.getUrl('example.com');
+console.log(url); 
+// Local mode: http://localhost:9465
+// Production mode: https://example.com
 ```
 
-This instance method returns the actual URL assigned to the domain after the server starts. It's useful when you need to confirm the URL or when there might be port collisions.
+This method:
+- Returns the correct URL based on your environment (`local: true/false`)
+- In **local mode**: Returns `http://localhost:{port}` with the assigned port
+- In **production mode**: Returns `https://{domain}` (or with custom port if configured)
+- Handles `www.` prefix automatically (returns same URL)
+- Returns `null` for domains that aren't registered
 
 **Example Usage:**
 
 ```javascript
-const roster = new Roster({ local: true });
-
-roster.register('example.com', (httpsServer) => {
-    return (req, res) => {
-        res.writeHead(200);
-        res.end('Hello World!');
-    };
-});
-
-roster.start().then(() => {
-    const url = roster.getLocalUrl('example.com');
-    console.log(`Server available at: ${url}`);
-});
+// Local development
+const localRoster = new Roster({ local: true });
+localRoster.register('example.com', handler);
+await localRoster.start();
+console.log(localRoster.getUrl('example.com')); 
+// → http://localhost:9465
+
+// Production
+const prodRoster = new Roster({ local: false });
+prodRoster.register('example.com', handler);
+await prodRoster.start();
+console.log(prodRoster.getUrl('example.com')); 
+// → https://example.com
+
+// Production with custom port
+const customRoster = new Roster({ local: false, port: 8443 });
+customRoster.register('api.example.com', handler);
+await customRoster.start();
+console.log(customRoster.getUrl('api.example.com')); 
+// → https://api.example.com:8443
 ```
 
 ## 🧂 A Touch of Magic

package/demo/custom-port-range.js

@@ -7,15 +7,7 @@ const roster = new Roster({
     maxLocalPort: 5100   // Custom maximum port
 });
 
-console.log('\n📍 Static URL Prediction with custom range (5000-5100):');
-console.log('example.com →', Roster.getLocalUrl('example.com', { 
-    minLocalPort: 5000, 
-    maxLocalPort: 5100 
-}));
-console.log('api.example.com →', Roster.getLocalUrl('api.example.com', { 
-    minLocalPort: 5000, 
-    maxLocalPort: 5100 
-}));
+console.log('\n🔧 Creating server with custom port range (5000-5100)...\n');
 
 roster.register('example.com', (httpsServer) => {
     return (req, res) => {
@@ -32,9 +24,9 @@ roster.register('api.example.com', (httpsServer) => {
 });
 
 roster.start().then(() => {
-    console.log('\n🚀 Server Started with custom port range:');
-    console.log('example.com →', roster.getLocalUrl('example.com'));
-    console.log('api.example.com →', roster.getLocalUrl('api.example.com'));
+    console.log('🚀 Server Started with custom port range:');
+    console.log('example.com →', roster.getUrl('example.com'));
+    console.log('api.example.com →', roster.getUrl('api.example.com'));
     
     console.log('\n✅ Both domains running in custom port range (5000-5100)!');
 });

package/demo/environment-aware-url.js

@@ -0,0 +1,55 @@
+const Roster = require('../index.js');
+
+// Example 1: Local mode
+console.log('\n📍 EXAMPLE 1: Local Development Mode\n');
+const localRoster = new Roster({ local: true });
+
+localRoster.register('example.com', (httpsServer) => {
+    return (req, res) => {
+        res.writeHead(200, { 'Content-Type': 'text/plain' });
+        res.end('Hello from local!');
+    };
+});
+
+localRoster.start().then(() => {
+    console.log('Local URL:', localRoster.getUrl('example.com'));
+    console.log('→ Returns: http://localhost:{port}\n');
+});
+
+// Example 2: Production mode (simulated, without actually starting)
+console.log('📍 EXAMPLE 2: Production Mode (simulated)\n');
+const prodRoster = new Roster({ 
+    local: false,
+    email: 'admin@example.com'
+});
+
+prodRoster.register('example.com', (httpsServer) => {
+    return (req, res) => {
+        res.writeHead(200);
+        res.end('Hello from production!');
+    };
+});
+
+// Don't actually start (would need real SSL), just show what URL would be
+console.log('Production URL (without starting):', 'https://example.com');
+console.log('→ Would return: https://example.com\n');
+
+// Example 3: Production with custom port
+console.log('📍 EXAMPLE 3: Production with Custom Port (simulated)\n');
+const customPortRoster = new Roster({ 
+    local: false,
+    port: 8443,
+    email: 'admin@example.com'
+});
+
+customPortRoster.register('api.example.com', (httpsServer) => {
+    return (req, res) => {
+        res.writeHead(200);
+        res.end('API');
+    };
+});
+
+console.log('Custom port URL (without starting):', 'https://api.example.com:8443');
+console.log('→ Would return: https://api.example.com:8443\n');
+
+console.log('✅ getUrl() adapts to the environment automatically!');

package/demo/local-url-example.js

@@ -1,12 +1,8 @@
 const Roster = require('../index.js');
 
-// Example 1: Get URL before creating instance (static method)
-console.log('\n📍 Static URL Prediction (before server starts):');
-console.log('example.com →', Roster.getLocalUrl('example.com'));
-console.log('api.example.com →', Roster.getLocalUrl('api.example.com'));
-console.log('test.example.com →', Roster.getLocalUrl('test.example.com'));
+// Example: Get URL after registration (adapts to environment)
+console.log('\n🔧 Creating local development server...\n');
 
-// Example 2: Get URL after registration (instance method)
 const roster = new Roster({ local: true });
 
 roster.register('example.com', (httpsServer) => {
@@ -24,17 +20,17 @@ roster.register('api.example.com', (httpsServer) => {
 });
 
 roster.start().then(() => {
-    console.log('\n🚀 Server Started - Actual URLs:');
-    console.log('example.com →', roster.getLocalUrl('example.com'));
-    console.log('api.example.com →', roster.getLocalUrl('api.example.com'));
+    console.log('🚀 Server Started - URLs (based on environment):');
+    console.log('example.com →', roster.getUrl('example.com'));
+    console.log('api.example.com →', roster.getUrl('api.example.com'));
     
     // Test with www prefix (should return same URL)
     console.log('\n🔄 Testing www prefix handling:');
-    console.log('www.example.com →', roster.getLocalUrl('www.example.com'));
+    console.log('www.example.com →', roster.getUrl('www.example.com'));
     
     // Test non-existent domain
     console.log('\n❌ Testing non-existent domain:');
-    console.log('nonexistent.com →', roster.getLocalUrl('nonexistent.com') || 'null (domain not registered)');
+    console.log('nonexistent.com →', roster.getUrl('nonexistent.com') || 'null (domain not registered)');
     
     console.log('\n✅ All domains running!');
 });

package/demo/socketio.js

@@ -27,11 +27,7 @@ roster.register('example.com', (httpsServer) => {
 });
 
 roster.start().then(() => {
-    // Get local URL for registered domain (requires instance)
-    const url = roster.getLocalUrl('example.com');
+    // Get URL for registered domain (adapts to environment)
+    const url = roster.getUrl('example.com');
     console.log(`✅ Socket.IO server available at: ${url}`);
-    
-    // Get local URL without instance (static method - predictable port)
-    const staticUrl = Roster.getLocalUrl('example.com');
-    console.log(`ℹ️  Static prediction: ${staticUrl}`);
 });

package/demo/test-geturl.js

@@ -0,0 +1,64 @@
+const Roster = require('../index.js');
+
+console.log('\n🧪 Testing getUrl() method in different scenarios\n');
+
+// Test 1: Local mode with default port
+console.log('TEST 1: Local mode (default port)');
+const local1 = new Roster({ local: true });
+local1.register('example.com', () => (req, res) => res.end('OK'));
+local1.start().then(() => {
+    const url = local1.getUrl('example.com');
+    console.log(`✓ example.com → ${url}`);
+    console.assert(url.startsWith('http://localhost:'), 'Should be localhost HTTP');
+});
+
+// Test 2: Local mode with custom port range
+console.log('\nTEST 2: Local mode (custom port range)');
+const local2 = new Roster({ local: true, minLocalPort: 6000, maxLocalPort: 6100 });
+local2.register('test.com', () => (req, res) => res.end('OK'));
+local2.start().then(() => {
+    const url = local2.getUrl('test.com');
+    console.log(`✓ test.com → ${url}`);
+    const port = parseInt(url.split(':')[2]);
+    console.assert(port >= 6000 && port <= 6100, 'Port should be in custom range');
+});
+
+// Test 3: Production mode (default HTTPS port)
+console.log('\nTEST 3: Production mode (default HTTPS)');
+const prod1 = new Roster({ local: false, email: 'admin@example.com' });
+prod1.register('example.com', () => (req, res) => res.end('OK'));
+const prodUrl1 = prod1.getUrl('example.com');
+console.log(`✓ example.com → ${prodUrl1}`);
+console.assert(prodUrl1 === 'https://example.com', 'Should be HTTPS without port');
+
+// Test 4: Production mode (custom port)
+console.log('\nTEST 4: Production mode (custom port)');
+const prod2 = new Roster({ local: false, port: 8443, email: 'admin@example.com' });
+prod2.register('api.example.com', () => (req, res) => res.end('OK'));
+const prodUrl2 = prod2.getUrl('api.example.com');
+console.log(`✓ api.example.com → ${prodUrl2}`);
+console.assert(prodUrl2 === 'https://api.example.com:8443', 'Should include custom port');
+
+// Test 5: www prefix handling
+console.log('\nTEST 5: www prefix handling');
+const local3 = new Roster({ local: true });
+local3.register('example.com', () => (req, res) => res.end('OK'));
+local3.start().then(() => {
+    const url1 = local3.getUrl('example.com');
+    const url2 = local3.getUrl('www.example.com');
+    console.log(`✓ example.com → ${url1}`);
+    console.log(`✓ www.example.com → ${url2}`);
+    console.assert(url1 === url2, 'www should return same URL');
+});
+
+// Test 6: Non-existent domain
+console.log('\nTEST 6: Non-existent domain');
+const local4 = new Roster({ local: true });
+local4.register('example.com', () => (req, res) => res.end('OK'));
+local4.start().then(() => {
+    const url = local4.getUrl('nonexistent.com');
+    console.log(`✓ nonexistent.com → ${url}`);
+    console.assert(url === null, 'Should return null for unregistered domain');
+    
+    console.log('\n✅ All tests passed!\n');
+});

package/index.js

@@ -367,41 +367,32 @@ class Roster {
     }
 
     /**
-     * Get the local URL for a domain when running in local mode
-     * @param {string} domain - The domain name (e.g., 'example.com')
-     * @param {Object} options - Optional configuration
-     * @param {number} options.minLocalPort - Minimum port range (default: 4000)
-     * @param {number} options.maxLocalPort - Maximum port range (default: 9999)
-     * @returns {string} The local URL (e.g., 'http://localhost:4321')
-     */
-    static getLocalUrl(domain, options = {}) {
-        const minPort = options.minLocalPort || 4000;
-        const maxPort = options.maxLocalPort || 9999;
-        
-        // Remove www prefix if present
-        const cleanDomain = domain.startsWith('www.') ? domain.slice(4) : domain;
-        
-        // Calculate deterministic port
-        const port = domainToPort(cleanDomain, minPort, maxPort);
-        
-        return `http://localhost:${port}`;
-    }
-
-    /**
-     * Get the local URL for a domain that was registered on this instance
+     * Get the URL for a domain based on the current environment
      * @param {string} domain - The domain name
-     * @returns {string|null} The local URL if found, null otherwise
+     * @returns {string|null} The URL if domain is registered, null otherwise
      */
-    getLocalUrl(domain) {
+    getUrl(domain) {
         // Remove www prefix if present
         const cleanDomain = domain.startsWith('www.') ? domain.slice(4) : domain;
         
-        // Check if domain has a port assigned
-        if (this.domainPorts && this.domainPorts[cleanDomain]) {
-            return `http://localhost:${this.domainPorts[cleanDomain]}`;
+        // Check if domain is registered
+        const isRegistered = this.sites[cleanDomain] || this.sites[`www.${cleanDomain}`];
+        if (!isRegistered) {
+            return null;
         }
         
-        return null;
+        // Return URL based on environment
+        if (this.local) {
+            // Local mode: return localhost URL with assigned port
+            if (this.domainPorts && this.domainPorts[cleanDomain]) {
+                return `http://localhost:${this.domainPorts[cleanDomain]}`;
+            }
+            return null;
+        } else {
+            // Production mode: return HTTPS URL
+            const port = this.defaultPort === 443 ? '' : `:${this.defaultPort}`;
+            return `https://${cleanDomain}${port}`;
+        }
     }
 
     createVirtualServer(domain) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "roster-server",
-    "version": "1.9.4",
+    "version": "1.9.6",
     "description": "👾 RosterServer - A domain host router to host multiple HTTPS.",
     "main": "index.js",
     "scripts": {