// Query todos with assigned users - manual approach
const todos = await ctx.db.query("todos").collect();

// Manually fetch related data for each todo
const todosWithUsers = await Promise.all(
  todos.map(async (todo) => {
    const assignments = await ctx.db
      .query("todoAssignedUsers")
      .withIndex("todoId", (q) => q.eq("todoId", todo._id))
      .collect();

    const users = await Promise.all(
      assignments.map((a) => ctx.db.get(a.userId))
    );

    return { ...todo, assignedUsers: users };
  })
);

// Same query with Ents
const todos = await ctx.table("todos").collect();

const todosWithUsers = await Promise.all(
  todos.map(async (todo) => ({
    ...todo,
    assignedUsers: await todo.edge("assignedUsers"),
  }))
);

// tables/todos.ts
import { defineEnt, defineEntSchema, getEntDefinitions } from "convex-ents";
import { v } from "convex/values";

const entSchema = defineEntSchema({
  todos: defineEnt({
    title: v.string(),
    status: v.union(
      v.literal("todo"),
      v.literal("in_progress"),
      v.literal("done")
    ),
    organizationId: v.string(),
    userId: v.string(),
  })
    .index("organizationId", ["organizationId"])
    .edges("todoAssignedUsers", { ref: true }),

  todoAssignedUsers: defineEnt({
    todoId: v.id("todos"),
    userId: v.string(),
    assignedAt: v.number(),
  })
    .index("todoId_userId", ["todoId", "userId"])
    .edge("todo"),
});

export const entDefinitions = getEntDefinitions(entSchema);

// functions.ts
import { entsTableFactory } from "convex-ents";
import { entDefinitions } from "./tables/todos";

export const zQuery = zCustomQuery(baseQuery, {
  input: async (ctx) => ({
    ctx: {
      ...ctx,
      table: entsTableFactory(ctx, entDefinitions),
    },
  }),
});

export const list = zQuery({
  args: z.object({}),
  handler: async (ctx) => {
    // ctx.table provides Ents API
    return await ctx.table("todos").collect();
  },
});

// Get all documents
const todos = await ctx.table("todos").collect();

// Get by ID
const todo = await ctx.table("todos").get(todoId);

// Query with index
const orgTodos = await ctx.table("todos", "organizationId", (q) =>
  q.eq("organizationId", orgId)
).collect();

const todo = await ctx.table("todos").get(todoId);

// Navigate edges
const assignedUsers = await todo.edge("assignedUsers");

// Get document data
const { title, status } = todo;

// Get ID
const id = todo._id;

// One-to-many: Todo has many assigned users
.edges("todoAssignedUsers", { ref: true })

// Many-to-one: Assignment belongs to a todo
.edge("todo")

const todoId = await ctx.table("todos").insert({
  title: "New todo",
  status: "todo",
  organizationId: ctx.identity.activeOrganizationId,
  userId: ctx.identity.userId,
});

await ctx.table("todos").patch(todoId, {
  status: "done",
  updatedAt: Date.now(),
});

await ctx.table("todos").delete(todoId);

const todo = await ctx.table("todos").get(todoId);
if (!todo) throw new Error("Not found");

// Throws if not found
const todo = await ctx.table("todos").getX(todoId);

const todos = await ctx.table("todos").collect();

const todos = await ctx.table("todos", "organizationId", (q) =>
  q.eq("organizationId", orgId)
).collect();

const doneTodos = await ctx.table("todos")
  .filter((q) => q.eq(q.field("status"), "done"))
  .collect();

const recentTodos = await ctx.table("todos")
  .order("desc") // by _creationTime
  .take(10);

// Get first match
const firstTodo = await ctx.table("todos", "organizationId", (q) =>
  q.eq("organizationId", orgId)
).first();

// Get unique (throws if multiple)
const uniqueTodo = await ctx.table("todos", "someUniqueIndex", (q) =>
  q.eq("uniqueField", value)
).unique();