veryfront 0.0.48 → 0.0.50

package/dist/integrations/supabase/files/ai/tools/delete-row.ts

@@ -0,0 +1,77 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { deleteRow, deleteRows } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "delete-row",
+  description:
+    "Delete rows from a Supabase table. Can delete by ID or by custom filter conditions. Returns the deleted rows.",
+  inputSchema: z.object({
+    tableName: z.string().describe("The name of the table to delete from"),
+    id: z.union([z.string(), z.number()]).optional().describe(
+      "The ID of the row to delete (if deleting a single row by ID)",
+    ),
+    filter: z.record(z.unknown()).optional().describe(
+      'Filter conditions to match rows to delete (e.g., {"status": "archived"})',
+    ),
+    confirm: z.boolean().default(false).describe(
+      "Confirm deletion (must be true to proceed with delete operation)",
+    ),
+  }),
+  async execute({ tableName, id, filter, confirm }) {
+    // Require confirmation for delete operations
+    if (!confirm) {
+      return {
+        success: false,
+        tableName,
+        error: "Deletion not confirmed",
+        message: "You must set confirm: true to delete rows. This is a safety measure.",
+      };
+    }
+
+    try {
+      // Validate that either id or filter is provided
+      if (!id && !filter) {
+        return {
+          success: false,
+          tableName,
+          error: "Either id or filter must be provided",
+          message: "You must specify either an id or filter conditions to delete rows",
+        };
+      }
+
+      // Delete by ID (single row)
+      if (id) {
+        const result = await deleteRow(tableName, id);
+        return {
+          success: true,
+          tableName,
+          rowsDeleted: 1,
+          row: result,
+          message: `Successfully deleted row with id ${id} from ${tableName}`,
+        };
+      }
+
+      // Delete by filter (multiple rows)
+      if (filter) {
+        const results = await deleteRows(tableName, filter);
+        return {
+          success: true,
+          tableName,
+          rowsDeleted: results.length,
+          rows: results,
+          message: `Successfully deleted ${results.length} row(s) from ${tableName}`,
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+
+      return {
+        success: false,
+        tableName,
+        error: errorMessage,
+        message: `Failed to delete row(s) from ${tableName}: ${errorMessage}`,
+      };
+    }
+  },
+});

package/dist/integrations/supabase/files/ai/tools/insert-row.ts

@@ -0,0 +1,35 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { insertRow } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "insert-row",
+  description: "Insert a new row into a Supabase table. Returns the created row.",
+  inputSchema: z.object({
+    tableName: z.string().describe("The name of the table to insert into"),
+    data: z.record(z.unknown()).describe(
+      "The data to insert as key-value pairs matching the table schema",
+    ),
+  }),
+  async execute({ tableName, data }) {
+    try {
+      const result = await insertRow(tableName, data);
+
+      return {
+        success: true,
+        tableName,
+        row: result,
+        message: `Successfully inserted row into ${tableName}`,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+
+      return {
+        success: false,
+        tableName,
+        error: errorMessage,
+        message: `Failed to insert row into ${tableName}: ${errorMessage}`,
+      };
+    }
+  },
+});

package/dist/integrations/supabase/files/ai/tools/list-tables.ts

@@ -0,0 +1,60 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getTableColumns, listTables } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "list-tables",
+  description: "List all tables in your Supabase database with their schema information.",
+  inputSchema: z.object({
+    includeColumns: z.boolean().default(false).describe(
+      "Include column information for each table",
+    ),
+  }),
+  async execute({ includeColumns }) {
+    const tables = await listTables();
+
+    if (!includeColumns) {
+      return {
+        count: tables.length,
+        tables: tables.map((t) => ({
+          name: t.table_name,
+          schema: t.table_schema,
+          type: t.table_type,
+        })),
+      };
+    }
+
+    // Fetch column information for each table
+    const tablesWithColumns = await Promise.all(
+      tables.map(async (table) => {
+        try {
+          const columns = await getTableColumns(table.table_name);
+          return {
+            name: table.table_name,
+            schema: table.table_schema,
+            type: table.table_type,
+            columns: columns.map((c) => ({
+              name: c.column_name,
+              type: c.data_type,
+              nullable: c.is_nullable === "YES",
+              default: c.column_default,
+            })),
+          };
+        } catch (error) {
+          return {
+            name: table.table_name,
+            schema: table.table_schema,
+            type: table.table_type,
+            columns: [],
+            error: error instanceof Error ? error.message : "Failed to fetch columns",
+          };
+        }
+      }),
+    );
+
+    return {
+      count: tablesWithColumns.length,
+      tables: tablesWithColumns,
+    };
+  },
+});

