api-ape 3.0.1 → 3.0.2

package/server/adapters/README.md

@@ -5,15 +5,15 @@ Connect multiple api-ape server instances via a shared database for horizontal s
 ## Quick Start
 
 ```js
-import ape from 'api-ape/server';
-import { createClient } from 'redis';
+const { ape } = require('api-ape')
+const { createClient } = require('redis')
 
 // Connect to your database
-const redis = createClient();
-await redis.connect();
+const redis = createClient()
+await redis.connect()
 
 // Join the cluster — APE creates its own namespace
-ape.joinVia(redis);
+ape.joinVia(redis)
 ```
 
 That's it. APE will:

package/server/client.js

@@ -217,6 +217,12 @@ function onConnectionChange(handler) {
  */
 const handler = {
     get(target, prop) {
+        // First check if property exists on target (set via defineProperty)
+        // This allows named exports like 'ape' to be accessed directly
+        if (Reflect.has(target, prop)) {
+            return Reflect.get(target, prop)
+        }
+
         // Reserved properties - same as browser
         if (prop === 'on') return on
         if (prop === 'onConnectionChange') return onConnectionChange
@@ -229,18 +235,13 @@ const handler = {
         const wrapperFn = function (a, b) {
             let path = joinKey + prop, body
             // Two args: first is path segment (string), second is body
-            // One arg: it's the body (unless it's a string, then it's a path segment with no body)
-            if (arguments.length === 2) {
+            // One arg: it's always the body (matches browser client behavior)
+            if (arguments.length === 2 && typeof a === 'string') {
                 path += a
                 body = b
-            } else if (arguments.length === 1) {
-                // If first arg is a string, treat as path segment, otherwise as body
-                if (typeof a === 'string') {
-                    path += a
-                    body = undefined
-                } else {
-                    body = a
-                }
+            } else {
+                // Single arg or non-string first arg: treat first arg as body
+                body = a
             }
             return queueOrSend(path, body)
         }
@@ -305,4 +306,6 @@ module.exports.onConnectionChange = onConnectionChange
 module.exports.connect = connect
 module.exports.close = close
 module.exports.ConnectionState = ConnectionState
+// Internal: expose queueOrSend for ape dual-purpose function
+module.exports._queueOrSend = queueOrSend
 

package/server/index.js

@@ -1,36 +1,90 @@
 /**
  * api-ape server entry point
  * 
- * V3 Usage (100% identical on browser and server):
- *   import api from 'api-ape'
- *   api.hello('World')  // Works same on browser AND server
- *   api.on('message', (data) => console.log(data))
+ * V3 Usage:
+ *   const api = require('api-ape')           // Get client proxy (default)
+ *   const { ape } = require('api-ape')       // Get server/API function
  * 
- * Server Setup:
+ *   // ESM
  *   import api, { ape } from 'api-ape'
- *   ape(server, { where: 'api' })  // Start your server
- *   
- *   // Connect to another server (set APE_SERVER env or call api.connect)
- *   api.connect('ws://other-server:3000/api/ape')
- *   api.hello('World')
  * 
- * Supports both CommonJS and ES Modules
+ * Server Setup:
+ *   ape(server, { where: 'api' })            // First arg is HTTP server → setup
+ * 
+ * API Call:
+ *   api.ape({ data: 'foo' })                 // Calls /ape endpoint
+ *   // or equivalently:
+ *   ape({ data: 'foo' })                     // Also calls /ape (detects it's not a server)
+ * 
+ * The ape function intelligently detects:
+ *   - HTTP server (has .listen/.on) → Server setup mode
+ *   - Anything else → API call to /ape
  */
 
-const ape = require('./lib/main')
+const serverApe = require('./lib/main')
 const { broadcast, clients } = require('./lib/broadcast')
 const api = require('./client')
+const { _queueOrSend } = require('./client')
+
+// Attach broadcast utilities to the serverApe function
+serverApe.broadcast = broadcast
+serverApe.clients = clients
+
+/**
+ * Check if value looks like an HTTP server
+ */
+function isHttpServer(val) {
+    return val && typeof val === 'object' && (
+        typeof val.listen === 'function' ||
+        typeof val.on === 'function' ||
+        typeof val.address === 'function'
+    )
+}
+
+/**
+ * Dual-purpose ape function:
+ * - Called with HTTP server → Setup server
+ * - Called with anything else → API call to /ape
+ */
+function ape(firstArg, ...rest) {
+    if (isHttpServer(firstArg)) {
+        // Server setup mode
+        return serverApe(firstArg, ...rest)
+    }
+    // API call mode - directly call the internal queueOrSend
+    return _queueOrSend('/ape', firstArg)
+}
 
-// Attach broadcast utilities to the ape function
+// Copy properties from serverApe to ape
 ape.broadcast = broadcast
 ape.clients = clients
 
-// Default export: api client (same interface as browser)
+// Store original serverApe for direct access if needed
+ape._serverApe = serverApe
+
+// Define ape on the proxy's target so it can be destructured
+// The proxy handler checks Reflect.has first, so this will be found
+Object.defineProperty(api, 'ape', {
+    value: ape,
+    writable: false,
+    enumerable: true,
+    configurable: false
+})
+
+// Default export: the proxy (so const api = require('api-ape') works)
 module.exports = api
 
-// Named exports
+// Also export named exports for ESM compatibility
 module.exports.ape = ape
 module.exports.api = api
+module.exports.broadcast = broadcast
+module.exports.clients = clients
+module.exports.default = api
+
+
+
+
+
 
 
 

package/server/lib/longPolling.js

@@ -201,9 +201,7 @@ function createLongPollingHandler(controllers, onConnect, fileTransfer) {
                     req,
                     broadcast: (t, d) => broadcast(t, d),
                     broadcastOthers: (t, d) => broadcast(t, d, clientId),
-                    // Use clients Map for count and list
-                    online: () => clients.size,
-                    getClients: () => Array.from(clients.keys())
+                    clients
                 }
 
                 // Execute controller

package/server/socket/receive.js

@@ -1,5 +1,5 @@
 const messageHash = require('../../utils/messageHash')
-const { broadcast, online, getClients } = require('../lib/broadcast')
+const { broadcast, clients } = require('../lib/broadcast')
 const jss = require('../../utils/jss')
 
 /**
@@ -135,7 +135,7 @@ function getSessionId(req) {
 }
 
 module.exports = function receiveHandler(ape) {
-    const { send, checkReply, events, controllers, sharedValues, hostId, embedValues, fileTransfer } = ape
+    const { send, checkReply, events, controllers, sharedValues, clientId, embedValues, fileTransfer } = ape
 
     // Extract sessionId from request cookies (set by outer framework session management)
     const sessionId = getSessionId(sharedValues.req)
@@ -147,10 +147,9 @@ module.exports = function receiveHandler(ape) {
         ...embedValues,
         // api-ape utilities available via `this`
         broadcast: (type, data) => broadcast(type, data),
-        broadcastOthers: (type, data) => broadcast(type, data, hostId), // exclude self
-        online,
-        getClients,
-        hostId,
+        broadcastOthers: (type, data) => broadcast(type, data, clientId), // exclude self
+        clients,
+        clientId,
         sessionId  // Session ID from cookie (set by outer framework)
     }
 
@@ -181,7 +180,7 @@ module.exports = function receiveHandler(ape) {
                     // Wait for all uploads
                     try {
                         await Promise.all(uploadTags.map(async ({ path, hash }) => {
-                            const uploadData = await fileTransfer.registerUpload(queryId, hash, hostId)
+                            const uploadData = await fileTransfer.registerUpload(queryId, hash, clientId)
                             setValueAtPath(processedData, path, uploadData)
                         }))
                     } catch (uploadErr) {
@@ -200,7 +199,7 @@ module.exports = function receiveHandler(ape) {
                 if (fileTags.length > 0) {
                     console.log(`📁 Registering ${fileTags.length} streaming file(s) for ${type}`)
                     fileTags.forEach(({ hash }) => {
-                        fileTransfer.registerStreamingFile(hash, hostId)
+                        fileTransfer.registerStreamingFile(hash, clientId)
                     })
                 }
             }
@@ -233,7 +232,7 @@ module.exports = function receiveHandler(ape) {
 
         } catch (err) {
             const errMessage = err.message || err
-            events.onError(hostId, queryId, errMessage)
+            events.onError(clientId, queryId, errMessage)
         } // END catch
 
     } // END onReceive