458 lines
17 KiB
JavaScript
458 lines
17 KiB
JavaScript
import express from "express";
|
|
import path from "path";
|
|
import { Readable } from "node:stream";
|
|
import {
|
|
fetchCommits,
|
|
fetchManifest,
|
|
fetchRepo,
|
|
fetchReleases,
|
|
normalizeRepoInput,
|
|
parseRepoEntry,
|
|
readRepos
|
|
} from "./lib/pluginService.js";
|
|
import {
|
|
buildLicensePayload,
|
|
createLicense,
|
|
findLicenseByKey,
|
|
getLicenseById,
|
|
listLicensesByUser,
|
|
touchLicenseHostname
|
|
} from "./lib/licenseService.js";
|
|
import { HOST, PATHS, PORT } from "./lib/config.js";
|
|
import { ensureSchema } from "./lib/schema.js";
|
|
import { authenticateUser, registerUser, adminCreateUser, listUsers, getUserById } from "./lib/userService.js";
|
|
import { requireAuth, requireAdmin } from "./middleware/auth.js";
|
|
import { getDownloadSourceForLicense, resolveRepoDownload, buildDownloadUrl } from "./lib/downloadService.js";
|
|
|
|
const app = express();
|
|
app.use(express.json());
|
|
|
|
try {
|
|
await ensureSchema();
|
|
} catch (error) {
|
|
console.error("Kon database schema niet initialiseren:", error);
|
|
process.exit(1);
|
|
}
|
|
|
|
app.post("/api/auth/register", async (req, res) => {
|
|
try {
|
|
const { username, name, email, password } = req.body || {};
|
|
if (!username || !name || !email || !password) {
|
|
return res.status(400).json({ error: "Vul gebruikersnaam, naam, e-mail en wachtwoord in." });
|
|
}
|
|
if (password.length < 8) {
|
|
return res.status(400).json({ error: "Wachtwoord moet minimaal 8 karakters zijn." });
|
|
}
|
|
const { user, token } = await registerUser({
|
|
username: String(username).trim(),
|
|
name: String(name).trim(),
|
|
email: String(email).trim().toLowerCase(),
|
|
password: String(password)
|
|
});
|
|
res.status(201).json({ token, user });
|
|
} catch (error) {
|
|
if (error?.code === "ER_DUP_ENTRY") {
|
|
const field = error.meta === "EMAIL" ? "e-mailadres" : "gebruikersnaam";
|
|
return res.status(409).json({ error: `Dit ${field} is al in gebruik.` });
|
|
}
|
|
res.status(500).json({ error: "Registratie mislukt." });
|
|
}
|
|
});
|
|
|
|
app.post("/api/auth/login", async (req, res) => {
|
|
try {
|
|
const { identifier, password } = req.body || {};
|
|
if (!identifier || !password) {
|
|
return res.status(400).json({ error: "Vul gebruikersnaam/e-mail en wachtwoord in." });
|
|
}
|
|
const { user, token } = await authenticateUser(String(identifier).trim(), String(password));
|
|
res.json({ token, user });
|
|
} catch (error) {
|
|
const message = error?.meta === "INVALID_CREDENTIALS" ? "Onjuiste inloggegevens." : "Login mislukt.";
|
|
res.status(401).json({ error: message });
|
|
}
|
|
});
|
|
|
|
app.get("/api/auth/me", requireAuth, (req, res) => {
|
|
res.json({ user: req.user });
|
|
});
|
|
|
|
app.get("/api/admin/users", requireAuth, requireAdmin, async (_req, res) => {
|
|
try {
|
|
const users = await listUsers();
|
|
res.json({ count: users.length, items: users });
|
|
} catch (error) {
|
|
res.status(500).json({ error: "Kon gebruikers niet laden." });
|
|
}
|
|
});
|
|
|
|
app.post("/api/admin/users", requireAuth, requireAdmin, async (req, res) => {
|
|
try {
|
|
const { username, name, email, password, isAdmin } = req.body || {};
|
|
if (!username || !name || !email || !password) {
|
|
return res.status(400).json({ error: "Alle velden zijn verplicht." });
|
|
}
|
|
if (String(password).length < 8) {
|
|
return res.status(400).json({ error: "Wachtwoord moet minimaal 8 karakters zijn." });
|
|
}
|
|
const user = await adminCreateUser({
|
|
username: String(username).trim(),
|
|
name: String(name).trim(),
|
|
email: String(email).trim().toLowerCase(),
|
|
password: String(password),
|
|
isAdmin: Boolean(isAdmin)
|
|
});
|
|
res.status(201).json({ user });
|
|
} catch (error) {
|
|
if (error?.code === "ER_DUP_ENTRY") {
|
|
const field = error.meta === "EMAIL" ? "e-mailadres" : "gebruikersnaam";
|
|
return res.status(409).json({ error: `Dit ${field} is al in gebruik.` });
|
|
}
|
|
res.status(500).json({ error: "Gebruiker aanmaken mislukt." });
|
|
}
|
|
});
|
|
|
|
app.get("/api/plugins", async (_req, res) => {
|
|
try {
|
|
const repos = await readRepos(PATHS.reposFile);
|
|
const results = await Promise.all(
|
|
repos.map(async (repo) => {
|
|
try {
|
|
const info = await fetchRepo(repo);
|
|
const manifest = await fetchManifest(repo, info.defaultBranch || info.default_branch);
|
|
return { ...info, manifest };
|
|
} catch {
|
|
const parsed = parseRepoEntry(repo);
|
|
return {
|
|
fullName: parsed.ownerRepo,
|
|
name: parsed.ownerRepo.split("/")[1] || parsed.ownerRepo,
|
|
description: "Kon gegevens niet ophalen.",
|
|
repoUrl:
|
|
parsed.provider === "gitea"
|
|
? `${parsed.baseUrl.replace(/\/$/, "")}/${parsed.ownerRepo}`
|
|
: `https://github.com/${parsed.ownerRepo}`,
|
|
stars: 0,
|
|
forks: 0,
|
|
issues: 0,
|
|
updatedAt: null,
|
|
topics: [],
|
|
manifest: null,
|
|
provider: parsed.provider,
|
|
ownerRepo: parsed.ownerRepo,
|
|
baseUrl: parsed.baseUrl
|
|
};
|
|
}
|
|
})
|
|
);
|
|
|
|
res.json({
|
|
count: results.length,
|
|
updatedAt: new Date().toISOString(),
|
|
items: results
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({ error: "Kon plugins niet laden." });
|
|
}
|
|
});
|
|
|
|
function buildPluginDownloadEndpoint(ownerRepo, { provider, baseUrl, version } = {}) {
|
|
const [owner, repo] = ownerRepo.split("/");
|
|
if (!owner || !repo) {
|
|
return null;
|
|
}
|
|
const params = new URLSearchParams();
|
|
if (provider) {
|
|
params.set("provider", provider);
|
|
}
|
|
if (baseUrl) {
|
|
params.set("baseUrl", baseUrl);
|
|
}
|
|
if (version) {
|
|
params.set("version", version);
|
|
}
|
|
const search = params.toString();
|
|
return `/api/plugins/${owner}/${repo}/download${search ? `?${search}` : ""}`;
|
|
}
|
|
|
|
app.get("/api/plugins/:owner/:repo", async (req, res) => {
|
|
const ownerRepo = `${req.params.owner}/${req.params.repo}`;
|
|
try {
|
|
const provider = (req.query.provider || "github").toLowerCase();
|
|
const baseUrlQuery = req.query.baseUrl || (provider === "github" ? "https://github.com" : "");
|
|
const entry = provider === "github" ? ownerRepo : { provider, repo: ownerRepo, baseUrl: baseUrlQuery };
|
|
const normalizedEntry = normalizeRepoInput(entry, { repo: ownerRepo, provider, baseUrl: baseUrlQuery });
|
|
|
|
const info = await fetchRepo(entry);
|
|
const [manifest, releases, commits] = await Promise.all([
|
|
fetchManifest(entry, info.defaultBranch).catch(() => null),
|
|
fetchReleases(entry).catch(() => []),
|
|
fetchCommits(entry).catch(() => [])
|
|
]);
|
|
|
|
const effectiveBaseUrl =
|
|
normalizedEntry?.baseUrl ||
|
|
baseUrlQuery ||
|
|
info.baseUrl ||
|
|
(provider === "github" ? "https://github.com" : "");
|
|
|
|
const releasesWithDownload =
|
|
normalizedEntry && releases.length > 0
|
|
? releases.map((release) => {
|
|
const tagOrName = release.tag || release.name;
|
|
if (!tagOrName) {
|
|
return release;
|
|
}
|
|
const endpoint = buildPluginDownloadEndpoint(ownerRepo, {
|
|
provider,
|
|
baseUrl: effectiveBaseUrl,
|
|
version: tagOrName
|
|
});
|
|
return {
|
|
...release,
|
|
downloadUrl: endpoint,
|
|
sourceDownloadUrl: buildDownloadUrl(normalizedEntry, tagOrName, "release")
|
|
};
|
|
})
|
|
: releases;
|
|
|
|
let downloadMeta = null;
|
|
if (normalizedEntry) {
|
|
const latestRelease = releasesWithDownload[0];
|
|
const sourceType = latestRelease ? "release" : "branch";
|
|
const version = latestRelease?.tag || latestRelease?.name || info.defaultBranch || "main";
|
|
if (version) {
|
|
const endpoint = buildPluginDownloadEndpoint(ownerRepo, {
|
|
provider,
|
|
baseUrl: effectiveBaseUrl,
|
|
version
|
|
});
|
|
downloadMeta = {
|
|
url: endpoint,
|
|
sourceUrl: buildDownloadUrl(normalizedEntry, version, sourceType),
|
|
version,
|
|
sourceType
|
|
};
|
|
}
|
|
}
|
|
|
|
res.json({
|
|
...info,
|
|
manifest,
|
|
releases: releasesWithDownload,
|
|
download: downloadMeta,
|
|
commits
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({ error: "Kon plugin details niet laden." });
|
|
}
|
|
});
|
|
|
|
app.get("/api/plugins/:owner/:repo/download", async (req, res) => {
|
|
const ownerRepo = `${req.params.owner}/${req.params.repo}`;
|
|
try {
|
|
const provider = (req.query.provider || "github").toLowerCase();
|
|
const baseUrl = req.query.baseUrl || undefined;
|
|
const version = req.query.version || "latest";
|
|
|
|
if (provider === "gitea" && !baseUrl) {
|
|
return res.status(400).json({ error: "Gitea downloads vereisen een baseUrl." });
|
|
}
|
|
|
|
const repoEntry = normalizeRepoInput(
|
|
{ repo: ownerRepo, provider, baseUrl },
|
|
{ repo: ownerRepo, provider, baseUrl }
|
|
);
|
|
|
|
if (!repoEntry) {
|
|
return res.status(400).json({ error: "Ongeldige repository." });
|
|
}
|
|
|
|
const source = await resolveRepoDownload(repoEntry, version);
|
|
const remoteResponse = await fetch(source.url);
|
|
if (!remoteResponse.ok || !remoteResponse.body) {
|
|
return res.status(502).json({ error: "Kon plugin versie niet downloaden." });
|
|
}
|
|
|
|
res.setHeader("Content-Type", remoteResponse.headers.get("content-type") || "application/zip");
|
|
const length = remoteResponse.headers.get("content-length");
|
|
if (length) {
|
|
res.setHeader("Content-Length", length);
|
|
}
|
|
res.setHeader("Content-Disposition", `attachment; filename="${source.filename}"`);
|
|
res.setHeader("X-Plugin-Version", source.version);
|
|
|
|
const stream = Readable.fromWeb(remoteResponse.body);
|
|
stream.on("error", (err) => {
|
|
console.error("Plugin download stream error:", err);
|
|
res.destroy(err);
|
|
});
|
|
stream.pipe(res);
|
|
} catch (error) {
|
|
console.error("Plugin download endpoint error:", error);
|
|
if (!res.headersSent) {
|
|
res.status(500).json({ error: "Download mislukt." });
|
|
} else {
|
|
res.end();
|
|
}
|
|
}
|
|
});
|
|
|
|
app.get("/api/licenses", requireAuth, async (req, res) => {
|
|
try {
|
|
let targetUserId = req.user.id;
|
|
if (req.user.isAdmin && req.query.userId) {
|
|
const parsed = Number(req.query.userId);
|
|
if (Number.isNaN(parsed)) {
|
|
return res.status(400).json({ error: "Ongeldige userId." });
|
|
}
|
|
const targetUser = await getUserById(parsed);
|
|
if (!targetUser) {
|
|
return res.status(404).json({ error: "Gebruiker niet gevonden." });
|
|
}
|
|
targetUserId = parsed;
|
|
}
|
|
const payload = await listLicensesByUser(targetUserId);
|
|
res.json({
|
|
count: payload.length,
|
|
updatedAt: new Date().toISOString(),
|
|
items: payload
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({ error: "Kon licenties niet laden." });
|
|
}
|
|
});
|
|
|
|
app.post("/api/licenses", requireAuth, async (req, res) => {
|
|
try {
|
|
const body = req.body || {};
|
|
const repoInput =
|
|
typeof body.repo === "object"
|
|
? body.repo
|
|
: typeof body.plugin === "object"
|
|
? body.plugin
|
|
: body.repo || body.ownerRepo || body.fullName || body.plugin;
|
|
const repoEntry =
|
|
normalizeRepoInput(repoInput, {
|
|
repo: body.ownerRepo || body.fullName || body.repo,
|
|
provider: body.provider,
|
|
baseUrl: body.baseUrl
|
|
}) || null;
|
|
|
|
if (!repoEntry) {
|
|
return res.status(400).json({ error: "Kies een plugin om de licentie aan te koppelen." });
|
|
}
|
|
|
|
try {
|
|
await fetchRepo(repoEntry);
|
|
} catch (error) {
|
|
return res.status(400).json({ error: "Kon plugin gegevens niet ophalen." });
|
|
}
|
|
|
|
let ownerUserId = req.user.id;
|
|
if (req.user.isAdmin && body.userId) {
|
|
const parsed = Number(body.userId);
|
|
if (Number.isNaN(parsed)) {
|
|
return res.status(400).json({ error: "Ongeldige gebruiker." });
|
|
}
|
|
const target = await getUserById(parsed);
|
|
if (!target) {
|
|
return res.status(404).json({ error: "Gebruiker niet gevonden." });
|
|
}
|
|
ownerUserId = parsed;
|
|
}
|
|
|
|
const payload = await createLicense(ownerUserId, {
|
|
label: body.label?.trim(),
|
|
note: body.note?.trim(),
|
|
repo: repoEntry
|
|
});
|
|
res.status(201).json(payload);
|
|
} catch (error) {
|
|
res.status(500).json({ error: "Kon licentie niet aanmaken." });
|
|
}
|
|
});
|
|
|
|
app.post("/api/licenses/verify", async (req, res) => {
|
|
try {
|
|
const { key, hostname } = req.body || {};
|
|
if (!key || !hostname) {
|
|
return res.status(400).json({ valid: false, error: "Licentiecode en hostname zijn verplicht." });
|
|
}
|
|
const license = await findLicenseByKey(String(key).trim());
|
|
if (!license) {
|
|
return res.status(404).json({ valid: false, error: "Licentie niet gevonden." });
|
|
}
|
|
|
|
const result = await touchLicenseHostname(license, hostname);
|
|
if (!result.ok) {
|
|
const status = result.conflict ? 403 : 400;
|
|
return res.status(status).json({ valid: false, error: result.error, boundHostname: license.primary_hostname });
|
|
}
|
|
|
|
const freshLicense = await getLicenseById(license.id);
|
|
const payload = await buildLicensePayload(freshLicense);
|
|
res.json({
|
|
valid: true,
|
|
hostname: payload.primaryHostname,
|
|
boundNow: !!result.boundNow,
|
|
license: payload
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({ valid: false, error: "Validatie mislukt." });
|
|
}
|
|
});
|
|
|
|
app.post("/api/licenses/download", async (req, res) => {
|
|
try {
|
|
const { key, hostname, version = "latest" } = req.body || {};
|
|
if (!key || !hostname) {
|
|
return res.status(400).json({ error: "Licentiecode en hostname zijn verplicht." });
|
|
}
|
|
const license = await findLicenseByKey(String(key).trim());
|
|
if (!license) {
|
|
return res.status(404).json({ error: "Licentie niet gevonden." });
|
|
}
|
|
const result = await touchLicenseHostname(license, hostname);
|
|
if (!result.ok) {
|
|
const status = result.conflict ? 403 : 400;
|
|
return res.status(status).json({ error: result.error, boundHostname: license.primary_hostname });
|
|
}
|
|
const source = await getDownloadSourceForLicense(license, version);
|
|
const remoteResponse = await fetch(source.url);
|
|
if (!remoteResponse.ok || !remoteResponse.body) {
|
|
return res.status(502).json({ error: "Kon plugin versie niet ophalen." });
|
|
}
|
|
|
|
res.setHeader("Content-Type", remoteResponse.headers.get("content-type") || "application/zip");
|
|
const length = remoteResponse.headers.get("content-length");
|
|
if (length) {
|
|
res.setHeader("Content-Length", length);
|
|
}
|
|
res.setHeader("Content-Disposition", `attachment; filename=\"${source.filename}\"`);
|
|
res.setHeader("X-Plugin-Version", source.version);
|
|
|
|
const stream = Readable.fromWeb(remoteResponse.body);
|
|
stream.on("error", (err) => {
|
|
console.error("Download stream error", err);
|
|
res.destroy(err);
|
|
});
|
|
stream.pipe(res);
|
|
} catch (error) {
|
|
console.error("Download endpoint error:", error);
|
|
if (!res.headersSent) {
|
|
res.status(500).json({ error: "Download mislukt." });
|
|
} else {
|
|
res.end();
|
|
}
|
|
}
|
|
});
|
|
|
|
app.use(express.static(PATHS.distDir));
|
|
app.get("*", (_req, res) => {
|
|
res.sendFile(path.join(PATHS.distDir, "index.html"));
|
|
});
|
|
|
|
app.listen(PORT, HOST, () => {
|
|
console.log(`Server draait op http://${HOST}:${PORT}`);
|
|
});
|