feat: add paid author and conference hosting with Stripe

This commit is contained in:
Thomas Durieux committed 2026-11-02 20:49:03 +00:00
1 parent b09ef0e5b0
commit 410863d253
54 files changed
+3263 -369

No files matched your search

+5
View File
@@ -1,3 +1,5 @@
import { startBillingMaintenance } from "../core/billing/maintenance";
import billing, { billingWebhook } from "./routes/billing";
import { githubAppRouter, githubAppWebhook } from "./routes/github-app";
import { config as dotenv } from "dotenv";
dotenv();
@@ -107,6 +109,7 @@ export default async function start() {
startPerformanceMonitoring("api", getAnonymizationPoolStats);
app.set("query parser", "extended");
app.use("/github/app/webhook", githubAppWebhook);
app.use("/api/billing/webhook", billingWebhook);
app.use(express.json());
// Preserve the empty body used by API validation when no JSON was parsed.
app.use((req, _res, next) => {
@@ -210,6 +213,7 @@ export default async function start() {
const apiRouter = express.Router();
app.use("/api", rate, apiRouter);
apiRouter.use("/billing", billing);
apiRouter.use("/admin", router.admin);
apiRouter.use("/options", router.option);
apiRouter.use("/conferences", router.conference);
@@ -300,6 +304,7 @@ export default async function start() {
dailyStatsSnapshot();
await connect();
await startBillingMaintenance();
await startTemporaryStorageMaintenance();
app.listen(config.PORT);
logger.info("server started", { port: config.PORT });
+114
View File
@@ -0,0 +1,114 @@
import * as express from "express";
import { randomBytes } from "crypto";
import { ensureAuthenticated } from "./connection";
import { getUser, handleError } from "./route-utils";
import config from "../../config";
import { BillingAccount, BillingGrant } from "../../core/billing/models";
import { billingOrigin, billingPlans, requireBilling } from "../../core/billing/config";
import { createCheckout, stripeClient, fulfillCheckout, syncSubscription } from "../../core/billing/stripe";
import { saveBillingDraft, getBillingDraft } from "../../core/billing/drafts";
import { allowance } from "../../core/billing/quotas";
import { receiveBillingEvent, billingFailure } from "../../core/billing/events";
import { createLogger } from "../../core/logger";
import { rateLimit } from "express-rate-limit";
declare module "express-session" { interface SessionData { billingCSRF?: string } }
export const billingWebhook = express.Router();
billingWebhook.post("/", express.raw({ type: "application/json", limit: "256kb" }), async (req, res) => {
if (!config.BILLING_ENABLED) { res.sendStatus(404); return; }
let event;
try { event = stripeClient().webhooks.constructEvent(req.body, req.headers["stripe-signature"] as string, config.STRIPE_WEBHOOK_SECRET); }
catch { res.status(400).json({ error: "invalid_billing_signature" }); return; }
if (event.account || (typeof event.livemode === "boolean" && event.livemode !== /^(sk|rk)_live_/.test(config.STRIPE_SECRET_KEY))) {
res.status(400).json({ error: "billing_environment_mismatch" }); return;
}
try { await receiveBillingEvent(event); res.json({ received: true }); }
catch (error) { createLogger("billing").error("billing event storage failed", { eventId: event.id, code: billingFailure(error) }); res.status(500).json({ error: "billing_webhook_failed" }); }
});
const priceCache = new Map<string, { expires: number; value: Awaited<ReturnType<ReturnType<typeof stripeClient>["prices"]["retrieve"]>> }>();
async function displayedPrice(id: string) {
const cached = priceCache.get(id);
if (cached && cached.expires > Date.now()) return cached.value;
const value = await stripeClient().prices.retrieve(id);
priceCache.set(id, { expires: Date.now() + 60_000, value });
return value;
}
const router = express.Router();
router.use(ensureAuthenticated);
router.get("/", async (req, res) => {
try {
const user = await getUser(req);
req.session.billingCSRF ||= randomBytes(32).toString("hex");
await new Promise<void>((resolve, reject) => req.session.save(error => error ? reject(error) : resolve()));
const account = await BillingAccount.findById(user.id).lean();
const grants = await BillingGrant.find({ owner: user.id }).select("planId scope status until cancelAtPeriodEnd revoked").lean();
const plans = config.BILLING_ENABLED ? await Promise.all(billingPlans().filter(p => p.priceId).map(async p => {
const price = await displayedPrice(p.priceId);
return { id: p.id, name: p.name, description: p.description, repositories: p.repositories, storage: p.storage,
amount: price.unit_amount, currency: price.currency, interval: price.recurring?.interval, intervalCount: price.recurring?.interval_count };
})) : [];
res.set("Cache-Control", "no-store").json({ enabled: config.BILLING_ENABLED, csrf: req.session.billingCSRF, plans, checkoutEnabled: config.BILLING_CHECKOUT_ENABLED,
grants: grants.map(g => ({ planId: g.planId, scope: g.scope, status: g.revoked ? "revoked" : g.status, until: g.until, cancelAtPeriodEnd: g.cancelAtPeriodEnd })),
portal: !!account?.customerId, allowance: config.BILLING_ENABLED ? await allowance(user.id) : null });
} catch (error) { handleError(error, res, req); }
});
router.get("/draft/:id", async (req, res) => {
try {
const user = await getUser(req);
const draft = await getBillingDraft(user.id, req.params.id);
res.set("Cache-Control", "no-store").json({ id: draft._id, path: draft.path, values: draft.values });
} catch (error) { handleError(error, res, req); }
});
router.use((req, res, next) => {
if (!req.session.billingCSRF || req.headers["x-csrf-token"] !== req.session.billingCSRF) { res.status(403).json({ error: "invalid_auth_state" }); return; }
next();
});
router.use(rateLimit({ windowMs: 60_000, limit: 30, standardHeaders: "draft-8", legacyHeaders: false }));
router.post("/draft", async (req, res) => {
try {
requireBilling();
const user = await getUser(req);
const draft = await saveBillingDraft(user.id, req.body.path, req.body.values);
res.set("Cache-Control", "no-store").json({ id: draft._id });
} catch (error) { handleError(error, res, req); }
});
router.post("/checkout", async (req, res) => {
try {
requireBilling();
const user = await getUser(req);
if (typeof req.body.planId !== "string" || (req.body.target != null && typeof req.body.target !== "string")) { res.sendStatus(400); return; }
let returnPath: string | undefined;
if (req.body.draftId != null) {
const draft = await getBillingDraft(user.id, req.body.draftId);
returnPath = `${draft.path}?billingDraft=${draft._id}`;
}
res.json({ url: await createCheckout(user.id, req.body.planId, req.body.target, undefined, returnPath) });
} catch (error) { handleError(error, res, req); }
});
router.post("/portal", async (req, res) => {
try {
const user = await getUser(req);
const account = await BillingAccount.findById(user.id).lean();
if (!account?.customerId) { res.status(404).json({ error: "billing_customer_not_found" }); return; }
const portal = await stripeClient().billingPortal.sessions.create({ customer: account.customerId, return_url: `${billingOrigin()}/profile?billing=portal` });
res.json({ url: portal.url });
} catch (error) { handleError(error, res, req); }
});
router.post("/refresh", async (req, res) => {
try {
requireBilling();
const user = await getUser(req);
const account = await BillingAccount.findById(user.id).lean();
let pending = !!account?.checkout?.key && !account.checkout.id;
if (account?.checkout?.id) {
await fulfillCheckout(account.checkout.id);
const checkout = await stripeClient().checkout.sessions.retrieve(account.checkout.id);
pending = checkout.status !== "expired" && checkout.payment_status === "unpaid";
}
const grants = await BillingGrant.find({ owner: user.id, subscriptionId: { $exists: true } }).lean();
for (const grant of grants) await syncSubscription(grant.subscriptionId!);
res.json({ ok: true, pending });
} catch (error) { handleError(error, res, req); }
});
export default router;
+21 -34
View File
@@ -1,3 +1,5 @@
import config from "../../config";
import { billingError } from "../../core/billing/config";
import * as express from "express";
import AnonymousError from "../../core/AnonymousError";
import Conference from "../../core/Conference";
@@ -12,37 +14,14 @@ const router = express.Router();
router.use(ensureAuthenticated);
const plans = [
{
id: "free_conference",
name: "Free",
pricePerRepo: 0,
storagePerRepo: -1,
description: `<li><strong>Quota is deducted from user account</strong></li>
<li>No-download</li>
<li>Conference dashboard</li>`,
},
{
id: "premium_conference",
name: "Premium",
pricePerRepo: 0.5,
storagePerRepo: 500 * 8 * 1024,
description: `<li>500Mo / repository</li>
<li>Repository download</li>
<li>Conference dashboard</li>`,
},
{
id: "unlimited_conference",
name: "Unlimited",
pricePerRepo: 3,
storagePerRepo: 0,
description: `<li><strong>Unlimited</strong> repository size</li>
<li>Repository download</li>
<li>Conference dashboard</li>`,
},
{ id: "free_conference", name: "Free", pricePerRepo: 0, storagePerRepo: -1,
description: "<li>Uses each author's allowance</li><li>Conference dashboard</li>" },
{ id: "conference", name: "Review package", pricePerRepo: 0, storagePerRepo: config.PAID_CONFERENCE_STORAGE,
description: `<li>Up to ${config.PAID_CONFERENCE_REPOSITORIES} repositories</li><li>Up to 180 days</li><li>Prepaid at checkout</li>` },
];
router.get("/plans", async (req: express.Request, res: express.Response) => {
res.json(plans);
res.json(config.BILLING_ENABLED && config.STRIPE_CONFERENCE_PRICE ? plans : plans.filter(p => p.id === "free_conference"));
});
router.get("/", async (req: express.Request, res: express.Response) => {
@@ -99,11 +78,13 @@ function validateConferenceForm(conf: any) {
object: conf,
httpStatus: 400,
});
if (plans.filter((p) => p.id == conf.plan.planID).length != 1)
if (!conf.plan || plans.filter((p) => p.id == conf.plan.planID).length != 1)
throw new AnonymousError("invalid_plan", {
object: conf,
httpStatus: 400,
});
if (!Number.isFinite(new Date(conf.startDate).getTime()) || !Number.isFinite(new Date(conf.endDate).getTime())) throw billingError("conf_start_date_invalid");
if (conf.plan.planID === "conference" && (!config.BILLING_ENABLED || !config.STRIPE_CONFERENCE_PRICE || new Date(conf.endDate).getTime() - new Date(conf.startDate).getTime() > 180 * 86400_000)) throw billingError("billing_invalid_review_window");
const plan = plans.filter((p) => p.id == conf.plan.planID)[0];
if (plan.pricePerRepo > 0) {
const billing = conf.billing;
@@ -145,16 +126,16 @@ function validateConferenceForm(conf: any) {
}
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
export function applyConferenceForm(
model: IConferenceDocument,
body: any,
body: { name: string; startDate: string | Date; endDate: string | Date; url: string;
options: IConferenceDocument["options"]; plan?: { planID: string } },
isNew: boolean
) {
model.name = body.name;
model.startDate = new Date(body.startDate);
model.endDate = new Date(body.endDate);
model.status = "ready";
if (isNew) model.status = body.plan?.planID === "conference" ? "pending_payment" : "ready";
model.url = body.url;
model.options = body.options;
if (isNew) model.repositories = [];
@@ -178,7 +159,13 @@ router.post(
model = queryModel;
isOwnerOrAdmin(model.owners, user);
}
validateConferenceForm(req.body);
if (req.params.conferenceID) {
if (req.body.plan?.planID !== model.plan.planID) throw billingError("billing_plan_change_not_supported");
if (model.plan.planID === "conference" && (new Date(req.body.startDate).getTime() !== model.startDate.getTime() || new Date(req.body.endDate).getTime() !== model.endDate.getTime())) throw billingError("billing_review_window_locked");
}
// Historical conference plans remain editable without being offered for purchase.
const legacyPlan = req.params.conferenceID && !plans.some(p => p.id === model.plan.planID);
validateConferenceForm(legacyPlan ? { ...req.body, plan: { planID: "free_conference" } } : req.body);
applyConferenceForm(model, req.body, !req.params.conferenceID);
if (!req.params.conferenceID) {
@@ -194,7 +181,7 @@ router.post(
size: plans.filter((p) => p.id == req.body.plan.planID)[0]
.storagePerRepo,
file: 0,
repository: 0,
repository: req.body.plan.planID === "conference" ? config.PAID_CONFERENCE_REPOSITORIES : 0,
},
};
+21
View File
@@ -1,3 +1,6 @@
import { neverExpirationDeadline, validateBillingExpiration } from "../../core/billing/expiration";
import config from "../../config";
import { assertConferenceAdmission, reserveRepository } from "../../core/billing/quotas";
import { randomUUID } from "crypto";
import { githubQuotaKey } from "../../core/github-token-context";
import { selectRepositoryAccess, boundAppToken, appError } from "../../core/github-app";
@@ -506,6 +509,14 @@ router.post(
const sourceChanged = reconnecting || hasRepositorySourceChanged(repo.model, repoUpdate);
const previousAccessRevision = repo.model.githubAccess?.revision;
if (repo.model.billingManaged) validateBillingExpiration(repoUpdate.options);
if (config.BILLING_ENABLED && repoUpdate.options.expirationMode === "never" &&
(repo.model.options.expirationMode !== "never" || repo.model.billingNeverExpiresUntil)) {
repo.model.billingNeverExpiresUntil = await neverExpirationDeadline(String(repo.model.owner),
repo.model.options.expirationMode === "never" ? repo.model.billingNeverExpiresUntil : undefined);
} else if (repoUpdate.options.expirationMode !== "never") {
repo.model.billingNeverExpiresUntil = undefined;
}
updateRepoModel(repo.model, repoUpdate);
const reactivating = shouldReactivateInactiveRepository(repo.model);
@@ -513,6 +524,9 @@ router.post(
repo.model.anonymizeDate = new Date();
}
await assertConferenceAdmission(String(repo.model.owner), repo.repoId, repoUpdate.conference);
if (repo.model.billingManaged) await reserveRepository(String(repo.model.owner), repo.repoId, repo.model.size?.storage || 0, repoUpdate.conference);
if (sourceChanged) {
const parsedRepository = gh(repoUpdate.fullName);
if (!parsedRepository?.owner || !parsedRepository?.name) {
@@ -691,6 +705,10 @@ router.post("/", async (req, res) => {
repo.owner = user.id;
repo.githubAccess = selectedAccess.binding;
validateBillingExpiration(repoUpdate.options);
if (repoUpdate.options.expirationMode === "never") {
repo.billingNeverExpiresUntil = await neverExpirationDeadline(user.id);
}
updateRepoModel(repo, repoUpdate);
repo.source.type = "GitHubStream";
repo.source.repositoryId = repository.model.id;
@@ -698,6 +716,9 @@ router.post("/", async (req, res) => {
repo.conference = repoUpdate.conference;
await assertConferenceAdmission(user.id, repo.repoId, repo.conference);
repo.billingManaged = config.BILLING_ENABLED;
await reserveRepository(user.id, repo.repoId, 0, repo.conference);
await repo.save();
if (repoUpdate.conference) {
+1
View File
@@ -32,6 +32,7 @@ router.get(
}
const repo = await getRepo(req, res);
if (!repo) return;
if (repo.model.billingManaged && repo.model.truncatedFolders?.length) throw new AnonymousError("repository_tree_incomplete", { httpStatus: 409 });
let user: User | undefined = undefined;
try {
+12 -4
View File
@@ -1,3 +1,6 @@
import { BillingQuota, BillingDraft } from "../../core/billing/models";
import { cancelAccountBilling } from "../../core/billing/stripe";
import { allowance } from "../../core/billing/quotas";
import DashboardName from "../../core/model/dashboard-name";
import { dashboardSummary } from "./dashboard-summary";
import { revokeGrant } from "./github-app";
@@ -112,18 +115,21 @@ router.get("/quota", async (req, res) => {
}
}
const limits = config.BILLING_ENABLED ? await allowance(user.id) : null;
const reserved = limits ? await BillingQuota.findById(limits.scope).lean() : null;
res.json({
storage: {
used: totalStorage,
total: config.DEFAULT_QUOTA,
unit: limits ? "bytes" : "legacy",
used: reserved ? reserved.allocations.reduce((sum, entry) => sum + (entry.bytes || 0), 0) : totalStorage,
total: limits?.storage ?? config.DEFAULT_QUOTA,
},
file: {
used: totalFiles,
total: 0,
},
repository: {
used: ready.length,
total: 20,
used: reserved ? reserved.allocations.length : ready.length,
total: limits?.repositories ?? 20,
},
});
} catch (error) {
@@ -175,6 +181,8 @@ router.post("/default", async (req, res) => {
router.delete("/", async (req, res) => {
try {
const user = await getUser(req);
if (config.BILLING_ENABLED) await cancelAccountBilling(user.id);
if (isConnected) await BillingDraft.deleteMany({ owner: user.id });
const repositories = (await user.getRepositories()).filter(
(r) => r.owner.id === user.model.id && r.status !== "removed"
+2
View File
@@ -1,3 +1,4 @@
import { reconcileNeverExpiration } from "../core/billing/expiration";
import { Model, Document } from "mongoose";
import * as schedule from "node-schedule";
import AnonymizedGistModel from "../core/model/anonymizedGists/anonymizedGists.model";
@@ -62,6 +63,7 @@ export function repositoryMaintenanceQuery(now: Date) {
}
export async function runRepositoryStatusCheck(now = new Date()) {
await reconcileNeverExpiration(now);
logger.info("checking repository status and unused repositories");
const fourMonthAgo = new Date(now);
fourMonthAgo.setMonth(fourMonthAgo.getMonth() - 4);