@tthr/vue 0.0.13 → 0.0.14

package/nuxt/module.ts

@@ -19,7 +19,7 @@
  * - TETHER_API_KEY: Your project's API key (required, kept server-side)
  */
 
-import { defineNuxtModule, addPlugin, createResolver, addImports, addComponent, addServerHandler } from '@nuxt/kit';
+import { defineNuxtModule, addPlugin, createResolver, addImports, addComponent, addServerHandler, addServerImports } from '@nuxt/kit';
 
 export interface TetherModuleOptions {
   /** Project ID from Tether dashboard */
@@ -101,5 +101,13 @@ export default defineNuxtModule<TetherModuleOptions>({
       name: 'TetherWelcome',
       filePath: resolver.resolve('./runtime/components/TetherWelcome.vue'),
     });
+
+    // Auto-import server utilities (available in server/ directory)
+    addServerImports([
+      {
+        name: 'useTetherServer',
+        from: resolver.resolve('./runtime/server/utils/tether'),
+      },
+    ]);
   },
 });

package/nuxt/runtime/server/utils/tether.ts

@@ -0,0 +1,338 @@
+/**
+ * Server-side Tether utilities for Nuxt
+ *
+ * Use these in your Nuxt server endpoints (e.g., server/api/*.ts)
+ * to query and mutate Tether data with full type safety.
+ *
+ * @example
+ * ```ts
+ * // server/api/my-endpoint.ts
+ * export default defineEventHandler(async (event) => {
+ *   const tether = useTetherServer(event);
+ *
+ *   const todos = await tether.query('getTodos', { completed: false });
+ *   await tether.mutation('createTodo', { title: 'New todo' });
+ *
+ *   return { todos };
+ * });
+ * ```
+ */
+
+import { useRuntimeConfig, createError, type H3Event } from '#imports';
+
+export interface TetherServerClient {
+  /**
+   * Execute a query on the Tether server
+   */
+  query: <TResult = unknown>(
+    name: string,
+    args?: Record<string, unknown>
+  ) => Promise<TResult>;
+
+  /**
+   * Execute a mutation on the Tether server
+   */
+  mutation: <TResult = unknown>(
+    name: string,
+    args?: Record<string, unknown>
+  ) => Promise<TResult>;
+
+  /**
+   * File storage operations
+   */
+  storage: {
+    /**
+     * Generate a presigned upload URL
+     */
+    generateUploadUrl: (options: {
+      filename: string;
+      contentType: string;
+      metadata?: Record<string, unknown>;
+    }) => Promise<{ assetId: string; uploadUrl: string; expiresAt: string }>;
+
+    /**
+     * Confirm an upload has completed
+     */
+    confirmUpload: (assetId: string, sha256?: string) => Promise<AssetMetadata>;
+
+    /**
+     * Get a presigned download URL for an asset
+     */
+    getUrl: (assetId: string) => Promise<string>;
+
+    /**
+     * Get metadata for an asset
+     */
+    getMetadata: (assetId: string) => Promise<AssetMetadata>;
+
+    /**
+     * Delete an asset
+     */
+    delete: (assetId: string) => Promise<void>;
+
+    /**
+     * List assets with optional pagination and filtering
+     */
+    list: (options?: {
+      limit?: number;
+      offset?: number;
+      contentType?: string;
+    }) => Promise<{ assets: AssetMetadata[]; totalCount: number }>;
+  };
+
+  /**
+   * The project ID
+   */
+  projectId: string;
+
+  /**
+   * The API URL
+   */
+  url: string;
+}
+
+export interface AssetMetadata {
+  id: string;
+  filename: string;
+  contentType: string;
+  size: number;
+  sha256?: string;
+  createdAt: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Get a Tether client for use in server-side code
+ *
+ * @param event - The H3 event (optional, used for request context)
+ * @returns A Tether client with query, mutation, and storage methods
+ */
+export function useTetherServer(_event?: H3Event): TetherServerClient {
+  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;
+
+  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. Set TETHER_PROJECT_ID or configure in nuxt.config.ts.',
+    });
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${apiKey}`,
+  };
+
+  async function query<TResult = unknown>(
+    name: string,
+    args?: Record<string, unknown>
+  ): Promise<TResult> {
+    const response = await fetch(`${url}/api/v1/projects/${projectId}/query`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ function: name, args }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+      throw createError({
+        statusCode: response.status,
+        message: error.error || `Query '${name}' failed`,
+      });
+    }
+
+    const result = await response.json();
+    return result.data as TResult;
+  }
+
+  async function mutation<TResult = unknown>(
+    name: string,
+    args?: Record<string, unknown>
+  ): Promise<TResult> {
+    const response = await fetch(`${url}/api/v1/projects/${projectId}/mutation`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ function: name, args }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+      throw createError({
+        statusCode: response.status,
+        message: error.error || `Mutation '${name}' failed`,
+      });
+    }
+
+    const result = await response.json();
+    return result.data as TResult;
+  }
+
+  const storage = {
+    async generateUploadUrl(options: {
+      filename: string;
+      contentType: string;
+      metadata?: Record<string, unknown>;
+    }) {
+      const response = await fetch(`${url}/api/v1/projects/${projectId}/assets/upload-url`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          filename: options.filename,
+          content_type: options.contentType,
+          metadata: options.metadata,
+        }),
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+        throw createError({
+          statusCode: response.status,
+          message: error.error || 'Failed to generate upload URL',
+        });
+      }
+
+      const result = await response.json();
+      return {
+        assetId: result.asset_id,
+        uploadUrl: result.upload_url,
+        expiresAt: result.expires_at,
+      };
+    },
+
+    async confirmUpload(assetId: string, sha256?: string): Promise<AssetMetadata> {
+      const response = await fetch(`${url}/api/v1/projects/${projectId}/assets/${assetId}/complete`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ sha256 }),
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+        throw createError({
+          statusCode: response.status,
+          message: error.error || 'Failed to confirm upload',
+        });
+      }
+
+      const result = await response.json();
+      return mapAssetMetadata(result.asset);
+    },
+
+    async getUrl(assetId: string): Promise<string> {
+      const response = await fetch(`${url}/api/v1/projects/${projectId}/assets/${assetId}/url`, {
+        method: 'GET',
+        headers,
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+        throw createError({
+          statusCode: response.status,
+          message: error.error || 'Failed to get asset URL',
+        });
+      }
+
+      const result = await response.json();
+      return result.url;
+    },
+
+    async getMetadata(assetId: string): Promise<AssetMetadata> {
+      const response = await fetch(`${url}/api/v1/projects/${projectId}/assets/${assetId}`, {
+        method: 'GET',
+        headers,
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+        throw createError({
+          statusCode: response.status,
+          message: error.error || 'Failed to get asset metadata',
+        });
+      }
+
+      const result = await response.json();
+      return mapAssetMetadata(result.asset);
+    },
+
+    async delete(assetId: string): Promise<void> {
+      const response = await fetch(`${url}/api/v1/projects/${projectId}/assets/${assetId}`, {
+        method: 'DELETE',
+        headers,
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+        throw createError({
+          statusCode: response.status,
+          message: error.error || 'Failed to delete asset',
+        });
+      }
+    },
+
+    async list(options?: {
+      limit?: number;
+      offset?: number;
+      contentType?: string;
+    }): Promise<{ assets: AssetMetadata[]; totalCount: number }> {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set('limit', String(options.limit));
+      if (options?.offset) params.set('offset', String(options.offset));
+      if (options?.contentType) params.set('content_type', options.contentType);
+
+      const queryString = params.toString();
+      const fetchUrl = `${url}/api/v1/projects/${projectId}/assets${queryString ? `?${queryString}` : ''}`;
+
+      const response = await fetch(fetchUrl, {
+        method: 'GET',
+        headers,
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+        throw createError({
+          statusCode: response.status,
+          message: error.error || 'Failed to list assets',
+        });
+      }
+
+      const result = await response.json();
+      return {
+        assets: result.assets.map(mapAssetMetadata),
+        totalCount: result.total_count,
+      };
+    },
+  };
+
+  return {
+    query,
+    mutation,
+    storage,
+    projectId,
+    url,
+  };
+}
+
+/**
+ * Map snake_case API response to camelCase
+ */
+function mapAssetMetadata(asset: Record<string, unknown>): AssetMetadata {
+  return {
+    id: asset.id as string,
+    filename: asset.filename as string,
+    contentType: asset.content_type as string,
+    size: asset.size as number,
+    sha256: asset.sha256 as string | undefined,
+    createdAt: asset.created_at as string,
+    metadata: asset.metadata as Record<string, unknown> | undefined,
+  };
+}

package/package.json

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