package/dist/integrations/supabase/files/ai/tools/query-table.ts

@@ -0,0 +1,48 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { queryTable } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "query-table",
+  description:
+    "Query a table in your Supabase database with optional filters, sorting, and pagination.",
+  inputSchema: z.object({
+    tableName: z.string().describe("The name of the table to query"),
+    select: z.string().optional().describe(
+      'Columns to select (comma-separated, e.g., "id,name,email"). Default is all columns (*)',
+    ),
+    filter: z.record(z.unknown()).optional().describe(
+      'Filter conditions as key-value pairs (e.g., {"status": "active", "age": 25})',
+    ),
+    orderBy: z.string().optional().describe("Column to order by"),
+    ascending: z.boolean().default(true).describe(
+      "Sort in ascending order (true) or descending (false)",
+    ),
+    limit: z.number().min(1).max(1000).default(100).describe(
+      "Maximum number of rows to return (1-1000)",
+    ),
+    offset: z.number().min(0).default(0).describe("Number of rows to skip (for pagination)"),
+  }),
+  async execute({ tableName, select, filter, orderBy, ascending, limit, offset }) {
+    const options = {
+      select,
+      filter,
+      order: orderBy ? { column: orderBy, ascending } : undefined,
+      limit,
+      offset,
+    };
+
+    const results = await queryTable(tableName, options);
+
+    return {
+      tableName,
+      count: results.length,
+      rows: results,
+      pagination: {
+        limit,
+        offset,
+        hasMore: results.length === limit,
+      },
+    };
+  },
+});

package/dist/integrations/supabase/files/ai/tools/update-row.ts

