@tthr/vue 0.0.84 → 0.0.86

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

@@ -2,371 +2,36 @@
  * Server-side query handler
  * Executes local custom functions or proxies generic CRUD to Tether API
  */
-
-import { defineEventHandler, readBody, createError, getHeader, getCookie } from 'h3';
-import { useRuntimeConfig } from '#imports';
-
-// Dynamic function registry - populated on first request
-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
- */
-async function loadFunctionRegistry() {
-  if (functionRegistry !== null || registryError !== null) {
-    return;
-  }
-
-  try {
-    // Try to import the user's functions index
-    // This path is relative to the Nuxt app's server runtime
-    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 {
-      // No custom functions found - that's OK, we'll proxy everything
-      log.debug('No custom functions found, will proxy all requests');
-      functionRegistry = {};
-    }
-  } catch (error) {
-    // Failed to load - we'll proxy everything to Tether API
-    log.debug('Could not load custom functions:', error.message);
-    registryError = error;
-    functionRegistry = {};
-  }
-}
-
-/**
- * Look up a function by name (e.g., "channel.getMyChannels")
- */
-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) {
-  return new Proxy({}, {
-    get(_target, tableName) {
-      const makeRequest = async (operation, args) => {
-        const response = await fetch(`${url}/api/v1/projects/${projectId}/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(`${url}/api/v1/projects/${projectId}/mutation`, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${apiKey}`,
-          },
-          body: JSON.stringify({
-            function: `${tableName}.${operation}`,
-            args,
-          }),
+import { defineEventHandler, readBody, createError } from 'h3';
+import { getConfig, lookupFunction, createDatabaseProxy, buildAuthContext, proxyToTetherApi, log, } from './utils/handler';
+export default defineEventHandler(async (event) => {
+    const config = getConfig();
+    const body = await readBody(event);
+    if (!body?.function) {
+        throw createError({
+            statusCode: 400,
+            message: 'Missing "function" in request body',
         });
-
-        if (!response.ok) {
-          const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-          throw new Error(error.error || `Database operation failed: ${tableName}.${operation}`);
+    }
+    const customFn = await lookupFunction(body.function);
+    log.debug(`Query: ${body.function}, custom function found: ${!!customFn}`);
+    if (customFn) {
+        try {
+            const db = createDatabaseProxy(config.apiKey, config.url, config.projectId);
+            const { auth, ctx } = await buildAuthContext(event, config.url, config.projectId);
+            log.debug(`Executing custom function: ${body.function}`);
+            const result = await customFn.handler({ db, ctx, auth, args: body.args ?? {} });
+            log.debug(`Function ${body.function} completed`);
+            return { data: result };
         }
-
-        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;
-          // Handle orderBy as either a string or an object { column: 'asc'|'desc' }
-          if (options?.orderBy) {
-            if (typeof options.orderBy === 'string') {
-              args.orderBy = options.orderBy;
-            } else if (typeof options.orderBy === 'object') {
-              const [column, dir] = Object.entries(options.orderBy)[0] || [];
-              if (column) {
-                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 results?.[0] ?? null;
-        },
-        findUnique: async (options) => {
-          const args = { limit: 1 };
-          if (options?.where) args.where = options.where;
-          const results = await makeRequest('list', args);
-          return results?.[0] ?? 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 whereObj = options.where;
-          // Support both _id (standard) and id (legacy) in where clause
-          const id = whereObj?._id ?? whereObj?.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 whereObj = options.where;
-
-          // Try to find existing record using the where clause
-          // This allows upserting on any field (e.g. clip_id, email, etc.)
-          // Use list with limit: 1 since findFirst doesn't exist on the server
-          const results = await makeRequest('list', { where: whereObj, limit: 1 }).catch(() => []);
-          const existing = results?.[0] ?? null;
-
-          if (existing) {
-            // Use _id from the found record for the update
-            const id = existing._id ?? existing.id;
-            if (!id) {
-              throw new Error('Found record has no _id or id field for update');
-            }
-            await makeMutation('update', { id, data: options.update });
-            return { ...existing, ...options.update };
-          } else {
-            return makeMutation('create', { data: options.create });
-          }
-        },
-        delete: async (options) => {
-          const whereObj = options.where;
-          // Support both _id (standard) and id (legacy) in where clause
-          const id = whereObj?._id ?? whereObj?.id;
-          if (id) {
-            const result = await makeMutation('delete', { id });
-            return result?.rowsAffected ?? 0;
-          }
-          // Compound where clause — use deleteMany
-          const result = await makeMutation('deleteMany', { where: whereObj });
-          return result?.rowsAffected ?? 0;
-        },
-        deleteById: async (id) => {
-          const result = await makeMutation('delete', { id });
-          return (result?.rowsAffected ?? 0) > 0;
-        },
-      };
-    },
-  });
-}
-
-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;
-  const url = config.tether?.url || process.env.TETHER_URL || 'https://tether-api.strands.gg';
-  const projectId = config.tether?.projectId || process.env.TETHER_PROJECT_ID;
-
-  if (!apiKey) {
-    throw createError({
-      statusCode: 500,
-      message: 'Tether API key not configured. Set TETHER_API_KEY environment variable.',
-    });
-  }
-
-  if (!projectId) {
-    throw createError({
-      statusCode: 500,
-      message: 'Tether project ID not configured.',
-    });
-  }
-
-  const body = await readBody(event);
-
-  if (!body?.function) {
-    throw createError({
-      statusCode: 400,
-      message: 'Missing "function" in request body',
-    });
-  }
-
-  // Load function registry (once)
-  await loadFunctionRegistry();
-
-  // Try to find a custom function
-  const customFn = lookupFunction(body.function);
-  log.debug(`Query: ${body.function}, custom function found: ${!!customFn}`);
-
-  if (customFn) {
-    // Execute locally with database proxy
-    try {
-      const db = createDatabaseProxy(apiKey, url, projectId);
-
-      // Create auth context - try to get user identity from request
-      // The app should pass auth info via a custom header or we check for common auth patterns
-      let userIdentity = null;
-
-      // Check for Strands auth token in cookie or header
-      const authHeader = getHeader(event, 'authorization');
-      const strandsToken = getHeader(event, 'x-strands-token');
-      const cookieToken = getCookie(event, 'strands_oauth_token');
-
-      // If using Strands auth, validate the token via Tether server
-      if (strandsToken || cookieToken || authHeader?.startsWith('Bearer ')) {
-        const token = strandsToken || cookieToken || authHeader?.replace('Bearer ', '');
-        if (token) {
-          try {
-            // Validate token via Tether server (which checks if Strands Auth is enabled)
-            const authResponse = await fetch(`${url}/api/v1/projects/${projectId}/auth/validate`, {
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json' },
-              body: JSON.stringify({ accessToken: token }),
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            log.error(`Function ${body.function} failed:`, err.message);
+            throw createError({
+                statusCode: 500,
+                message: err.message || 'Function execution failed',
             });
-            if (authResponse.ok) {
-              const authData = await authResponse.json();
-              if (authData.valid) {
-                userIdentity = {
-                  subject: authData.userId,
-                  email: authData.email,
-                  name: authData.name,
-                };
-              }
-            }
-          } catch (authError) {
-            log.warn('Auth validation failed:', authError.message);
-            // Auth validation failed - continue without identity
-          }
         }
-      }
-
-      const auth = {
-        getUserIdentity: async () => userIdentity,
-      };
-
-      const ctx = {
-        auth: {
-          userId: userIdentity?.subject ?? null,
-          claims: userIdentity ?? {},
-        },
-        userId: userIdentity?.subject ?? null,
-      };
-
-      log.debug(`Executing custom function: ${body.function}`);
-      const result = await customFn.handler({
-        db,
-        ctx,
-        auth,
-        args: body.args ?? {},
-      });
-      log.debug(`Function ${body.function} completed`);
-
-      return { data: result };
-    } catch (error) {
-      log.error(`Function ${body.function} failed:`, error.message || error);
-      throw createError({
-        statusCode: 500,
-        message: error.message || 'Function execution failed',
-      });
     }
-  }
-
-  // No custom function found - proxy to Tether API (generic CRUD)
-  const response = await fetch(`${url}/api/v1/projects/${projectId}/query`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({
-      function: body.function,
-      args: body.args,
-    }),
-  });
-
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-    throw createError({
-      statusCode: response.status,
-      message: error.error || 'Query failed',
-    });
-  }
-
-  return response.json();
+    return proxyToTetherApi(config, 'query', body.function, body.args);
 });

package/nuxt/runtime/server/query.post.ts

@@ -0,0 +1,51 @@
+/**
+ * Server-side query handler
+ * Executes local custom functions or proxies generic CRUD to Tether API
+ */
+
+import { defineEventHandler, readBody, createError } from 'h3';
+import {
+  getConfig,
+  lookupFunction,
+  createDatabaseProxy,
+  buildAuthContext,
+  proxyToTetherApi,
+  log,
+} from './utils/handler';
+
+export default defineEventHandler(async (event) => {
+  const config = getConfig();
+  const body = await readBody(event);
+
+  if (!body?.function) {
+    throw createError({
+      statusCode: 400,
+      message: 'Missing "function" in request body',
+    });
+  }
+
+  const customFn = await lookupFunction(body.function);
+  log.debug(`Query: ${body.function}, custom function found: ${!!customFn}`);
+
+  if (customFn) {
+    try {
+      const db = createDatabaseProxy(config.apiKey, config.url, config.projectId);
+      const { auth, ctx } = await buildAuthContext(event, config.url, config.projectId);
+
+      log.debug(`Executing custom function: ${body.function}`);
+      const result = await customFn.handler({ db, ctx, auth, args: body.args ?? {} });
+      log.debug(`Function ${body.function} completed`);
+
+      return { data: result };
+    } catch (error: unknown) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      log.error(`Function ${body.function} failed:`, err.message);
+      throw createError({
+        statusCode: 500,
+        message: err.message || 'Function execution failed',
+      });
+    }
+  }
+
+  return proxyToTetherApi(config, 'query', body.function, body.args);
+});