npm - @tthr/vue - Versions diffs - 0.0.40 → 0.0.44 - Mend

@tthr/vue 0.0.40 → 0.0.44

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/nuxt/module.js +3 -0
package/nuxt/module.ts +8 -3
package/nuxt/runtime/server/mutation.post.js +20 -9
package/nuxt/runtime/server/plugins/cron.d.ts.map +1 -1
package/nuxt/runtime/server/plugins/cron.js +46 -26
package/nuxt/runtime/server/query.post.js +21 -10
package/package.json +1 -1

package/nuxt/module.js CHANGED Viewed

@@ -38,6 +38,7 @@ export default defineNuxtModule({
         const apiKey = process.env.TETHER_API_KEY || '';
         const url = options.url || process.env.TETHER_URL || 'https://tether-api.strands.gg';
         const projectId = options.projectId || process.env.TETHER_PROJECT_ID || '';
+        const verbose = options.verbose ?? (process.env.TETHER_VERBOSE === 'true');
         // Calculate WebSocket URL from HTTP URL
         const wsUrl = url.replace(/^https:/, 'wss:').replace(/^http:/, 'ws:');
         // Server-side config (includes API key - never exposed to client)
@@ -45,10 +46,12 @@ export default defineNuxtModule({
         // - NUXT_TETHER_API_KEY
         // - NUXT_TETHER_URL
         // - NUXT_TETHER_PROJECT_ID
+        // - NUXT_TETHER_VERBOSE
         nuxt.options.runtimeConfig.tether = {
             apiKey,
             url,
             projectId,
+            verbose,
         };
         // Public config (safe for client - no secrets)
         // Can be overridden at runtime via:

package/nuxt/module.ts CHANGED Viewed

@@ -26,6 +26,8 @@ export interface TetherModuleOptions {
   projectId?: string;
   /** API endpoint (defaults to Tether Cloud) */
   url?: string;
+  /** Enable verbose logging for debugging WebSocket connections */
+  verbose?: boolean;
 }
 export default defineNuxtModule<TetherModuleOptions>({
@@ -48,6 +50,7 @@ export default defineNuxtModule<TetherModuleOptions>({
     const apiKey = process.env.TETHER_API_KEY || '';
     const url = options.url || process.env.TETHER_URL || 'https://tether-api.strands.gg';
     const projectId = options.projectId || process.env.TETHER_PROJECT_ID || '';
+    const verbose = options.verbose ?? (process.env.TETHER_VERBOSE === 'true');
     // Calculate WebSocket URL from HTTP URL
     const wsUrl = url.replace(/^https:/, 'wss:').replace(/^http:/, 'ws:');
@@ -57,17 +60,19 @@ export default defineNuxtModule<TetherModuleOptions>({
     // - NUXT_TETHER_API_KEY
     // - NUXT_TETHER_URL
     // - NUXT_TETHER_PROJECT_ID
-    nuxt.options.runtimeConfig.tether = {
+    // - NUXT_TETHER_VERBOSE
+    (nuxt.options.runtimeConfig as any).tether = {
       apiKey,
       url,
       projectId,
+      verbose,
     };
     // Public config (safe for client - no secrets)
     // Can be overridden at runtime via:
     // - NUXT_PUBLIC_TETHER_PROJECT_ID
     // - NUXT_PUBLIC_TETHER_WS_URL
-    nuxt.options.runtimeConfig.public.tether = {
+    (nuxt.options.runtimeConfig.public as any).tether = {
       projectId,
       wsUrl,
     };
@@ -140,7 +145,7 @@ export default defineNuxtModule<TetherModuleOptions>({
     // Add Nitro plugin for cron WebSocket connection
     // This auto-connects to Tether when the server starts
-    nuxt.hook('nitro:config', (nitroConfig) => {
+    nuxt.hook('nitro:config' as any, (nitroConfig: any) => {
       nitroConfig.plugins = nitroConfig.plugins || [];
       // Use direct path - Nitro will handle the #imports resolution at build time
       nitroConfig.plugins.push(resolver.resolve('./runtime/server/plugins/cron.js'));

package/nuxt/runtime/server/mutation.post.js CHANGED Viewed

@@ -10,6 +10,16 @@ import { useRuntimeConfig } from '#imports';
 let functionRegistry = null;
 let registryError = null;
+// Verbose logging support
+let verboseLogging = false;
+const PREFIX = '[Tether]';
+const log = {
+  debug: (...args) => { if (verboseLogging) console.log(PREFIX, ...args); },
+  info: (...args) => console.log(PREFIX, ...args),
+  warn: (...args) => console.warn(PREFIX, ...args),
+  error: (...args) => console.error(PREFIX, ...args),
+};
 /**
  * Try to load the user's custom functions from ~/tether/functions
  */
@@ -21,23 +31,23 @@ async function loadFunctionRegistry() {
   try {
     // Try to import the user's functions index
     // This path is relative to the Nuxt app's server runtime
-    console.log('[Tether] Loading custom functions from ~~/tether/functions/index.ts');
+    log.debug('Loading custom functions from ~~/tether/functions/index.ts');
     const functions = await import('~~/tether/functions/index.ts').catch((err) => {
-      console.warn('[Tether] Failed to import functions:', err.message);
+      log.debug('Failed to import functions:', err.message);
       return null;
     });
     if (functions) {
-      console.log('[Tether] Loaded function modules:', Object.keys(functions));
+      log.debug('Loaded function modules:', Object.keys(functions));
       functionRegistry = functions;
     } else {
       // No custom functions found - that's OK, we'll proxy everything
-      console.log('[Tether] No custom functions found, will proxy all requests');
+      log.debug('No custom functions found, will proxy all requests');
       functionRegistry = {};
     }
   } catch (error) {
     // Failed to load - we'll proxy everything to Tether API
-    console.warn('[Tether] Could not load custom functions:', error.message);
+    log.debug('Could not load custom functions:', error.message);
     registryError = error;
     functionRegistry = {};
   }
@@ -217,6 +227,7 @@ function createDatabaseProxy(apiKey, url, projectId) {
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
+  verboseLogging = config.tether?.verbose || process.env.TETHER_VERBOSE === 'true';
   // Get API key from runtime config (populated from TETHER_API_KEY env var)
   const apiKey = config.tether?.apiKey || process.env.TETHER_API_KEY;
@@ -251,12 +262,12 @@ export default defineEventHandler(async (event) => {
   // Try to find a custom function
   const customFn = lookupFunction(body.function);
-  console.log(`[Tether] Mutation: ${body.function}, custom function found: ${!!customFn}`);
+  log.debug(`Mutation: ${body.function}, custom function found: ${!!customFn}`);
   if (customFn) {
     // Execute locally with database proxy
     try {
-      console.log(`[Tether] Executing custom mutation: ${body.function}`);
+      log.debug(`Executing custom mutation: ${body.function}`);
       const db = createDatabaseProxy(apiKey, url, projectId);
       // Create auth context - try to get user identity from request
@@ -288,7 +299,7 @@ export default defineEventHandler(async (event) => {
               }
             }
           } catch (authError) {
-            console.warn('[Tether] Auth validation failed:', authError.message);
+            log.warn('Auth validation failed:', authError.message);
             // Auth validation failed - continue without identity
           }
         }
@@ -315,7 +326,7 @@ export default defineEventHandler(async (event) => {
       return { data: result };
     } catch (error) {
-      console.error(`[Tether] Mutation ${body.function} failed:`, error);
+      log.error(`Mutation ${body.function} failed:`, error);
       // Return JSON error response instead of throwing (avoids proxy HTML error pages)
       setResponseStatus(event, 400);
       return {

package/nuxt/runtime/server/plugins/cron.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["cron.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;~~AAsBH~~;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAC3C,IAAI,CAGN;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAEhE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,EAAE,CAE1C;;~~AAqPD~~,~~wBA+BG~~"}
1	+ {"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["cron.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAoCH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAC3C,IAAI,CAGN;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAEhE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,EAAE,CAE1C;;AAyPD,wBAiCG"}

package/nuxt/runtime/server/plugins/cron.js CHANGED Viewed

@@ -20,10 +20,24 @@ let heartbeatTimer = null;
 let heartbeatTimeoutTimer = null;
 let awaitingPong = false;
 let shouldReconnect = true;
+let verboseLogging = false;
 const MAX_RECONNECT_ATTEMPTS = 10;
-const HEARTBEAT_INTERVAL = 30000;
+const HEARTBEAT_INTERVAL = 20000; // 20 seconds - keeps connection alive through proxies with 30s idle timeout
 const HEARTBEAT_TIMEOUT = 10000;
 const RECONNECT_DELAY = 1000;
+const PREFIX = '[Tether Cron]';
+/** Simple logger that respects verbose flag */
+const log = {
+    /** Debug messages - only shown when verbose is enabled */
+    debug: (...args) => { if (verboseLogging)
+        console.log(PREFIX, ...args); },
+    /** Info messages - always shown */
+    info: (...args) => console.log(PREFIX, ...args),
+    /** Warning messages - always shown */
+    warn: (...args) => console.warn(PREFIX, ...args),
+    /** Error messages - always shown */
+    error: (...args) => console.error(PREFIX, ...args),
+};
 /**
  * Register a cron handler for a specific function
  *
@@ -40,7 +54,7 @@ const RECONNECT_DELAY = 1000;
  */
 export function registerCronHandler(functionName, handler) {
     cronHandlers.set(functionName, handler);
-    console.log(`[Tether Cron] Registered handler for: ${functionName}`);
+    log.debug('Registered handler for:', functionName);
 }
 /**
  * Unregister a cron handler
@@ -97,22 +111,22 @@ async function reportExecution(config, trigger, result, durationMs) {
             }),
         });
         if (!response.ok) {
-            console.error(`[Tether Cron] Failed to report execution: ${response.status} ${response.statusText}`);
+            log.error(`Failed to report execution: ${response.status} ${response.statusText}`);
         }
         else {
-            console.log(`[Tether Cron] Reported execution ${trigger.executionId}: ${result.success ? 'success' : 'failed'}`);
+            log.debug(`Reported execution ${trigger.executionId}: ${result.success ? 'success' : 'failed'}`);
         }
     }
     catch (error) {
-        console.error('[Tether Cron] Failed to report execution:', error);
+        log.error('Failed to report execution:', error);
     }
 }
 async function handleCronTrigger(config, trigger) {
-    console.log(`[Tether Cron] Received trigger for ${trigger.functionName} (execution: ${trigger.executionId})`);
+    log.info(`Received trigger for ${trigger.functionName} (execution: ${trigger.executionId})`);
     const startTime = Date.now();
     const handler = cronHandlers.get(trigger.functionName);
     if (!handler) {
-        console.warn(`[Tether Cron] No handler registered for: ${trigger.functionName}`);
+        log.warn(`No handler registered for: ${trigger.functionName}`);
         const durationMs = Date.now() - startTime;
         await reportExecution(config, trigger, {
             success: false,
@@ -131,7 +145,7 @@ async function handleCronTrigger(config, trigger) {
     catch (error) {
         const durationMs = Date.now() - startTime;
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`[Tether Cron] Handler error for ${trigger.functionName}:`, errorMessage);
+        log.error(`Handler error for ${trigger.functionName}:`, errorMessage);
         await reportExecution(config, trigger, {
             success: false,
             error: errorMessage,
@@ -143,14 +157,18 @@ function startHeartbeat() {
     heartbeatTimer = setInterval(() => {
         if (ws?.readyState === WebSocket.OPEN) {
             awaitingPong = true;
+            log.debug('Sending heartbeat ping');
             ws.send(JSON.stringify({ type: 'ping' }));
             heartbeatTimeoutTimer = setTimeout(() => {
                 if (awaitingPong) {
-                    console.warn('[Tether Cron] Heartbeat timeout - forcing reconnect');
+                    log.warn('Heartbeat timeout - forcing reconnect');
                     ws?.close();
                 }
             }, HEARTBEAT_TIMEOUT);
         }
+        else {
+            log.warn(`Cannot send ping - WebSocket state: ${ws?.readyState}`);
+        }
     }, HEARTBEAT_INTERVAL);
 }
 function stopHeartbeat() {
@@ -176,7 +194,7 @@ function connect(config) {
         ws = new WebSocketImpl(url);
         ws.onopen = () => {
             reconnectAttempts = 0;
-            console.log('[Tether Cron] WebSocket connected');
+            log.debug('WebSocket connected');
         };
         ws.onmessage = async (event) => {
             const data = typeof event.data === 'string' ? event.data : event.data.toString();
@@ -186,12 +204,13 @@ function connect(config) {
                     case 'connected':
                         connectionId = message.connection_id ?? null;
                         startHeartbeat();
-                        console.log(`[Tether Cron] Connected with ID: ${connectionId}`);
+                        log.info(`Connected with ID: ${connectionId}`);
                         break;
                     case 'cron_trigger':
                         await handleCronTrigger(config, message);
                         break;
                     case 'pong':
+                        log.debug('Received pong');
                         awaitingPong = false;
                         if (heartbeatTimeoutTimer) {
                             clearTimeout(heartbeatTimeoutTimer);
@@ -199,27 +218,27 @@ function connect(config) {
                         }
                         break;
                     case 'error':
-                        console.error('[Tether Cron] Server error:', message.error);
+                        log.error('Server error:', message.error);
                         break;
                 }
             }
             catch (e) {
-                console.error('[Tether Cron] Failed to parse message:', e);
+                log.error('Failed to parse message:', e);
             }
         };
         ws.onerror = (error) => {
             const err = error instanceof Error ? error : new Error('WebSocket error');
-            console.error('[Tether Cron] WebSocket error:', err.message);
+            log.error('WebSocket error:', err.message);
         };
-        ws.onclose = () => {
+        ws.onclose = (event) => {
             connectionId = null;
             stopHeartbeat();
-            console.log('[Tether Cron] WebSocket disconnected');
+            log.debug(`WebSocket disconnected (code: ${event.code}, reason: ${event.reason || 'none'})`);
             handleReconnect(config);
         };
     }
     catch (error) {
-        console.error('[Tether Cron] Failed to connect:', error);
+        log.error('Failed to connect:', error);
         handleReconnect(config);
     }
 }
@@ -228,12 +247,12 @@ function handleReconnect(config) {
         return;
     }
     if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-        console.error('[Tether Cron] Max reconnection attempts reached');
+        log.error('Max reconnection attempts reached');
         return;
     }
     reconnectAttempts++;
     const delay = Math.min(RECONNECT_DELAY * Math.pow(2, reconnectAttempts - 1), 30000);
-    console.log(`[Tether Cron] Reconnecting in ${delay}ms (attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
+    log.debug(`Reconnecting in ${delay}ms (attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
     setTimeout(() => {
         connect(config);
     }, delay);
@@ -241,15 +260,17 @@ function handleReconnect(config) {
 export default defineNitroPlugin((nitro) => {
     // Get config from runtime config
     const config = useRuntimeConfig();
-    const apiKey = config.tether?.apiKey || process.env.TETHER_API_KEY;
-    const url = config.tether?.url || process.env.TETHER_URL || 'https://tether-api.strands.gg';
-    const projectId = config.tether?.projectId || process.env.TETHER_PROJECT_ID;
+    const tetherConfig = config.tether;
+    const apiKey = tetherConfig?.apiKey || process.env.TETHER_API_KEY;
+    const url = tetherConfig?.url || process.env.TETHER_URL || 'https://tether-api.strands.gg';
+    const projectId = tetherConfig?.projectId || process.env.TETHER_PROJECT_ID;
+    verboseLogging = tetherConfig?.verbose || process.env.TETHER_VERBOSE === 'true';
     // Only connect if we have all required config
     if (!apiKey || !projectId) {
-        console.log('[Tether Cron] Missing config (apiKey or projectId) - cron connection disabled');
+        log.debug('Missing config (apiKey or projectId) - cron connection disabled');
         return;
     }
-    console.log('[Tether Cron] Initialising cron connection...');
+    log.info('Initialising cron connection...');
     // Connect on next tick to allow handlers to be registered first
     process.nextTick(() => {
         connect({ url, projectId, apiKey });
@@ -262,7 +283,6 @@ export default defineNitroPlugin((nitro) => {
             ws.close();
             ws = null;
         }
-        console.log('[Tether Cron] Connection closed');
+        log.debug('Connection closed');
     });
 });
-//# sourceMappingURL=cron.js.map

package/nuxt/runtime/server/query.post.js CHANGED Viewed

@@ -10,6 +10,16 @@ import { useRuntimeConfig } from '#imports';
 let functionRegistry = null;
 let registryError = null;
+// Verbose logging support
+let verboseLogging = false;
+const PREFIX = '[Tether]';
+const log = {
+  debug: (...args) => { if (verboseLogging) console.log(PREFIX, ...args); },
+  info: (...args) => console.log(PREFIX, ...args),
+  warn: (...args) => console.warn(PREFIX, ...args),
+  error: (...args) => console.error(PREFIX, ...args),
+};
 /**
  * Try to load the user's custom functions from ~/tether/functions
  */
@@ -21,23 +31,23 @@ async function loadFunctionRegistry() {
   try {
     // Try to import the user's functions index
     // This path is relative to the Nuxt app's server runtime
-    console.log('[Tether] Loading custom functions from ~~/tether/functions/index.ts');
+    log.debug('Loading custom functions from ~~/tether/functions/index.ts');
     const functions = await import('~~/tether/functions/index.ts').catch((err) => {
-      console.warn('[Tether] Failed to import functions:', err.message);
+      log.debug('Failed to import functions:', err.message);
       return null;
     });
     if (functions) {
-      console.log('[Tether] Loaded function modules:', Object.keys(functions));
+      log.debug('Loaded function modules:', Object.keys(functions));
       functionRegistry = functions;
     } else {
       // No custom functions found - that's OK, we'll proxy everything
-      console.log('[Tether] No custom functions found, will proxy all requests');
+      log.debug('No custom functions found, will proxy all requests');
       functionRegistry = {};
     }
   } catch (error) {
     // Failed to load - we'll proxy everything to Tether API
-    console.warn('[Tether] Could not load custom functions:', error.message);
+    log.debug('Could not load custom functions:', error.message);
     registryError = error;
     functionRegistry = {};
   }
@@ -217,6 +227,7 @@ function createDatabaseProxy(apiKey, url, projectId) {
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
+  verboseLogging = config.tether?.verbose || process.env.TETHER_VERBOSE === 'true';
   // Get API key from runtime config (populated from TETHER_API_KEY env var)
   const apiKey = config.tether?.apiKey || process.env.TETHER_API_KEY;
@@ -251,7 +262,7 @@ export default defineEventHandler(async (event) => {
   // Try to find a custom function
   const customFn = lookupFunction(body.function);
-  console.log(`[Tether] Query: ${body.function}, custom function found: ${!!customFn}`);
+  log.debug(`Query: ${body.function}, custom function found: ${!!customFn}`);
   if (customFn) {
     // Execute locally with database proxy
@@ -288,7 +299,7 @@ export default defineEventHandler(async (event) => {
               }
             }
           } catch (authError) {
-            console.warn('[Tether] Auth validation failed:', authError.message);
+            log.warn('Auth validation failed:', authError.message);
             // Auth validation failed - continue without identity
           }
         }
@@ -306,18 +317,18 @@ export default defineEventHandler(async (event) => {
         userId: userIdentity?.subject ?? null,
       };
-      console.log(`[Tether] Executing custom function: ${body.function}`);
+      log.debug(`Executing custom function: ${body.function}`);
       const result = await customFn.handler({
         db,
         ctx,
         auth,
         args: body.args ?? {},
       });
-      console.log(`[Tether] Function ${body.function} completed`);
+      log.debug(`Function ${body.function} completed`);
       return { data: result };
     } catch (error) {
-      console.error(`[Tether] Function ${body.function} failed:`, error.message || error);
+      log.error(`Function ${body.function} failed:`, error.message || error);
       throw createError({
         statusCode: 500,
         message: error.message || 'Function execution failed',

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@tthr/vue",
-  "version": "0.0.40",
+  "version": "0.0.44",
   "description": "Tether Vue/Nuxt SDK",
   "type": "module",
   "main": "./dist/index.js",