@@ -0,0 +1,64 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateRow, updateRows } from "../../lib/supabase-client.ts";
+
+export default tool({
+  id: "update-row",
+  description: "Update rows in a Supabase table. Can update by ID or by custom filter conditions.",
+  inputSchema: z.object({
+    tableName: z.string().describe("The name of the table to update"),
+    id: z.union([z.string(), z.number()]).optional().describe(
+      "The ID of the row to update (if updating a single row by ID)",
+    ),
+    filter: z.record(z.unknown()).optional().describe(
+      'Filter conditions to match rows to update (e.g., {"status": "pending"})',
+    ),
+    data: z.record(z.unknown()).describe("The data to update as key-value pairs"),
+  }),
+  async execute({ tableName, id, filter, data }) {
+    try {
+      // Validate that either id or filter is provided
+      if (!id && !filter) {
+        return {
+          success: false,
+          tableName,
+          error: "Either id or filter must be provided",
+          message: "You must specify either an id or filter conditions to update rows",
+        };
+      }
+
+      // Update by ID (single row)
+      if (id) {
+        const result = await updateRow(tableName, id, data);
+        return {
+          success: true,
+          tableName,
+          rowsUpdated: 1,
+          row: result,
+          message: `Successfully updated row with id ${id} in ${tableName}`,
+        };
+      }
+
+      // Update by filter (multiple rows)
+      if (filter) {
+        const results = await updateRows(tableName, filter, data);
+        return {
+          success: true,
+          tableName,
+          rowsUpdated: results.length,
+          rows: results,
+          message: `Successfully updated ${results.length} row(s) in ${tableName}`,
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+
+      return {
+        success: false,
+        tableName,
+        error: errorMessage,
+        message: `Failed to update row(s) in ${tableName}: ${errorMessage}`,
+      };
+    }
+  },
+});

package/dist/integrations/supabase/files/app/api/auth/supabase/route.ts

@@ -0,0 +1,91 @@
+import { isConfigured, setSupabaseConfig } from "../../../../lib/token-store.ts";
+
+/**
+ * POST /api/auth/supabase
+ * Initialize Supabase configuration with API keys
+ */
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { url, anonKey, serviceKey } = body;
+
+    // Validate required fields
+    if (!url || !anonKey || !serviceKey) {
+      return Response.json(
+        { error: "Missing required fields: url, anonKey, serviceKey" },
+        { status: 400 },
+      );
+    }
+
+    // Validate URL format
+    try {
+      new URL(url);
+    } catch {
+      return Response.json(
+        { error: "Invalid Supabase URL format" },
+        { status: 400 },
+      );
+    }
+
+    // Store configuration
+    setSupabaseConfig({
+      url,
+      anonKey,
+      serviceKey,
+    });
+
+    return Response.json({
+      success: true,
+      message: "Supabase configuration saved successfully",
+    });
+  } catch (error) {
+    console.error("Supabase config error:", error);
+    return Response.json(
+      { error: "Failed to configure Supabase" },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * GET /api/auth/supabase
+ * Check if Supabase is configured
+ */
+export function GET() {
+  try {
+    const configured = isConfigured();
+
+    return Response.json({
+      configured,
+      message: configured ? "Supabase is configured" : "Supabase is not configured",
+    });
+  } catch (error) {
+    console.error("Supabase status check error:", error);
+    return Response.json(
+      { error: "Failed to check Supabase status" },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * DELETE /api/auth/supabase
+ * Clear Supabase configuration
+ */
+export async function DELETE() {
+  try {
+    const { clearConfig } = await import("../../../../lib/token-store.ts");
+    clearConfig();
+
+    return Response.json({
+      success: true,
+      message: "Supabase configuration cleared",
+    });
+  } catch (error) {
+    console.error("Supabase clear config error:", error);
+    return Response.json(
+      { error: "Failed to clear Supabase configuration" },
+      { status: 500 },
+    );
+  }
+}

package/dist/integrations/supabase/files/lib/supabase-client.ts

@@ -0,0 +1,296 @@
+import { getAnonKey, getServiceKey, getSupabaseUrl } from "./token-store.ts";
+
+interface SupabaseResponse<T> {
+  data: T | null;
+  error: {
+    message: string;
+    details?: string;
+    hint?: string;
+    code?: string;
+  } | null;
+}
+
+interface TableInfo {
+  table_name: string;
+  table_schema: string;
+  table_type: string;
+}
+
+interface ColumnInfo {
+  column_name: string;
+  data_type: string;
+  is_nullable: string;
+  column_default: string | null;
+}
+
+interface QueryOptions {
+  select?: string;
+  filter?: Record<string, unknown>;
+  order?: { column: string; ascending?: boolean };
+  limit?: number;
+  offset?: number;
+}
+
+interface SupabaseError extends Error {
+  code?: string;
+  details?: string;
+  hint?: string;
+}
+
+async function supabaseFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+  useServiceRole = true,
+): Promise<T> {
+  const url = getSupabaseUrl();
+  const apiKey = useServiceRole ? getServiceKey() : getAnonKey();
+
+  const response = await fetch(`${url}/rest/v1${endpoint}`, {
+    ...options,
+    headers: {
+      "apikey": apiKey,
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "Prefer": "return=representation",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({})) as SupabaseError;
+    const errorMessage = error.message ||
+      `Supabase API error: ${response.status} ${response.statusText}`;
+    const err: SupabaseError = new Error(errorMessage);
+    err.code = error.code;
+    err.details = error.details;
+    err.hint = error.hint;
+    throw err;
+  }
+
+  // Handle empty responses (like DELETE)
+  const text = await response.text();
+  return text ? JSON.parse(text) : null;
+}
+
+/**
+ * List all tables in the public schema
+ */
+export async function listTables(): Promise<TableInfo[]> {
+  try {
+    const tables = await supabaseFetch<TableInfo[]>(
+      `/rpc/get_tables`,
+      {
+        method: "POST",
+        body: JSON.stringify({}),
+      },
+    );
+    return tables || [];
+  } catch (_error) {
+    // Fallback: query information_schema directly
+    const query =
+      `?select=table_name,table_schema,table_type&table_schema=eq.public&table_type=eq.BASE TABLE`;
+    const tables = await supabaseFetch<TableInfo[]>(`/information_schema.tables${query}`);
+    return tables || [];
+  }
+}
+
+/**
+ * Get columns for a specific table
+ */
+export async function getTableColumns(tableName: string): Promise<ColumnInfo[]> {
+  const query =
+    `?select=column_name,data_type,is_nullable,column_default&table_name=eq.${tableName}&table_schema=eq.public`;
+  const columns = await supabaseFetch<ColumnInfo[]>(`/information_schema.columns${query}`);
+  return columns || [];
+}
+
+/**
+ * Query a table with filters, sorting, and pagination
+ */
+export async function queryTable<T = Record<string, unknown>>(
+  tableName: string,
+  options: QueryOptions = {},
+): Promise<T[]> {
+  const params = new URLSearchParams();
+
+  // Select columns
+  if (options.select) {
+    params.append("select", options.select);
+  } else {
+    params.append("select", "*");
+  }
+
+  // Add filters
+  if (options.filter) {
+    for (const [key, value] of Object.entries(options.filter)) {
+      if (value === null) {
+        params.append(key, "is.null");
+      } else if (typeof value === "string") {
+        params.append(key, `eq.${value}`);
+      } else if (typeof value === "number") {
+        params.append(key, `eq.${value}`);
+      } else if (typeof value === "boolean") {
+        params.append(key, `eq.${value}`);
+      }
+    }
+  }
+
+  // Add ordering
+  if (options.order) {
+    const direction = options.order.ascending === false ? ".desc" : ".asc";
+    params.append("order", `${options.order.column}${direction}`);
+  }
+
+  // Add pagination
+  if (options.limit) {
+    params.append("limit", options.limit.toString());
+  }
+  if (options.offset) {
+    params.append("offset", options.offset.toString());
+  }
+
+  const queryString = params.toString();
+  const results = await supabaseFetch<T[]>(`/${tableName}?${queryString}`);
+  return results || [];
+}
+
+/**
+ * Insert a new row into a table
+ */
+export async function insertRow<T = Record<string, unknown>>(
+  tableName: string,
+  data: Record<string, unknown>,
+): Promise<T> {
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}`,
+    {
+      method: "POST",
+      body: JSON.stringify(data),
+    },
+  );
+
+  if (!result || result.length === 0) {
+    throw new Error("Insert operation did not return data");
+  }
+
+  return result[0];
+}
+
+/**
+ * Update a row in a table by ID
+ */
+export async function updateRow<T = Record<string, unknown>>(
+  tableName: string,
+  id: string | number,
+  data: Record<string, unknown>,
+): Promise<T> {
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}?id=eq.${id}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify(data),
+    },
+  );
+
+  if (!result || result.length === 0) {
+    throw new Error(`No row found with id ${id}`);
+  }
+
+  return result[0];
+}
+
+/**
+ * Update rows in a table with custom filter
+ */
+export async function updateRows<T = Record<string, unknown>>(
+  tableName: string,
+  filter: Record<string, unknown>,
+  data: Record<string, unknown>,
+): Promise<T[]> {
+  const params = new URLSearchParams();
+
+  for (const [key, value] of Object.entries(filter)) {
+    params.append(key, `eq.${value}`);
+  }
+
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}?${params.toString()}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify(data),
+    },
+  );
+
+  return result || [];
+}
+
+/**
+ * Delete a row from a table by ID
+ */
+export async function deleteRow<T = Record<string, unknown>>(
+  tableName: string,
+  id: string | number,
+): Promise<T> {
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}?id=eq.${id}`,
+    {
+      method: "DELETE",
+    },
+  );
+
+  if (!result || result.length === 0) {
+    throw new Error(`No row found with id ${id}`);
+  }
+
+  return result[0];
+}
+
+/**
+ * Delete rows from a table with custom filter
+ */
+export async function deleteRows<T = Record<string, unknown>>(
+  tableName: string,
+  filter: Record<string, unknown>,
+): Promise<T[]> {
+  const params = new URLSearchParams();
+
+  for (const [key, value] of Object.entries(filter)) {
+    params.append(key, `eq.${value}`);
+  }
+
+  const result = await supabaseFetch<T[]>(
+    `/${tableName}?${params.toString()}`,
+    {
+      method: "DELETE",
+    },
+  );
+
+  return result || [];
+}
+
+/**
+ * Execute a raw SQL query using RPC
+ * Note: This requires a stored procedure to be created in your Supabase database
+ */
+export function runRawQuery<T = unknown>(
+  query: string,
+): Promise<T> {
+  return supabaseFetch<T>(
+    "/rpc/execute_sql",
+    {
+      method: "POST",
+      body: JSON.stringify({ query }),
+    },
+  );
+}
+
+/**
+ * Get client instance (for use with @supabase/supabase-js if needed)
+ */
+export function getClient() {
+  return {
+    url: getSupabaseUrl(),
+    anonKey: getAnonKey(),
+    serviceKey: getServiceKey(),
+  };
+}