stagent 0.6.3 → 0.8.0

package/src/app/api/tables/[id]/import/route.ts

@@ -0,0 +1,111 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getTable, addColumn, getColumns } from "@/lib/data/tables";
+import {
+  extractStructuredData,
+  inferColumnTypes,
+  importRows,
+  createImportRecord,
+} from "@/lib/tables/import";
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const table = await getTable(id);
+    if (!table) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const body = await req.json();
+    const { documentId, columnMapping, preview } = body as {
+      documentId?: string;
+      columnMapping?: Array<{
+        name: string;
+        displayName: string;
+        dataType: string;
+        skip?: boolean;
+      }>;
+      preview?: boolean;
+    };
+
+    if (!documentId) {
+      return NextResponse.json(
+        { error: "documentId is required" },
+        { status: 400 }
+      );
+    }
+
+    // Step 1: Extract structured data from the document
+    const { headers, rows } = await extractStructuredData(documentId);
+
+    // Step 2: Infer column types from a sample (first 100 rows)
+    const sampleRows = rows.slice(0, 100);
+    const inferredColumns = inferColumnTypes(headers, sampleRows);
+
+    // If preview mode, return data without importing
+    if (preview) {
+      return NextResponse.json({
+        headers,
+        sampleRows: rows.slice(0, 10),
+        totalRows: rows.length,
+        inferredColumns,
+      });
+    }
+
+    // Step 3: Use user-provided column mapping or fall back to inferred
+    const finalColumns = columnMapping
+      ? inferredColumns.map((col) => {
+          const mapped = columnMapping.find(
+            (m) => m.name === col.name || m.displayName === col.displayName
+          );
+          if (mapped?.skip) return null;
+          if (mapped) {
+            return {
+              ...col,
+              name: mapped.name,
+              displayName: mapped.displayName,
+              dataType: mapped.dataType as typeof col.dataType,
+            };
+          }
+          return col;
+        }).filter(Boolean) as typeof inferredColumns
+      : inferredColumns;
+
+    // Step 4: Ensure columns exist on the table
+    const existingColumns = await getColumns(id);
+    const existingNames = new Set(existingColumns.map((c) => c.name));
+
+    for (const col of finalColumns) {
+      if (!existingNames.has(col.name)) {
+        await addColumn(id, {
+          name: col.name,
+          displayName: col.displayName,
+          dataType: col.dataType,
+          config: col.config,
+        });
+      }
+    }
+
+    // Step 5: Import all rows
+    const result = await importRows(id, rows, finalColumns);
+
+    // Step 6: Create import audit record
+    await createImportRecord(id, documentId, result);
+
+    return NextResponse.json({
+      importId: result.importId,
+      rowsImported: result.rowsImported,
+      rowsSkipped: result.rowsSkipped,
+      errors: result.errors.slice(0, 20), // Limit error detail in response
+      columns: finalColumns,
+    });
+  } catch (err) {
+    console.error("[tables/import] POST error:", err);
+    const message =
+      err instanceof Error ? err.message : "Failed to import data";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/src/app/api/tables/[id]/route.ts

@@ -0,0 +1,86 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getTable,
+  updateTable,
+  deleteTable,
+  getColumns,
+} from "@/lib/data/tables";
+import { updateTableSchema } from "@/lib/tables/validation";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const table = await getTable(id);
+    if (!table) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const columns = await getColumns(id);
+    return NextResponse.json({ ...table, columns });
+  } catch (err) {
+    console.error("[tables] GET by id error:", err);
+    return NextResponse.json(
+      { error: "Failed to get table" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PATCH(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const body = await req.json();
+    const parsed = updateTableSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    const existing = await getTable(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const updated = await updateTable(id, parsed.data);
+    return NextResponse.json(updated);
+  } catch (err) {
+    console.error("[tables] PATCH error:", err);
+    return NextResponse.json(
+      { error: "Failed to update table" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const existing = await getTable(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    await deleteTable(id);
+    return new NextResponse(null, { status: 204 });
+  } catch (err) {
+    console.error("[tables] DELETE error:", err);
+    return NextResponse.json(
+      { error: "Failed to delete table" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/tables/[id]/rows/[rowId]/history/route.ts

@@ -0,0 +1,32 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getRowHistory, rollbackRow } from "@/lib/tables/history";
+
+interface RouteContext {
+  params: Promise<{ id: string; rowId: string }>;
+}
+
+export async function GET(req: NextRequest, { params }: RouteContext) {
+  const { rowId } = await params;
+  const url = new URL(req.url);
+  const limit = Math.min(parseInt(url.searchParams.get("limit") ?? "50", 10), 200);
+
+  const history = getRowHistory(rowId, limit);
+  return NextResponse.json(history);
+}
+
+export async function POST(req: NextRequest, { params }: RouteContext) {
+  await params; // validate route
+  const body = await req.json();
+  const { historyEntryId } = body as { historyEntryId?: string };
+
+  if (!historyEntryId) {
+    return NextResponse.json({ error: "historyEntryId is required" }, { status: 400 });
+  }
+
+  const success = rollbackRow(historyEntryId);
+  if (!success) {
+    return NextResponse.json({ error: "History entry not found" }, { status: 404 });
+  }
+
+  return NextResponse.json({ ok: true });
+}

package/src/app/api/tables/[id]/rows/[rowId]/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import { updateRow, deleteRows } from "@/lib/data/tables";
+import { updateRowSchema } from "@/lib/tables/validation";
+
+export async function PATCH(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string; rowId: string }> }
+) {
+  const { rowId } = await params;
+
+  try {
+    const body = await req.json();
+    const parsed = updateRowSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    const row = await updateRow(rowId, parsed.data);
+    if (!row) {
+      return NextResponse.json({ error: "Row not found" }, { status: 404 });
+    }
+    return NextResponse.json(row);
+  } catch (err) {
+    console.error("[tables] PATCH row error:", err);
+    return NextResponse.json(
+      { error: "Failed to update row" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string; rowId: string }> }
+) {
+  const { rowId } = await params;
+
+  try {
+    await deleteRows([rowId]);
+    return new NextResponse(null, { status: 204 });
+  } catch (err) {
+    console.error("[tables] DELETE row error:", err);
+    return NextResponse.json(
+      { error: "Failed to delete row" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/tables/[id]/rows/route.ts

@@ -0,0 +1,101 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getTable, listRows, addRows } from "@/lib/data/tables";
+import { rowQuerySchema, addRowsSchema } from "@/lib/tables/validation";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const existing = await getTable(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const url = new URL(req.url);
+    const limit = url.searchParams.get("limit")
+      ? Number(url.searchParams.get("limit"))
+      : undefined;
+    const offset = url.searchParams.get("offset")
+      ? Number(url.searchParams.get("offset"))
+      : undefined;
+
+    let filters: unknown;
+    let sorts: unknown;
+
+    const filtersParam = url.searchParams.get("filters");
+    if (filtersParam) {
+      try {
+        filters = JSON.parse(filtersParam);
+      } catch {
+        return NextResponse.json(
+          { error: "Invalid filters JSON" },
+          { status: 400 }
+        );
+      }
+    }
+
+    const sortsParam = url.searchParams.get("sorts");
+    if (sortsParam) {
+      try {
+        sorts = JSON.parse(sortsParam);
+      } catch {
+        return NextResponse.json(
+          { error: "Invalid sorts JSON" },
+          { status: 400 }
+        );
+      }
+    }
+
+    const parsed = rowQuerySchema.safeParse({ limit, offset, filters, sorts });
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    const rows = await listRows(id, parsed.data);
+    return NextResponse.json(rows);
+  } catch (err) {
+    console.error("[tables] GET rows error:", err);
+    return NextResponse.json(
+      { error: "Failed to list rows" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const existing = await getTable(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const body = await req.json();
+    const parsed = addRowsSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    const rows = await addRows(id, parsed.data.rows);
+    return NextResponse.json(rows, { status: 201 });
+  } catch (err) {
+    console.error("[tables] POST rows error:", err);
+    return NextResponse.json(
+      { error: "Failed to add rows" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/tables/[id]/triggers/[triggerId]/route.ts

@@ -0,0 +1,65 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { userTableTriggers } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+
+interface RouteContext {
+  params: Promise<{ id: string; triggerId: string }>;
+}
+
+export async function PATCH(req: NextRequest, { params }: RouteContext) {
+  const { id, triggerId } = await params;
+
+  const trigger = db
+    .select()
+    .from(userTableTriggers)
+    .where(and(eq(userTableTriggers.id, triggerId), eq(userTableTriggers.tableId, id)))
+    .get();
+
+  if (!trigger) {
+    return NextResponse.json({ error: "Trigger not found" }, { status: 404 });
+  }
+
+  const body = await req.json();
+  const updates: Record<string, unknown> = { updatedAt: new Date() };
+
+  if (body.name !== undefined) updates.name = body.name;
+  if (body.triggerEvent !== undefined) updates.triggerEvent = body.triggerEvent;
+  if (body.status !== undefined) updates.status = body.status;
+  if (body.condition !== undefined) updates.condition = body.condition ? JSON.stringify(body.condition) : null;
+  if (body.actionType !== undefined) updates.actionType = body.actionType;
+  if (body.actionConfig !== undefined) updates.actionConfig = JSON.stringify(body.actionConfig);
+
+  db.update(userTableTriggers)
+    .set(updates)
+    .where(eq(userTableTriggers.id, triggerId))
+    .run();
+
+  const updated = db
+    .select()
+    .from(userTableTriggers)
+    .where(eq(userTableTriggers.id, triggerId))
+    .get();
+
+  return NextResponse.json(updated);
+}
+
+export async function DELETE(_req: NextRequest, { params }: RouteContext) {
+  const { id, triggerId } = await params;
+
+  const trigger = db
+    .select()
+    .from(userTableTriggers)
+    .where(and(eq(userTableTriggers.id, triggerId), eq(userTableTriggers.tableId, id)))
+    .get();
+
+  if (!trigger) {
+    return NextResponse.json({ error: "Trigger not found" }, { status: 404 });
+  }
+
+  db.delete(userTableTriggers)
+    .where(eq(userTableTriggers.id, triggerId))
+    .run();
+
+  return new NextResponse(null, { status: 204 });
+}

package/src/app/api/tables/[id]/triggers/route.ts

@@ -0,0 +1,122 @@
+import { NextRequest, NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { db } from "@/lib/db";
+import { userTableTriggers } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { getTable } from "@/lib/data/tables";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const table = await getTable(id);
+    if (!table) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const triggers = db
+      .select()
+      .from(userTableTriggers)
+      .where(eq(userTableTriggers.tableId, id))
+      .all();
+
+    return NextResponse.json(triggers);
+  } catch (err) {
+    console.error("[tables/triggers] GET error:", err);
+    return NextResponse.json({ error: "Failed to list triggers" }, { status: 500 });
+  }
+}
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const table = await getTable(id);
+    if (!table) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const body = await req.json();
+    const { name, triggerEvent, condition, actionType, actionConfig } = body as {
+      name?: string;
+      triggerEvent?: string;
+      condition?: unknown;
+      actionType?: string;
+      actionConfig?: unknown;
+    };
+
+    if (!name || !triggerEvent || !actionType || !actionConfig) {
+      return NextResponse.json(
+        { error: "name, triggerEvent, actionType, and actionConfig are required" },
+        { status: 400 }
+      );
+    }
+
+    const now = new Date();
+    const triggerId = randomUUID();
+
+    db.insert(userTableTriggers)
+      .values({
+        id: triggerId,
+        tableId: id,
+        name,
+        triggerEvent: triggerEvent as "row_added" | "row_updated" | "row_deleted",
+        condition: condition ? JSON.stringify(condition) : null,
+        actionType: actionType as "run_workflow" | "create_task",
+        actionConfig: JSON.stringify(actionConfig),
+        status: "active",
+        fireCount: 0,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    const trigger = db
+      .select()
+      .from(userTableTriggers)
+      .where(eq(userTableTriggers.id, triggerId))
+      .get();
+
+    return NextResponse.json(trigger, { status: 201 });
+  } catch (err) {
+    console.error("[tables/triggers] POST error:", err);
+    return NextResponse.json({ error: "Failed to create trigger" }, { status: 500 });
+  }
+}
+
+export async function PATCH(
+  req: NextRequest,
+  { params: _params }: { params: Promise<{ id: string }> }
+) {
+
+  try {
+    const body = await req.json();
+    const { triggerId, status } = body as { triggerId?: string; status?: string };
+
+    if (!triggerId || !status) {
+      return NextResponse.json(
+        { error: "triggerId and status are required" },
+        { status: 400 }
+      );
+    }
+
+    db.update(userTableTriggers)
+      .set({
+        status: status as "active" | "paused",
+        updatedAt: new Date(),
+      })
+      .where(eq(userTableTriggers.id, triggerId))
+      .run();
+
+    return NextResponse.json({ success: true });
+  } catch (err) {
+    console.error("[tables/triggers] PATCH error:", err);
+    return NextResponse.json({ error: "Failed to update trigger" }, { status: 500 });
+  }
+}

package/src/app/api/tables/route.ts

@@ -0,0 +1,65 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  listTables,
+  createTable,
+  cloneFromTemplate,
+} from "@/lib/data/tables";
+import {
+  createTableSchema,
+  cloneFromTemplateSchema,
+} from "@/lib/tables/validation";
+
+export async function GET(req: NextRequest) {
+  try {
+    const url = new URL(req.url);
+    const projectId = url.searchParams.get("projectId") ?? undefined;
+    const source = url.searchParams.get("source") ?? undefined;
+    const search = url.searchParams.get("search") ?? undefined;
+
+    const tables = await listTables({ projectId, source, search });
+    return NextResponse.json(tables);
+  } catch (err) {
+    console.error("[tables] GET error:", err);
+    return NextResponse.json(
+      { error: "Failed to list tables" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+
+    // Template clone path
+    if (body.templateId) {
+      const parsed = cloneFromTemplateSchema.safeParse(body);
+      if (!parsed.success) {
+        return NextResponse.json(
+          { error: parsed.error.flatten() },
+          { status: 400 }
+        );
+      }
+      const table = await cloneFromTemplate(parsed.data);
+      return NextResponse.json(table, { status: 201 });
+    }
+
+    // Normal create path
+    const parsed = createTableSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    const table = await createTable(parsed.data);
+    return NextResponse.json(table, { status: 201 });
+  } catch (err) {
+    console.error("[tables] POST error:", err);
+    return NextResponse.json(
+      { error: "Failed to create table" },
+      { status: 500 }
+    );
+  }
+}