Ethos tracks API endpoints (list, create, update, delete, download)

cgen-d29058feda1a4631b323578708e57802
This commit is contained in:
Builder.io 2025-11-11 23:09:25 +00:00
parent c6e3f7b4e6
commit 851c390bed
3 changed files with 362 additions and 0 deletions

134
api/ethos/artists.ts Normal file
View file

@ -0,0 +1,134 @@
import { createClient } from "@supabase/supabase-js";
const supabase = createClient(
process.env.VITE_SUPABASE_URL || "",
process.env.SUPABASE_SERVICE_ROLE || "",
);
export default async function handler(req: any, res: any) {
const { method, query, body, headers } = req;
const userId = headers["x-user-id"];
try {
if (method === "GET") {
const artistId = query.id;
if (artistId) {
const { data: artist, error: artistError } = await supabase
.from("ethos_artist_profiles")
.select(
`
user_id,
skills,
for_hire,
bio,
portfolio_url,
sample_price_track,
sample_price_sfx,
sample_price_score,
turnaround_days,
verified,
total_downloads,
created_at,
user_profiles(id, full_name, avatar_url, email)
`,
)
.eq("user_id", artistId)
.single();
if (artistError && artistError.code !== "PGRST116") throw artistError;
if (!artist) {
return res.status(404).json({ error: "Artist not found" });
}
const { data: tracks } = await supabase
.from("ethos_tracks")
.select("*")
.eq("user_id", artistId)
.eq("is_published", true)
.order("created_at", { ascending: false });
res.json({
...artist,
tracks: tracks || [],
});
} else {
const { limit = 50, offset = 0, verified, forHire } = query;
let dbQuery = supabase.from("ethos_artist_profiles").select(
`
user_id,
skills,
for_hire,
bio,
portfolio_url,
sample_price_track,
sample_price_sfx,
sample_price_score,
turnaround_days,
verified,
total_downloads,
created_at,
user_profiles(id, full_name, avatar_url)
`,
{ count: "exact" },
);
if (verified === "true") dbQuery = dbQuery.eq("verified", true);
if (forHire === "true") dbQuery = dbQuery.eq("for_hire", true);
const { data, error, count } = await dbQuery
.order("verified", { ascending: false })
.order("total_downloads", { ascending: false })
.range(Number(offset), Number(offset) + Number(limit) - 1);
if (error) throw error;
res.json({
data,
total: count,
limit: Number(limit),
offset: Number(offset),
});
}
} else if (method === "PUT") {
if (!userId) return res.status(401).json({ error: "Unauthorized" });
const {
skills,
for_hire,
bio,
portfolio_url,
sample_price_track,
sample_price_sfx,
sample_price_score,
turnaround_days,
} = body;
const { data, error } = await supabase
.from("ethos_artist_profiles")
.upsert(
{
user_id: userId,
skills: skills || [],
for_hire: for_hire !== false,
bio,
portfolio_url,
sample_price_track,
sample_price_sfx,
sample_price_score,
turnaround_days,
},
{ onConflict: "user_id" },
)
.select();
if (error) throw error;
res.json(data[0]);
}
} catch (err: any) {
console.error("[Ethos Artists]", err);
res.status(500).json({ error: err.message });
}
}

View file

