@tthr/vue 0.0.65 → 0.0.67

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

@@ -13,6 +13,9 @@ import { defineNitroPlugin } from 'nitropack/runtime';
 export { defineNitroPlugin };
 // Store for registered cron handlers
 const cronHandlers = new Map();
+// Dynamic function registry - populated on first cron trigger
+let functionRegistry = null;
+let registryError = null;
 // WebSocket connection state
 let ws = null;
 let connectionId = null;
@@ -69,6 +72,203 @@ export function unregisterCronHandler(functionName) {
 export function getCronHandlers() {
     return Array.from(cronHandlers.keys());
 }
+/**
+ * Load user's custom functions from ~/tether/functions
+ */
+async function loadFunctionRegistry() {
+    if (functionRegistry !== null || registryError !== null) {
+        return;
+    }
+    try {
+        log.debug('Loading custom functions from ~~/tether/functions/index.ts');
+        const functions = await import('~~/tether/functions/index.ts').catch((err) => {
+            log.debug('Failed to import functions:', err.message);
+            return null;
+        });
+        if (functions) {
+            log.debug('Loaded function modules:', Object.keys(functions));
+            functionRegistry = functions;
+        }
+        else {
+            log.debug('No custom functions found');
+            functionRegistry = {};
+        }
+    }
+    catch (error) {
+        log.debug('Could not load custom functions:', error instanceof Error ? error.message : String(error));
+        registryError = error instanceof Error ? error : new Error(String(error));
+        functionRegistry = {};
+    }
+}
+/**
+ * Look up a function by name (e.g., "sync.syncClips")
+ */
+function lookupFunction(name) {
+    if (!functionRegistry || !name)
+        return null;
+    const parts = name.split('.');
+    if (parts.length !== 2)
+        return null;
+    const [moduleName, fnName] = parts;
+    const module = functionRegistry[moduleName];
+    if (!module)
+        return null;
+    const fn = module[fnName];
+    // Check if it's a valid Tether function (has a handler)
+    if (fn && typeof fn === 'object' && typeof fn.handler === 'function') {
+        return fn;
+    }
+    return null;
+}
+/**
+ * Create a database proxy that routes calls to Tether's CRUD endpoints
+ */
+function createDatabaseProxy(apiKey, url, projectId, environment) {
+    const base = url.replace(/\/$/, '');
+    let apiPath;
+    if (environment && environment !== 'production') {
+        apiPath = `${base}/api/v1/projects/${projectId}/env/${environment}`;
+    }
+    else {
+        apiPath = `${base}/api/v1/projects/${projectId}`;
+    }
+    return new Proxy({}, {
+        get(_target, tableName) {
+            const makeRequest = async (operation, args) => {
+                const response = await fetch(`${apiPath}/query`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        function: `${tableName}.${operation}`,
+                        args,
+                    }),
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+                    throw new Error(error.error || `Database operation failed: ${tableName}.${operation}`);
+                }
+                const result = await response.json();
+                return result.data;
+            };
+            const makeMutation = async (operation, args) => {
+                const response = await fetch(`${apiPath}/mutation`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        function: `${tableName}.${operation}`,
+                        args,
+                    }),
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+                    throw new Error(error.error || `Database operation failed: ${tableName}.${operation}`);
+                }
+                const result = await response.json();
+                return result.data;
+            };
+            return {
+                findMany: async (options) => {
+                    const args = {};
+                    if (options?.where)
+                        args.where = options.where;
+                    if (options?.limit)
+                        args.limit = options.limit;
+                    if (options?.offset)
+                        args.offset = options.offset;
+                    if (options?.orderBy) {
+                        if (typeof options.orderBy === 'string') {
+                            args.orderBy = options.orderBy;
+                        }
+                        else if (typeof options.orderBy === 'object') {
+                            const entries = Object.entries(options.orderBy);
+                            if (entries.length > 0) {
+                                const [column, dir] = entries[0];
+                                args.orderBy = column;
+                                args.orderDir = dir?.toUpperCase?.() || 'ASC';
+                            }
+                        }
+                    }
+                    if (options?.orderDir)
+                        args.orderDir = options.orderDir;
+                    return makeRequest('list', args);
+                },
+                findFirst: async (options) => {
+                    const args = { limit: 1 };
+                    if (options?.where)
+                        args.where = options.where;
+                    const results = await makeRequest('list', args);
+                    return Array.isArray(results) ? results[0] ?? null : null;
+                },
+                findUnique: async (options) => {
+                    const args = { limit: 1 };
+                    if (options?.where)
+                        args.where = options.where;
+                    const results = await makeRequest('list', args);
+                    return Array.isArray(results) ? results[0] ?? null : null;
+                },
+                findById: async (id) => {
+                    return makeRequest('get', { id });
+                },
+                count: async (options) => {
+                    const args = {};
+                    if (options?.where)
+                        args.where = options.where;
+                    const result = await makeRequest('count', args);
+                    return result?.count ?? 0;
+                },
+                insert: async (data) => {
+                    return makeMutation('create', { data });
+                },
+                insertMany: async (items) => {
+                    const results = [];
+                    for (const data of items) {
+                        const result = await makeMutation('create', { data });
+                        results.push(result);
+                    }
+                    return results;
+                },
+                create: async (options) => {
+                    return makeMutation('create', { data: options.data });
+                },
+                update: async (options) => {
+                    const id = options.where?.id;
+                    if (!id)
+                        throw new Error('Update requires an id in the where clause');
+                    const result = await makeMutation('update', { id, data: options.data });
+                    return result?.rowsAffected ?? 0;
+                },
+                upsert: async (options) => {
+                    const id = options.where?.id;
+                    const existing = id ? await makeRequest('get', { id }).catch(() => null) : null;
+                    if (existing) {
+                        await makeMutation('update', { id, data: options.update });
+                        return { ...existing, ...options.update };
+                    }
+                    else {
+                        return makeMutation('create', { data: options.create });
+                    }
+                },
+                delete: async (options) => {
+                    const id = options.where?.id;
+                    if (!id)
+                        throw new Error('Delete requires an id in the where clause');
+                    const result = await makeMutation('delete', { id });
+                    return result?.rowsAffected ?? 0;
+                },
+                deleteById: async (id) => {
+                    const result = await makeMutation('delete', { id });
+                    return (result?.rowsAffected ?? 0) > 0;
+                },
+            };
+        },
+    });
+}
 function getWsUrl(config) {
     const base = config.url
         .replace('https://', 'wss://')
@@ -194,19 +394,54 @@ async function executeViaApi(config, functionName, functionType, args) {
 async function handleCronTrigger(config, trigger) {
     log.info(`Received trigger for ${trigger.functionName} (execution: ${trigger.executionId})`);
     const startTime = Date.now();
-    const handler = cronHandlers.get(trigger.functionName);
     try {
         let result;
+        // 1. Check for manually registered handler
+        const handler = cronHandlers.get(trigger.functionName);
         if (handler) {
-            // Use locally registered handler
-            log.debug(`Using local handler for: ${trigger.functionName}`);
+            log.debug(`Using registered handler for: ${trigger.functionName}`);
             result = await handler(trigger.args);
         }
         else {
-            // Execute via Tether API (default behaviour)
-            // This allows cron to work without explicit handler registration
-            log.debug(`Executing via API: ${trigger.functionName} (${trigger.functionType})`);
-            result = await executeViaApi(config, trigger.functionName, trigger.functionType, trigger.args);
+            // 2. Try to load and execute from user's tether/functions
+            await loadFunctionRegistry();
+            const localFn = lookupFunction(trigger.functionName);
+            if (localFn) {
+                log.debug(`Executing local function: ${trigger.functionName}`);
+                // Create execution context with database proxy
+                const db = createDatabaseProxy(config.apiKey, config.url, config.projectId, config.environment);
+                // Create a simple logger for the function
+                const fnLog = {
+                    log: (...args) => log.info(`[${trigger.functionName}]`, ...args),
+                    debug: (...args) => log.debug(`[${trigger.functionName}]`, ...args),
+                    info: (...args) => log.info(`[${trigger.functionName}]`, ...args),
+                    warn: (...args) => log.warn(`[${trigger.functionName}]`, ...args),
+                    error: (...args) => log.error(`[${trigger.functionName}]`, ...args),
+                };
+                // Create tether context with env vars from process.env
+                // Note: For cron execution, env vars should be set in the Nuxt app's environment
+                const tether = {
+                    env: new Proxy({}, {
+                        get(_target, key) {
+                            return process.env[key];
+                        },
+                    }),
+                };
+                // Execute the function with context
+                result = await localFn.handler({
+                    db,
+                    args: trigger.args ?? {},
+                    log: fnLog,
+                    tether,
+                    ctx: { auth: { userId: null, claims: {} }, userId: null },
+                    auth: { getUserIdentity: async () => null },
+                });
+            }
+            else {
+                // 3. Fall back to API for generic CRUD operations (table.operation)
+                log.debug(`Executing via API: ${trigger.functionName} (${trigger.functionType})`);
+                result = await executeViaApi(config, trigger.functionName, trigger.functionType, trigger.args);
+            }
         }
         const durationMs = Date.now() - startTime;
         await reportExecution(config, trigger, {
@@ -336,14 +571,15 @@ export default defineNitroPlugin((nitro) => {
     const apiKey = process.env.NUXT_TETHER_API_KEY || process.env.TETHER_API_KEY;
     const url = process.env.NUXT_TETHER_URL || process.env.TETHER_URL || 'https://tether-api.strands.gg';
     const projectId = process.env.NUXT_TETHER_PROJECT_ID || process.env.TETHER_PROJECT_ID;
+    const environment = process.env.NUXT_TETHER_ENVIRONMENT || process.env.TETHER_ENVIRONMENT;
     verboseLogging = process.env.NUXT_TETHER_VERBOSE === 'true' || process.env.TETHER_VERBOSE === 'true';
     // Only connect if we have all required config
     if (!apiKey || !projectId) {
         log.debug('Missing config (apiKey or projectId) - cron connection disabled');
         return;
     }
-    log.info('Initialising cron connection...');
-    const config = { url, projectId, apiKey };
+    log.info(`Initialising cron connection...${environment ? ` (env: ${environment})` : ''}`);
+    const config = { url, projectId, apiKey, environment };
     // Connect on next tick to allow the server to fully initialise
     process.nextTick(() => {
         connect(config);
@@ -359,4 +595,4 @@ export default defineNitroPlugin((nitro) => {
         log.debug('Connection closed');
     });
 });
-//# sourceMappingURL=cron.js.map
+//# sourceMappingURL=cron.js.map

package/package.json

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