@tthr/vue 0.0.84 → 0.0.85

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

@@ -1,372 +0,0 @@
-/**
- * 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,
-          }),
-        });
-
-        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;
-          // 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 }),
-            });
-            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();
-});