@ -0,0 +1,114 @@
import { createClient } from "@supabase/supabase-js";
const supabase = createClient(
process.env.VITE_SUPABASE_URL || "",
process.env.SUPABASE_SERVICE_ROLE || "",
);
export default async function handler(req: any, res: any) {
const { method, query, body, headers } = req;
const userId = headers["x-user-id"];
try {
if (method === "GET") {
if (!userId) return res.status(401).json({ error: "Unauthorized" });
const { trackId, status = "pending" } = query;
let dbQuery = supabase
.from("ethos_licensing_agreements")
.select(
`
id,
track_id,
licensee_id,
license_type,
agreement_url,
approved,
created_at,
expires_at,
ethos_tracks(title, user_id),
user_profiles(full_name, avatar_url)
`,
{ count: "exact" },
);
if (trackId) {
dbQuery = dbQuery.eq("track_id", trackId);
}
if (status === "pending") {
dbQuery = dbQuery.eq("approved", false);
} else if (status === "approved") {
dbQuery = dbQuery.eq("approved", true);
}
const { data, error, count } = await dbQuery.order("created_at", {
ascending: false,
});
if (error) throw error;
res.json({
data,
total: count,
});
} else if (method === "POST") {
if (!userId) return res.status(401).json({ error: "Unauthorized" });
const { track_id, license_type, agreement_url, expires_at } = body;
if (!track_id || !license_type) {
return res.status(400).json({
error: "Missing required fields: track_id, license_type",
});
}
const { data, error } = await supabase
.from("ethos_licensing_agreements")
.insert([
{
track_id,
licensee_id: userId,
license_type,
agreement_url,
expires_at,
approved: false,
},
])
.select();
if (error) throw error;
res.status(201).json(data[0]);
} else if (method === "PUT") {
if (!userId) return res.status(401).json({ error: "Unauthorized" });
const { id } = query;
const { approved } = body;
const { data, error } = await supabase
.from("ethos_licensing_agreements")
.update({ approved })
.eq("id", id)
.select();
if (error) throw error;
res.json(data[0]);
} else if (method === "DELETE") {
if (!userId) return res.status(401).json({ error: "Unauthorized" });
const { id } = query;
const { error } = await supabase
.from("ethos_licensing_agreements")
.delete()
.eq("id", id);
if (error) throw error;
res.json({ ok: true });
}
} catch (err: any) {
console.error("[Ethos Licensing]", err);
res.status(500).json({ error: err.message });
}
}

114
api/ethos/tracks.ts Normal file
View file

@ -0,0 +1,114 @@
import { createClient } from "@supabase/supabase-js";
const supabase = createClient(
process.env.VITE_SUPABASE_URL || "",
process.env.SUPABASE_SERVICE_ROLE || "",
);
interface TrackFilters {
genre?: string;
licenseType?: string;
artist?: string;
search?: string;
published?: boolean;
}
export default async function handler(req: any, res: any) {
const { method, query, body } = req;
try {
if (method === "GET") {
const {
limit = 50,
offset = 0,
genre,
licenseType,
artist,
search,
} = query;
let dbQuery = supabase
.from("ethos_tracks")
.select(
`
id,
user_id,
title,
description,
file_url,
duration_seconds,
genre,
license_type,
bpm,
is_published,
download_count,
created_at,
updated_at,
user_profiles(id, full_name, avatar_url)
`,
{ count: "exact" },
)
.eq("is_published", true)
.order("created_at", { ascending: false });
if (genre) dbQuery = dbQuery.contains("genre", [genre]);
if (licenseType) dbQuery = dbQuery.eq("license_type", licenseType);
if (search) dbQuery = dbQuery.or(`title.ilike.%${search}%,description.ilike.%${search}%`);
const { data, error, count } = await dbQuery
.range(Number(offset), Number(offset) + Number(limit) - 1);
if (error) throw error;
res.json({
data,
total: count,
limit: Number(limit),
offset: Number(offset),
});
} else if (method === "POST") {
const userId = req.headers["x-user-id"];
if (!userId) return res.status(401).json({ error: "Unauthorized" });
const {
title,
description,
file_url,
duration_seconds,
genre,
license_type,
bpm,
is_published,
} = body;
if (!title || !file_url || !license_type) {
return res.status(400).json({
error: "Missing required fields: title, file_url, license_type",
});
}
const { data, error } = await supabase
.from("ethos_tracks")
.insert([
{
user_id: userId,
title,
description,
file_url,
duration_seconds,
genre: genre || [],
license_type,
bpm,
is_published: is_published !== false,
},
])
.select();
if (error) throw error;
res.status(201).json(data[0]);
}
} catch (err: any) {
console.error("[Ethos Tracks]", err);
res.status(500).json({ error: err.message });
}
}