stagent 0.6.2 → 0.7.0

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 }
+    );
+  }
+}

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

@@ -0,0 +1,92 @@
+import { NextRequest, NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { db } from "@/lib/db";
+import { userTableTemplates } from "@/lib/db/schema";
+import { listTemplates, getTable, listRows } from "@/lib/data/tables";
+import { listTemplatesSchema } from "@/lib/tables/validation";
+
+export async function GET(req: NextRequest) {
+  try {
+    const url = new URL(req.url);
+    const category = url.searchParams.get("category") ?? undefined;
+    const scope = url.searchParams.get("scope") ?? undefined;
+
+    const parsed = listTemplatesSchema.safeParse({ category, scope });
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    const templates = await listTemplates(parsed.data);
+    return NextResponse.json(templates);
+  } catch (err) {
+    console.error("[tables] GET templates error:", err);
+    return NextResponse.json(
+      { error: "Failed to list templates" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/tables/templates — Save a table as a user-scoped template.
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { tableId, name, description, category, includeSampleData } = body as {
+      tableId?: string;
+      name?: string;
+      description?: string;
+      category?: string;
+      includeSampleData?: boolean;
+    };
+
+    if (!tableId || !name) {
+      return NextResponse.json(
+        { error: "tableId and name are required" },
+        { status: 400 }
+      );
+    }
+
+    const table = await getTable(tableId);
+    if (!table) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    // Optionally snapshot first 5 rows as sample data
+    let sampleData: string | null = null;
+    if (includeSampleData) {
+      const rows = await listRows(tableId, { limit: 5 });
+      sampleData = JSON.stringify(rows.map((r) => JSON.parse(r.data)));
+    }
+
+    const now = new Date();
+    const templateId = randomUUID();
+
+    db.insert(userTableTemplates)
+      .values({
+        id: templateId,
+        name,
+        description: description ?? table.description,
+        category: (category as "business" | "personal" | "pm" | "finance" | "content") ?? "personal",
+        columnSchema: table.columnSchema,
+        sampleData,
+        scope: "user",
+        icon: null,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    return NextResponse.json({ id: templateId, name }, { status: 201 });
+  } catch (err) {
+    console.error("[tables] POST templates error:", err);
+    return NextResponse.json(
+      { error: "Failed to save template" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
-import { tasks, projects, workflows, schedules, usageLedger } from "@/lib/db/schema";
+import { tasks, projects, workflows, schedules, usageLedger, documents } from "@/lib/db/schema";
 import { eq, sum, min, max } from "drizzle-orm";
 import { updateTaskSchema } from "@/lib/validators/task";
 import { isValidTransition, type TaskStatus } from "@/lib/constants/task-status";
@@ -106,11 +106,46 @@ export async function PATCH(
     }
   }
 
+  // Extract documentIds before spreading into task update (not a task column)
+  const { documentIds, ...taskFields } = parsed.data;
+  const now = new Date();
+
   await db
     .update(tasks)
-    .set({ ...parsed.data, updatedAt: new Date() })
+    .set({ ...taskFields, updatedAt: now })
     .where(eq(tasks.id, id));
 
+  // Handle document linking/unlinking
+  if (documentIds !== undefined) {
+    try {
+      // Unlink documents previously linked to this task that are no longer selected
+      const currentDocs = await db
+        .select({ id: documents.id })
+        .from(documents)
+        .where(eq(documents.taskId, id));
+      const newDocSet = new Set(documentIds);
+      for (const doc of currentDocs) {
+        if (!newDocSet.has(doc.id)) {
+          await db.update(documents)
+            .set({ taskId: null, updatedAt: now })
+            .where(eq(documents.id, doc.id));
+        }
+      }
+      // Link newly selected documents
+      for (const docId of documentIds) {
+        await db.update(documents)
+          .set({
+            taskId: id,
+            projectId: existing.projectId,
+            updatedAt: now,
+          })
+          .where(eq(documents.id, docId));
+      }
+    } catch (err) {
+      console.error("[tasks] Document association failed:", err);
+    }
+  }
+
   const [updated] = await db.select().from(tasks).where(eq(tasks.id, id));
   return NextResponse.json(updated);
 }