@tthr/vue 0.0.20 → 0.0.22

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

@@ -1,11 +1,203 @@
 /**
  * Server-side mutation handler
- * Proxies mutations to Tether API with the secret API key
+ * Executes local custom functions or proxies generic CRUD to Tether API
  */
 
-import { defineEventHandler, readBody, createError } from 'h3';
+import { defineEventHandler, readBody, createError, getHeader } from 'h3';
 import { useRuntimeConfig } from '#imports';
 
+// Dynamic function registry - populated on first request
+let functionRegistry = null;
+let registryError = null;
+
+/**
+ * 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
+    const functions = await import('~~/tether/functions/index.ts').catch(() => null);
+
+    if (functions) {
+      functionRegistry = functions;
+    } else {
+      // No custom functions found - that's OK, we'll proxy everything
+      functionRegistry = {};
+    }
+  } catch (error) {
+    // Failed to load - we'll proxy everything to Tether API
+    console.warn('[Tether] Could not load custom functions:', error.message);
+    registryError = error;
+    functionRegistry = {};
+  }
+}
+
+/**
+ * Look up a function by name (e.g., "channel.createChannel")
+ */
+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;
+          if (options?.orderBy) args.orderBy = options.orderBy;
+          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;
+          const 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;
+          const id = whereObj?.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 whereObj = options.where;
+          const id = whereObj?.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;
+        },
+      };
+    },
+  });
+}
+
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
 
@@ -37,6 +229,76 @@ export default defineEventHandler(async (event) => {
     });
   }
 
+  // Load function registry (once)
+  await loadFunctionRegistry();
+
+  // Try to find a custom function
+  const customFn = lookupFunction(body.function);
+
+  if (customFn) {
+    // Execute locally with database proxy
+    try {
+      const db = createDatabaseProxy(apiKey, url, projectId);
+
+      // Create auth context - try to get user identity from request
+      let userIdentity = null;
+
+      // Check for Strands auth token in cookie or header
+      const authHeader = getHeader(event, 'authorization');
+      const strandsToken = getHeader(event, 'x-strands-token');
+
+      // If using Strands auth, try to validate the token
+      if (strandsToken || authHeader?.startsWith('Bearer ')) {
+        const token = strandsToken || authHeader?.replace('Bearer ', '');
+        if (token) {
+          try {
+            // Try to fetch user identity from Strands auth service
+            const authResponse = await fetch('https://accounts.strands.gg/api/auth/me', {
+              headers: { 'Authorization': `Bearer ${token}` },
+            });
+            if (authResponse.ok) {
+              const userData = await authResponse.json();
+              userIdentity = {
+                subject: userData.id || userData.sub,
+                email: userData.email,
+                ...userData,
+              };
+            }
+          } catch {
+            // Auth validation failed - continue without identity
+          }
+        }
+      }
+
+      const auth = {
+        getUserIdentity: async () => userIdentity,
+      };
+
+      const ctx = {
+        auth: {
+          userId: userIdentity?.subject ?? null,
+          claims: userIdentity ?? {},
+        },
+        userId: userIdentity?.subject ?? null,
+      };
+
+      const result = await customFn.handler({
+        db,
+        ctx,
+        auth,
+        args: body.args ?? {},
+      });
+
+      return { data: result };
+    } catch (error) {
+      throw createError({
+        statusCode: 500,
+        message: error.message || 'Mutation execution failed',
+      });
+    }
+  }
+
+  // No custom function found - proxy to Tether API (generic CRUD)
   const response = await fetch(`${url}/api/v1/projects/${projectId}/mutation`, {
     method: 'POST',
     headers: {

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

@@ -1,11 +1,203 @@
 /**
  * Server-side query handler
- * Proxies queries to Tether API with the secret API key
+ * Executes local custom functions or proxies generic CRUD to Tether API
  */
 
-import { defineEventHandler, readBody, createError } from 'h3';
+import { defineEventHandler, readBody, createError, getHeader } from 'h3';
 import { useRuntimeConfig } from '#imports';
 
+// Dynamic function registry - populated on first request
+let functionRegistry = null;
+let registryError = null;
+
+/**
+ * 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
+    const functions = await import('~~/tether/functions/index.ts').catch(() => null);
+
+    if (functions) {
+      functionRegistry = functions;
+    } else {
+      // No custom functions found - that's OK, we'll proxy everything
+      functionRegistry = {};
+    }
+  } catch (error) {
+    // Failed to load - we'll proxy everything to Tether API
+    console.warn('[Tether] 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;
+          if (options?.orderBy) args.orderBy = options.orderBy;
+          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;
+          const 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;
+          const id = whereObj?.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 whereObj = options.where;
+          const id = whereObj?.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;
+        },
+      };
+    },
+  });
+}
+
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig();
 
@@ -37,6 +229,77 @@ export default defineEventHandler(async (event) => {
     });
   }
 
+  // Load function registry (once)
+  await loadFunctionRegistry();
+
+  // Try to find a custom function
+  const customFn = lookupFunction(body.function);
+
+  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');
+
+      // If using Strands auth, try to validate the token
+      if (strandsToken || authHeader?.startsWith('Bearer ')) {
+        const token = strandsToken || authHeader?.replace('Bearer ', '');
+        if (token) {
+          try {
+            // Try to fetch user identity from Strands auth service
+            const authResponse = await fetch('https://accounts.strands.gg/api/auth/me', {
+              headers: { 'Authorization': `Bearer ${token}` },
+            });
+            if (authResponse.ok) {
+              const userData = await authResponse.json();
+              userIdentity = {
+                subject: userData.id || userData.sub,
+                email: userData.email,
+                ...userData,
+              };
+            }
+          } catch {
+            // Auth validation failed - continue without identity
+          }
+        }
+      }
+
+      const auth = {
+        getUserIdentity: async () => userIdentity,
+      };
+
+      const ctx = {
+        auth: {
+          userId: userIdentity?.subject ?? null,
+          claims: userIdentity ?? {},
+        },
+        userId: userIdentity?.subject ?? null,
+      };
+
+      const result = await customFn.handler({
+        db,
+        ctx,
+        auth,
+        args: body.args ?? {},
+      });
+
+      return { data: result };
+    } catch (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: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tthr/vue",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Tether Vue/Nuxt SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,8 +29,8 @@
   },
   "dependencies": {
     "@nuxt/kit": "^3.14.0",
-    "@tthr/client": "workspace:*",
-    "@tthr/server": "workspace:*"
+    "@tthr/client": "latest",
+    "@tthr/server": "latest"
   },
   "devDependencies": {
     "typescript": "^5.7.2"