// vitest.config.mts
import { defineConfig } from "vitest/config";

export default defineConfig({
  test: {
    environment: "edge-runtime",
    server: { deps: { inline: ["convex-test"] } },
  },
});

// vitest.config.mts
import { defineConfig } from "vitest/config";

export default defineConfig({
  test: {
    environment: "edge-runtime",
    server: { deps: { inline: ["convex-test"] } },
  },
});

// subjects.test.ts
import { convexTest } from "convex-test";
import { expect, test } from "vitest";
import { api } from "./_generated/api";
import schema from "./schema";

test("creating and retrieving subjects", async () => {
  const t = convexTest(schema);

  // Setup admin user
  const asAdmin = t.withIdentity({
    name: "Admin User",
    role: "admin",
  });

  // Test creating a subject
  const mathId = await asAdmin.mutation(api.subjects.createSubject, {
    name: "Mathematics",
  });

  // Test getting all subjects
  const allSubjects = await t.query(api.subjects.getAllSubjects);
  expect(allSubjects).toHaveLength(1);
  expect(allSubjects[0]).toMatchObject({
    name: "Mathematics",
  });

  // Test getting subject by ID
  const mathSubject = await t.query(api.subjects.getSubjectById, {
    id: mathId,
  });
  expect(mathSubject).toMatchObject({
    name: "Mathematics",
  });
});

// subjects.ts
...
// Mutation to create a new subject
export const createSubject = mutation({
  args: {
    name: v.string(),
  },
  handler: async (ctx, args) => {
    await requireRole(ctx, ROLES.ADMIN);

    const subjectId = await ctx.db.insert("subjects", {
      name: args.name,
    });

    return subjectId;
  },
});

// schemas.ts
import { defineSchema, defineTable } from "convex/server";
import { authTables } from "@convex-dev/auth/server";
import { v } from "convex/values";
import { ROLES } from "./lib/permissions";

const schema = defineSchema({
  ...authTables,

  /**
   * Users table
   */
  users: defineTable({
    name: v.optional(v.string()),
    ...
    role: v.optional(
      v.union(
        v.literal(ROLES.ADMIN),
        v.literal(ROLES.TUTOR),
        v.literal(ROLES.STUDENT)
      )
    ),
  })
    .index("email", ["email"])
    .index("phone", ["phone"])
    .index("role", ["role"]),

  /**
   * Subjects table
   */
  subjects: defineTable({
    name: v.string(),
  }),

  /**
   * Levels table
   */
  levels: defineTable({
    name: v.string(),
    subjectId: v.id("subjects"),
  }).index("by_subjectId", ["subjectId"]),
});

export default schema;

// permissions.ts
export const ROLES = {
  STUDENT: "student",
  TUTOR: "tutor",
  ADMIN: "admin",
} as const;

export async function checkRole(
  ctx: QueryCtx | MutationCtx,
  requiredRole: Role
): Promise<boolean> {
  const user = await ctx.auth.getUserIdentity();

  // If the user doesn't exist or doesn't have a role, return false
  if (!user || !user.roles) return false;

  // Check if the user has the required role
  return user.roles === requiredRole;
}

export async function requireRole(
  ctx: QueryCtx | MutationCtx,
  requiredRole: Role
): Promise<void> {
  const hasRole = await checkRole(ctx, requiredRole);
  if (!hasRole) {
    throw new Error(`Access denied. Required role: ${requiredRole}`);
  }
}

// subjects.test.ts
import { convexTest } from "convex-test";
import { expect, test } from "vitest";
import { api } from "./_generated/api";
import schema from "./schema";

test("creating and retrieving subjects", async () => {
  const t = convexTest(schema);

  // Setup admin user
  const asAdmin = t.withIdentity({
    name: "Admin User",
    role: "admin",
  });

  // Test creating a subject
  const mathId = await asAdmin.mutation(api.subjects.createSubject, {
    name: "Mathematics",
  });

  // Test getting all subjects
  const allSubjects = await t.query(api.subjects.getAllSubjects);
  expect(allSubjects).toHaveLength(1);
  expect(allSubjects[0]).toMatchObject({
    name: "Mathematics",
  });

  // Test getting subject by ID
  const mathSubject = await t.query(api.subjects.getSubjectById, {
    id: mathId,
  });
  expect(mathSubject).toMatchObject({
    name: "Mathematics",
  });
});

// subjects.ts
...
// Mutation to create a new subject
export const createSubject = mutation({
  args: {
    name: v.string(),
  },
  handler: async (ctx, args) => {
    await requireRole(ctx, ROLES.ADMIN);

    const subjectId = await ctx.db.insert("subjects", {
      name: args.name,
    });

    return subjectId;
  },
});

// schemas.ts
import { defineSchema, defineTable } from "convex/server";
import { authTables } from "@convex-dev/auth/server";
import { v } from "convex/values";
import { ROLES } from "./lib/permissions";

const schema = defineSchema({
  ...authTables,

  /**
   * Users table
   */
  users: defineTable({
    name: v.optional(v.string()),
    ...
    role: v.optional(
      v.union(
        v.literal(ROLES.ADMIN),
        v.literal(ROLES.TUTOR),
        v.literal(ROLES.STUDENT)
      )
    ),
  })
    .index("email", ["email"])
    .index("phone", ["phone"])
    .index("role", ["role"]),

  /**
   * Subjects table
   */
  subjects: defineTable({
    name: v.string(),
  }),

  /**
   * Levels table
   */
  levels: defineTable({
    name: v.string(),
    subjectId: v.id("subjects"),
  }).index("by_subjectId", ["subjectId"]),
});

export default schema;

// permissions.ts
export const ROLES = {
  STUDENT: "student",
  TUTOR: "tutor",
  ADMIN: "admin",
} as const;

export async function checkRole(
  ctx: QueryCtx | MutationCtx,
  requiredRole: Role
): Promise<boolean> {
  const user = await ctx.auth.getUserIdentity();

  // If the user doesn't exist or doesn't have a role, return false
  if (!user || !user.roles) return false;

  // Check if the user has the required role
  return user.roles === requiredRole;
}

export async function requireRole(
  ctx: QueryCtx | MutationCtx,
  requiredRole: Role
): Promise<void> {
  const hasRole = await checkRole(ctx, requiredRole);
  if (!hasRole) {
    throw new Error(`Access denied. Required role: ${requiredRole}`);
  }
}