Nova - Prompt Engineering Platform

CREATE TABLE private.nova_challenges (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  title text NOT NULL,
  description text NOT NULL,
  duration integer NOT NULL,            -- session duration in seconds
  enabled boolean NOT NULL DEFAULT false,
  max_attempts integer NOT NULL,
  max_daily_attempts integer NOT NULL,
  open_at timestamptz,
  close_at timestamptz,
  previewable_at timestamptz,
  whitelisted_only boolean NOT NULL DEFAULT false,
  password_hash text,
  password_salt text,
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE private.nova_problems (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  challenge_id uuid NOT NULL REFERENCES private.nova_challenges(id),
  title text NOT NULL,
  description text NOT NULL,
  example_input text NOT NULL,
  example_output text NOT NULL,
  max_prompt_length integer NOT NULL,   -- caps how long a submitted prompt may be
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE private.nova_problem_test_cases (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  problem_id uuid NOT NULL REFERENCES private.nova_problems(id),
  input text NOT NULL,
  output text NOT NULL,
  hidden boolean NOT NULL DEFAULT false, -- hidden test cases are not exposed to participants
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE private.nova_challenge_criteria (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  challenge_id uuid NOT NULL REFERENCES private.nova_challenges(id),
  name text NOT NULL,
  description text NOT NULL,
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE private.nova_sessions (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  challenge_id uuid NOT NULL REFERENCES private.nova_challenges(id),
  user_id uuid NOT NULL,
  status text NOT NULL,
  start_time timestamptz NOT NULL,
  end_time timestamptz,
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE private.nova_submissions (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  problem_id uuid NOT NULL REFERENCES private.nova_problems(id),
  session_id uuid REFERENCES private.nova_sessions(id),
  user_id uuid NOT NULL,
  prompt text NOT NULL,
  overall_assessment text,
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE private.nova_submission_criteria (
  submission_id uuid NOT NULL REFERENCES private.nova_submissions(id),
  criteria_id uuid NOT NULL REFERENCES private.nova_challenge_criteria(id),
  score numeric NOT NULL,
  feedback text NOT NULL,
  strengths text[],
  improvements text[],
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE private.nova_submission_test_cases (
  submission_id uuid NOT NULL REFERENCES private.nova_submissions(id),
  test_case_id uuid NOT NULL REFERENCES private.nova_problem_test_cases(id),
  output text NOT NULL,
  matched boolean NOT NULL DEFAULT false,
  confidence numeric,
  reasoning text,
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE private.nova_teams (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  name text NOT NULL,
  description text,
  goals text,
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE private.nova_team_members (
  team_id uuid NOT NULL REFERENCES private.nova_teams(id),
  user_id uuid NOT NULL,
  created_at timestamptz NOT NULL DEFAULT now()
);

-- Invite-by-email roster for a team
CREATE TABLE private.nova_team_emails (
  team_id uuid NOT NULL REFERENCES private.nova_teams(id),
  email text NOT NULL,
  created_at timestamptz NOT NULL DEFAULT now()
);

-- Emails allowed to participate when a challenge is whitelisted_only
CREATE TABLE private.nova_challenge_whitelisted_emails (
  challenge_id uuid NOT NULL REFERENCES private.nova_challenges(id),
  email text NOT NULL,
  created_at timestamptz NOT NULL DEFAULT now()
);

-- Emails granted management rights over a specific challenge
CREATE TABLE private.nova_challenge_manager_emails (
  challenge_id uuid NOT NULL REFERENCES private.nova_challenges(id),
  email text NOT NULL,
  created_at timestamptz NOT NULL DEFAULT now()
);

// apps/nova/src/app/api/v1/problems/route.ts (simplified)
import { createAdminClient } from '@tuturuuu/supabase/next/server';
import { NextResponse } from 'next/server';
import { getNovaAppSessionUserFromRequest } from '@/lib/app-session';

export async function GET(request: Request) {
  const { searchParams } = new URL(request.url);
  const challengeId = searchParams.get('challengeId');

  // App-session resolution is synchronous; do NOT await it.
  const user = getNovaAppSessionUserFromRequest(request);
  if (!user?.id) {
    return NextResponse.json({ message: 'Unauthorized' }, { status: 401 });
  }

  // createAdminClient is synchronous, but { noCookie: true } returns a promise
  // in this entrypoint, so await it here.
  const sbAdmin = await createAdminClient({ noCookie: true });

  let query = sbAdmin
    .schema('private')
    .from('nova_problems')
    .select('*')
    .order('created_at', { ascending: false });

  if (challengeId) {
    query = query.eq('challenge_id', challengeId);
  }

  const { data: problems, error } = await query;
  if (error) {
    return NextResponse.json(
      { message: 'Error fetching problems' },
      { status: 500 }
    );
  }

  return NextResponse.json(problems, { status: 200 });
}

// apps/nova/src/app/api/v1/problems/route.ts (simplified)
import { createAdminClient } from '@tuturuuu/supabase/next/server';
import { NextResponse } from 'next/server';
import { getNovaAppSessionUserFromRequest } from '@/lib/app-session';
import { canManageNovaChallenge } from '@/lib/challenge-management-auth';
import { createProblemSchema } from '../schemas';

export async function POST(request: Request) {
  const user = getNovaAppSessionUserFromRequest(request);
  if (!user?.id) {
    return NextResponse.json({ message: 'Unauthorized' }, { status: 401 });
  }

  const validatedData = createProblemSchema.parse(await request.json());
  const sbAdmin = await createAdminClient({ noCookie: true });

  // Authorize against the target challenge before the privileged write.
  if (!(await canManageNovaChallenge(user, validatedData.challengeId, sbAdmin))) {
    return NextResponse.json({ message: 'Forbidden' }, { status: 403 });
  }

  const { data: problem, error } = await sbAdmin
    .schema('private')
    .from('nova_problems')
    .insert({
      title: validatedData.title,
      description: validatedData.description,
      max_prompt_length: validatedData.maxPromptLength,
      example_input: validatedData.exampleInput,
      example_output: validatedData.exampleOutput,
      challenge_id: validatedData.challengeId,
    })
    .select()
    .single();

  if (error) {
    return NextResponse.json(
      { message: 'Error creating problem' },
      { status: 500 }
    );
  }

  return NextResponse.json(problem, { status: 201 });
}