Function bodies 245 total

middleware function · typescript · L4-L55 (52 LOC)

middleware.ts

export async function middleware(request: NextRequest) {
  let supabaseResponse = NextResponse.next({
    request,
  });

  const supabase = createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return request.cookies.getAll();
        },
        setAll(cookiesToSet) {
          cookiesToSet.forEach(({ name, value }) =>
            request.cookies.set(name, value)
          );
          supabaseResponse = NextResponse.next({
            request,
          });
          cookiesToSet.forEach(({ name, value, options }) =>
            supabaseResponse.cookies.set(name, value, options)
          );
        },
      },
    }
  );

  const {
    data: { user },
  } = await supabase.auth.getUser();

  // Redirect unauthenticated users to login (except for auth pages)
  const isAuthPage =
    request.nextUrl.pathname === "/login" ||
    request.nextUrl.pathname === "/signup";

  if (!use

POST function · typescript · L19-L86 (68 LOC)

src/app/api/analysis/summarize/route.ts

export async function POST(request: Request) {
  try {
    const { analysisId, analysis, title } = await request.json();

    if (!analysis || !analysisId) {
      return Response.json({ error: "Missing analysis data" }, { status: 400 });
    }

    const NOTE_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
    function midiToNote(midi: number): string {
      return `${NOTE_NAMES[midi % 12]}${Math.floor(midi / 12) - 1}`;
    }

    // Build chord progression string
    const chordProgression = (analysis.chords ?? [])
      .map((c: { chord: string; time: number; duration: number }) =>
        `${c.chord} (${formatTime(c.time)}, ${c.duration.toFixed(1)}s)`
      )
      .join(" | ");

    // Note range
    const notes = analysis.notes ?? [];
    const midiValues = notes.map((n: { midi: number }) => n.midi);
    const minNote = midiValues.length > 0 ? midiToNote(Math.min(...midiValues)) : "N/A";
    const maxNote = midiValues.length > 0 ? midiToNote(Math.max(.

midiToNote function · typescript · L28-L30 (3 LOC)

src/app/api/analysis/summarize/route.ts

    function midiToNote(midi: number): string {
      return `${NOTE_NAMES[midi % 12]}${Math.floor(midi / 12) - 1}`;
    }

formatTime function · typescript · L88-L92 (5 LOC)

src/app/api/analysis/summarize/route.ts

function formatTime(seconds: number): string {
  const m = Math.floor(seconds / 60);
  const s = Math.floor(seconds % 60);
  return `${m}:${s.toString().padStart(2, "0")}`;
}

resolveFfmpegPath function · typescript · L9-L17 (9 LOC)

src/app/api/audio/[id]/route.ts

function resolveFfmpegPath(): string {
  if (process.env.FFMPEG_PATH) return process.env.FFMPEG_PATH;
  try {
    // eslint-disable-next-line @typescript-eslint/no-require-imports
    const p = require("ffmpeg-static");
    if (p) return p;
  } catch { /* ignore */ }
  return "ffmpeg";
}

isALAC function · typescript · L21-L29 (9 LOC)

src/app/api/audio/[id]/route.ts

function isALAC(bytes: Uint8Array): boolean {
  const searchLen = Math.min(bytes.length, 500000);
  for (let i = 0; i < searchLen - 3; i++) {
    if (bytes[i] === 0x61 && bytes[i+1] === 0x6c && bytes[i+2] === 0x61 && bytes[i+3] === 0x63) {
      return true;
    }
  }
  return false;
}

transcodeToAAC function · typescript · L31-L63 (33 LOC)

src/app/api/audio/[id]/route.ts

async function transcodeToAAC(inputBuffer: ArrayBuffer): Promise<Buffer> {
  const dir = await mkdtemp(join(tmpdir(), "audio-"));
  const inputPath = join(dir, "input.m4a");
  const outputPath = join(dir, "output.m4a");

  try {
    await writeFile(inputPath, Buffer.from(inputBuffer));
    await access(ffmpegPath).catch(() => {
      throw new Error(`ffmpeg not found at: ${ffmpegPath}`);
    });

    await new Promise<void>((resolve, reject) => {
      execFile(
        ffmpegPath,
        ["-i", inputPath, "-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart", "-y", outputPath],
        { timeout: 120000 },
        (error, _stdout, stderr) => {
          if (error) {
            console.error("[TRANSCODE] ffmpeg error:", error.message, stderr);
            reject(error);
          } else {
            resolve();
          }
        }
      );
    });

    return await readFile(outputPath);
  } finally {
    await unlink(inputPath).catch(() => {});
    await unlink(outputPath).catch

resolveRecording function · typescript · L74-L98 (25 LOC)

src/app/api/audio/[id]/route.ts

async function resolveRecording(id: string) {
  const supabase = await createClient();
  const { data } = await supabase
    .from("recordings")
    .select(RECORDING_COLUMNS)
    .eq("id", id)
    .single();

  if (data) return { recording: data as RecordingRow, client: supabase, owned: true };

  // Fallback for shared recordings
  const anonClient = createAnonClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
  );
  const { data: shared } = await anonClient
    .from("recordings")
    .select(RECORDING_COLUMNS)
    .eq("id", id)
    .not("share_token", "is", null)
    .single();

  if (shared) return { recording: shared as RecordingRow, client: anonClient, owned: false };
  return null;
}

GET function · typescript · L102-L211 (110 LOC)

src/app/api/audio/[id]/route.ts

export async function GET(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  const { id } = await params;
  const result = await resolveRecording(id);

  if (!result) {
    return NextResponse.json({ error: "Recording not found" }, { status: 404 });
  }

  const { recording, client } = result;

  // Check query param to know if client needs transcoded version
  const needsTranscode = request.nextUrl.searchParams.get("transcode") === "1";

  if (!needsTranscode) {
    // If a persisted AAC transcode exists, serve that instead of the original
    const fileToSign = recording.aac_file_name ?? recording.file_name;

    const { data: signedData } = await client.storage
      .from("recordings")
      .createSignedUrl(fileToSign, 3600);

    if (signedData?.signedUrl) {
      return NextResponse.json({
        url: signedData.signedUrl,
        codec: recording.aac_file_name ? "aac" : (recording.audio_codec ?? null),
        hasAac: !!recording.aac_file_name,

PATCH function · typescript · L213-L252 (40 LOC)

src/app/api/audio/[id]/route.ts

export async function PATCH(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  const { id } = await params;
  const supabase = await createClient();

  // Verify the user owns this recording
  const { data: recording } = await supabase
    .from("recordings")
    .select("id")
    .eq("id", id)
    .single();

  if (!recording) {
    return NextResponse.json({ error: "Recording not found" }, { status: 404 });
  }

  const body = await request.json();

  // Save waveform peaks (and optionally duration)
  if (body.waveform_peaks) {
    const updates: Record<string, unknown> = { waveform_peaks: body.waveform_peaks };
    if (typeof body.duration === "number" && body.duration > 0) {
      updates.duration = body.duration;
    }

    const { error } = await supabase
      .from("recordings")
      .update(updates)
      .eq("id", id);

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

POST function · typescript · L5-L22 (18 LOC)

src/app/api/chat/compare/route.ts

export async function POST(request: Request) {
  const { messages, analysisA, analysisB, titleA, titleB } = await request.json();

  const systemPrompt = buildCompareSystemPrompt(
    titleA,
    analysisA,
    titleB,
    analysisB
  );

  const result = streamText({
    model: defaultModel,
    system: systemPrompt,
    messages,
  });

  return result.toDataStreamResponse();
}

POST function · typescript · L5-L24 (20 LOC)

src/app/api/chat/insights/route.ts

export async function POST(request: Request) {
  const { messages, analyses } = await request.json();

  const systemPrompt = buildInsightsSystemPrompt(
    analyses.map((a: { title: string; key_signature: string | null; tempo: number | null; chords: { chord: string }[] }) => ({
      recording_title: a.title,
      key_signature: a.key_signature,
      tempo: a.tempo,
      chords: a.chords,
    }))
  );

  const result = streamText({
    model: defaultModel,
    system: systemPrompt,
    messages,
  });

  return result.toDataStreamResponse();
}

POST function · typescript · L6-L49 (44 LOC)

src/app/api/chat/route.ts

export async function POST(request: Request) {
  try {
    const { messages, recordingId, analysis } = await request.json();

    if (!messages || !Array.isArray(messages)) {
      return new Response("Invalid messages format", { status: 400 });
    }

    const systemPrompt = buildRecordingSystemPrompt(analysis);

    const result = streamText({
      model: defaultModel,
      system: systemPrompt,
      messages: messages.map((m: { role: string; content: string }) => ({
        role: m.role as "user" | "assistant",
        content: m.content,
      })),
    });

    // Fire-and-forget: save user message without blocking the stream
    const lastUserMessage = messages[messages.length - 1];
    if (lastUserMessage?.role === "user") {
      createClient().then(async (supabase) => {
        const { data: { user } } = await supabase.auth.getUser();
        if (user) {
          await supabase.from("chat_messages").insert({
            recording_id: recordingId,
            user_id: user.

POST function · typescript · L19-L58 (40 LOC)

src/app/api/insights/summarize/route.ts

export async function POST(request: Request) {
  try {
    const { analyses } = await request.json();

    if (!analyses || !Array.isArray(analyses) || analyses.length === 0) {
      return Response.json({ error: "No analyses provided" }, { status: 400 });
    }

    const recordingSummaries = analyses.map((a: {
      title: string;
      key_signature: string | null;
      tempo: number | null;
      chords: { chord: string }[];
    }) => {
      const uniqueChords = [...new Set(a.chords.map((c) => c.chord))];
      return `- "${a.title}" — Key: ${a.key_signature ?? "?"}, Tempo: ${a.tempo ? `~${a.tempo} BPM` : "?"}, Chords: ${uniqueChords.slice(0, 10).join(", ")}`;
    }).join("\n");

    const prompt = `Analyze this library of ${analyses.length} piano voice memo recordings and generate insights.

## Recordings
${recordingSummaries}

Group similar recordings into clusters based on shared musical characteristics (key, chord vocabulary, tempo, style). Identify any standout recordings th

getCreationDate function · typescript · L6-L58 (53 LOC)

src/app/api/recordings/fix-dates/route.ts

function getCreationDate(buf: ArrayBuffer): Date | null {
  const view = new DataView(buf);

  // Scan top-level atoms to find moov
  let offset = 0;
  while (offset + 8 <= view.byteLength) {
    let size = view.getUint32(offset);
    const type = String.fromCharCode(
      view.getUint8(offset + 4), view.getUint8(offset + 5),
      view.getUint8(offset + 6), view.getUint8(offset + 7)
    );

    // Handle 64-bit extended size (size field = 1)
    let headerSize = 8;
    if (size === 1 && offset + 16 <= view.byteLength) {
      const hi = view.getUint32(offset + 8);
      const lo = view.getUint32(offset + 12);
      size = hi * 4294967296 + lo;
      headerSize = 16;
    }

    if (size < 8) break;

    if (type === "moov") {
      const end = Math.min(offset + size, view.byteLength);
      let inner = offset + headerSize;
      while (inner + 20 <= end) {
        const atomSize = view.getUint32(inner);
        const atomType = String.fromCharCode(
          view.getUint8(inner + 4),

All rows above produced by Repobility · https://repobility.com

POST function · typescript · L60-L108 (49 LOC)

src/app/api/recordings/fix-dates/route.ts

export async function POST() {
  const supabase = await createClient();
  const { data: { user } } = await supabase.auth.getUser();
  if (!user) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  const { data: recordings, error } = await supabase
    .from("recordings")
    .select("id, file_name, recorded_at")
    .eq("user_id", user.id);

  if (error || !recordings) {
    return NextResponse.json({ error: "Failed to fetch recordings" }, { status: 500 });
  }

  const results = [];

  for (const rec of recordings) {
    const { data: fileData, error: dlError } = await supabase.storage
      .from("recordings")
      .download(rec.file_name);

    if (dlError || !fileData) {
      results.push({ id: rec.id, file: rec.file_name, oldDate: rec.recorded_at, newDate: null, error: dlError?.message });
      continue;
    }

    const buf = await fileData.arrayBuffer();
    const creationDate = getCreationDate(buf);

    if (creationDate) {
      const newDate

GET function · typescript · L4-L22 (19 LOC)

src/app/api/recordings/[id]/analysis/route.ts

export async function GET(
  _request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  const { id } = await params;
  const supabase = await createClient();

  const { data, error } = await supabase
    .from("analyses")
    .select("*")
    .eq("recording_id", id)
    .single();

  if (error) {
    return NextResponse.json({ error: error.message }, { status: 404 });
  }

  return NextResponse.json(data);
}

POST function · typescript · L24-L49 (26 LOC)

src/app/api/recordings/[id]/analysis/route.ts

export async function POST(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  const { id } = await params;
  const supabase = await createClient();
  const body = await request.json();

  const { data, error } = await supabase
    .from("analyses")
    .upsert(
      {
        recording_id: id,
        ...body,
      },
      { onConflict: "recording_id" }
    )
    .select()
    .single();

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

  return NextResponse.json(data);
}

CollectionDetailLoading function · typescript · L1-L25 (25 LOC)

src/app/(app)/collections/[id]/loading.tsx

export default function CollectionDetailLoading() {
  return (
    <div className="space-y-6 animate-pulse">
      <div>
        <div className="h-8 w-48 rounded bg-muted" />
        <div className="mt-2 h-4 w-32 rounded bg-muted" />
      </div>

      <div className="space-y-3">
        {Array.from({ length: 4 }).map((_, i) => (
          <div
            key={i}
            className="flex items-center gap-4 rounded-xl border bg-card px-6 py-4"
          >
            <div className="h-10 w-10 shrink-0 rounded-lg bg-muted" />
            <div className="flex-1 space-y-2">
              <div className="h-4 w-48 rounded bg-muted" />
              <div className="h-3 w-32 rounded bg-muted" />
            </div>
          </div>
        ))}
      </div>
    </div>
  );
}

CollectionPage function · typescript · L5-L57 (53 LOC)

src/app/(app)/collections/[id]/page.tsx

export default async function CollectionPage({
  params,
}: {
  params: Promise<{ id: string }>;
}) {
  const { id } = await params;
  const supabase = await createClient();

  const { data: collection } = await supabase
    .from("collections")
    .select("*")
    .eq("id", id)
    .single();

  if (!collection) notFound();

  // Get recordings in this collection
  const { data: items } = await supabase
    .from("collection_recordings")
    .select("position, recording:recordings(id, title, duration, created_at)")
    .eq("collection_id", id)
    .order("position");

  const recordings = (items ?? [])
    .map((item) => ({
      position: item.position,
      ...(item.recording as unknown as { id: string; title: string; duration: number | null; created_at: string }),
    }))
    .filter((r) => r.id);

  // Get ALL user recordings to power the "add recording" picker
  const { data: allRecordings } = await supabase
    .from("recordings")
    .select("id, title, duration, created_at")

CollectionsLoading function · typescript · L1-L19 (19 LOC)

src/app/(app)/collections/loading.tsx

export default function CollectionsLoading() {
  return (
    <div className="space-y-6 animate-pulse">
      <div className="flex items-center justify-between">
        <div className="h-8 w-40 rounded bg-muted" />
        <div className="h-9 w-32 rounded bg-muted" />
      </div>

      <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
        {Array.from({ length: 6 }).map((_, i) => (
          <div key={i} className="rounded-xl border bg-card p-6 space-y-3">
            <div className="h-5 w-32 rounded bg-muted" />
            <div className="h-3 w-20 rounded bg-muted" />
          </div>
        ))}
      </div>
    </div>
  );
}

CollectionsPage function · typescript · L7-L59 (53 LOC)

src/app/(app)/collections/page.tsx

export default async function CollectionsPage() {
  const supabase = await createClient();

  const { data: collections } = await supabase
    .from("collections")
    .select("*, collection_recordings(count)")
    .order("created_at", { ascending: false });

  return (
    <div className="space-y-6">
      <div className="flex items-center justify-between">
        <div>
          <h1 className="text-2xl font-bold">Collections</h1>
          <p className="text-muted-foreground">
            Organize recordings into themed collections
          </p>
        </div>
        <CreateCollectionDialog />
      </div>

      {collections && collections.length > 0 ? (
        <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
          {collections.map((collection) => (
            <Link key={collection.id} href={`/collections/${collection.id}`}>
              <Card className="cursor-pointer transition-colors hover:bg-accent/50">
                <CardHeader className="pb-2">

formatDuration function · typescript · L32-L36 (5 LOC)