dhkatzandClaude Opus 5.5
97ce2be569
CI / test (push) Successful in 1m4s
A creator deletes a product: it's no longer listed and nobody new can get it, while people who have it keep it (its page, files and library entries stay, and rooms keep showing it), as old revisions stay available. Moderation removes one everywhere, with a reason: its page and files answer 410, and it leaves libraries and rooms. Both are on the product's page and in the audit log. Co-Authored-By: Claude Opus 5.5 <[email protected]>
493 lines
20 KiB
TypeScript
493 lines
20 KiB
TypeScript
// The product registry, catalogs and libraries (docs/products.md). The routes are in app.ts; this is what they do.
|
|
import { createHash, timingSafeEqual } from "node:crypto";
|
|
import {
|
|
and,
|
|
desc,
|
|
eq,
|
|
gt,
|
|
ilike,
|
|
inArray,
|
|
isNull,
|
|
ne,
|
|
or,
|
|
sql,
|
|
schema,
|
|
type Database,
|
|
type FileEntry,
|
|
type ParentInfo,
|
|
} from "@t5de/db";
|
|
import { cleanHTML, maxDescription } from "./html";
|
|
import type { ImvuClient } from "./imvu";
|
|
import type { Signer } from "./keys";
|
|
|
|
const { catalog, product, productRevision, hosting, library, user } = schema;
|
|
|
|
export type Catalog = typeof catalog.$inferSelect;
|
|
export type Product = typeof product.$inferSelect;
|
|
export type Revision = typeof productRevision.$inferSelect;
|
|
|
|
/** An error for the person; the routes turn it into a Problem. */
|
|
export class ProductError extends Error {
|
|
constructor(
|
|
readonly status: number,
|
|
readonly slug: string,
|
|
message: string,
|
|
) {
|
|
super(message);
|
|
}
|
|
}
|
|
|
|
const base32 = "abcdefghijklmnopqrstuvwxyz234567";
|
|
export const newProductID = () =>
|
|
[...crypto.getRandomValues(new Uint8Array(10))].map((b) => base32[b & 31]).join("");
|
|
const randomKey = () => Buffer.from(crypto.getRandomValues(new Uint8Array(24))).toString("base64url");
|
|
const sha256 = (s: string) => createHash("sha256").update(s).digest("hex");
|
|
|
|
const nameRule = (s: unknown, max: number) => {
|
|
const v = typeof s === "string" ? s.trim() : "";
|
|
// eslint-disable-next-line no-control-regex
|
|
if (!v || v.length > max || /[\u0000-\u001f\u007f]/.test(v)) return undefined;
|
|
return v;
|
|
};
|
|
|
|
/** A file list as catalogs send it: checked and sorted by name. */
|
|
export function checkFiles(files: unknown): FileEntry[] | undefined {
|
|
if (!Array.isArray(files) || files.length === 0 || files.length > 512) return undefined;
|
|
const out: FileEntry[] = [];
|
|
const names = new Set<string>();
|
|
for (const f of files) {
|
|
const name = typeof f?.name === "string" ? f.name : "";
|
|
const hash = typeof f?.sha256 === "string" ? f.sha256 : "";
|
|
const size = Number(f?.size);
|
|
if (!name || name.length > 200 || names.has(name) || /[/\\]/.test(name)) return undefined;
|
|
if (!/^[0-9a-f]{64}$/.test(hash) || !Number.isSafeInteger(size) || size < 0) return undefined;
|
|
names.add(name);
|
|
out.push({ name, sha256: hash, size });
|
|
}
|
|
return out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
|
|
}
|
|
|
|
// Field by field: stored lists come back from JSONB with their keys in another order.
|
|
const sameFiles = (a: FileEntry[], b: FileEntry[]) =>
|
|
a.length === b.length && a.every((f, i) => f.name === b[i]!.name && f.sha256 === b[i]!.sha256 && f.size === b[i]!.size);
|
|
|
|
// A parent's info another revision looked up lately is reused rather than asking IMVU again.
|
|
const parentInfoFresh = 7 * 24 * 60 * 60 * 1000;
|
|
|
|
/** Each product's latest revision (joined on product.latest, for lists). */
|
|
const latestJoin = and(eq(productRevision.productId, product.id), eq(productRevision.number, product.latest));
|
|
|
|
export class Products {
|
|
constructor(
|
|
private readonly db: Database,
|
|
private readonly signer: Signer,
|
|
private readonly imvu?: ImvuClient,
|
|
) {}
|
|
|
|
// ---- catalogs ----
|
|
|
|
async registerCatalog(
|
|
ownerId: string,
|
|
input: { name: string; url: string; contact: string; visibility: string; membership: string },
|
|
) {
|
|
const name = nameRule(input.name, 64);
|
|
const contact = nameRule(input.contact, 200);
|
|
let url: URL;
|
|
try {
|
|
url = new URL(input.url);
|
|
} catch {
|
|
throw new ProductError(400, "invalid", "That address isn't a URL.");
|
|
}
|
|
if (!name || !contact) throw new ProductError(400, "invalid", "A name and a takedown contact are needed.");
|
|
if (url.protocol !== "https:" && url.hostname !== "localhost" && url.hostname !== "127.0.0.1")
|
|
throw new ProductError(400, "invalid", "Catalogs need an https address.");
|
|
if (!["public", "private"].includes(input.visibility) || !["open", "approval", "invite"].includes(input.membership))
|
|
throw new ProductError(400, "invalid", "Choose a visibility and a membership.");
|
|
const clean = url.origin + url.pathname.replace(/\/+$/, "");
|
|
const [taken] = await this.db.select({ id: catalog.id }).from(catalog).where(eq(catalog.url, clean));
|
|
if (taken) throw new ProductError(409, "taken", "A catalog at that address is already registered.");
|
|
const key = randomKey();
|
|
const [c] = await this.db
|
|
.insert(catalog)
|
|
.values({
|
|
id: newProductID(),
|
|
ownerId,
|
|
name,
|
|
url: clean,
|
|
contact,
|
|
visibility: input.visibility,
|
|
membership: input.membership,
|
|
keyHash: sha256(key),
|
|
})
|
|
.returning();
|
|
return { catalog: c!, key };
|
|
}
|
|
|
|
/** The catalog an `Authorization: Catalog <id>:<key>` header names, if it's approved and the key is right. */
|
|
async catalogFor(header: string | null): Promise<Catalog | undefined> {
|
|
const m = header?.match(/^Catalog ([a-z2-7]{10}):(\S+)$/);
|
|
if (!m) return undefined;
|
|
const [c] = await this.db.select().from(catalog).where(eq(catalog.id, m[1]!));
|
|
if (!c || c.status !== "approved") return undefined;
|
|
return timingSafeEqual(Buffer.from(sha256(m[2]!)), Buffer.from(c.keyHash)) ? c : undefined;
|
|
}
|
|
|
|
async catalogs(viewerId?: string) {
|
|
const rows = await this.db
|
|
.select()
|
|
.from(catalog)
|
|
.where(
|
|
or(
|
|
and(eq(catalog.status, "approved"), eq(catalog.visibility, "public")),
|
|
viewerId ? eq(catalog.ownerId, viewerId) : sql`false`,
|
|
),
|
|
)
|
|
.orderBy(catalog.name);
|
|
return rows;
|
|
}
|
|
|
|
async allCatalogs() {
|
|
return this.db.select().from(catalog).orderBy(desc(catalog.createdAt));
|
|
}
|
|
|
|
async setCatalogStatus(id: string, status: "approved" | "rejected") {
|
|
const [c] = await this.db.update(catalog).set({ status }).where(eq(catalog.id, id)).returning();
|
|
if (!c) throw new ProductError(404, "not_found", "No such catalog.");
|
|
return c;
|
|
}
|
|
|
|
// ---- uploads ----
|
|
|
|
/** An upload token for a person to send a product (or a new revision of theirs) to a catalog. */
|
|
async uploadToken(personId: string, catalogId: string, productId?: string) {
|
|
const [c] = await this.db.select().from(catalog).where(eq(catalog.id, catalogId));
|
|
if (!c || c.status !== "approved") throw new ProductError(404, "not_found", "No such catalog.");
|
|
if (productId) await this.own(personId, productId);
|
|
const token = await this.signer.sign(
|
|
"t5de-upload",
|
|
{ sub: personId, catalog: c.id, ...(productId ? { product: productId } : {}) },
|
|
30 * 60,
|
|
);
|
|
return { token, url: `${c.url}/api/v1/uploads` };
|
|
}
|
|
|
|
/** A catalog registers an uploaded revision: a new product, or a new revision of one. */
|
|
async registerRevision(
|
|
c: Catalog,
|
|
body: { uploadToken: string; files: unknown; rating: string; parent: number; name: string; notes: string },
|
|
) {
|
|
const claims = await this.signer.verify(body.uploadToken, "t5de-upload");
|
|
if (!claims || claims.catalog !== c.id || typeof claims.sub !== "string")
|
|
throw new ProductError(401, "bad_token", "The upload token isn't valid for this catalog.");
|
|
const files = checkFiles(body.files);
|
|
if (!files) throw new ProductError(400, "invalid", "The file list isn't valid.");
|
|
if (body.rating !== "general" && body.rating !== "adult")
|
|
throw new ProductError(400, "invalid", "The rating must be general or adult.");
|
|
const parent = Number.isSafeInteger(body.parent) && body.parent > 0 ? body.parent : 0;
|
|
const notes = (typeof body.notes === "string" ? body.notes.trim() : "").slice(0, 2000);
|
|
const personId = claims.sub;
|
|
|
|
const made = await this.db.transaction(async (tx) => {
|
|
let p: Product;
|
|
if (typeof claims.product === "string") {
|
|
const [found] = await tx.select().from(product).where(eq(product.id, claims.product)).for("update");
|
|
if (!found || found.creatorId !== personId) throw new ProductError(403, "forbidden", "That product isn't yours.");
|
|
if (!notes) throw new ProductError(400, "invalid", "Say what changed in this revision.");
|
|
const [latest] = await tx
|
|
.select()
|
|
.from(productRevision)
|
|
.where(and(eq(productRevision.productId, found.id), eq(productRevision.number, found.latest)));
|
|
if (latest && sameFiles(latest.files, files))
|
|
throw new ProductError(409, "unchanged", "These files are the same as the latest revision's.");
|
|
p = found;
|
|
} else {
|
|
const name = nameRule(body.name, 64) ?? "Untitled";
|
|
const [made] = await tx
|
|
.insert(product)
|
|
.values({ id: newProductID(), creatorId: personId, name, rating: body.rating })
|
|
.returning();
|
|
p = made!;
|
|
}
|
|
const number = p.latest + 1;
|
|
const token = await this.signer.sign("t5de-revision", {
|
|
product: p.id,
|
|
revision: number,
|
|
rating: body.rating,
|
|
files,
|
|
parent,
|
|
});
|
|
await tx.insert(productRevision).values({
|
|
productId: p.id,
|
|
number,
|
|
files,
|
|
rating: body.rating,
|
|
parent,
|
|
notes,
|
|
token,
|
|
uploadedBy: personId,
|
|
});
|
|
// A product is adult if any revision is (or its creator says so).
|
|
const rating = p.rating === "adult" || body.rating === "adult" ? "adult" : "general";
|
|
await tx.update(product).set({ latest: number, rating }).where(eq(product.id, p.id));
|
|
await tx.insert(hosting).values({ catalogId: c.id, productId: p.id, number });
|
|
return { product: p.id, revision: number };
|
|
});
|
|
// The parent's image and categories: best effort, without holding up the upload (fillParentInfo retries).
|
|
if (parent > 0) this.lookUpParent(made.product, made.revision, parent).catch(() => {});
|
|
return made;
|
|
}
|
|
|
|
// ---- parents (the IMVU products revisions derive from) ----
|
|
|
|
/** Looks up and stores a revision's parent info. Throws if IMVU can't be reached (the info stays null). */
|
|
async lookUpParent(productId: string, number: number, parent: number): Promise<ParentInfo | undefined> {
|
|
if (!this.imvu || parent <= 0) return undefined;
|
|
const since = new Date(Date.now() - parentInfoFresh).toISOString();
|
|
const [known] = await this.db
|
|
.select({ info: productRevision.parentInfo })
|
|
.from(productRevision)
|
|
.where(
|
|
and(
|
|
eq(productRevision.parent, parent),
|
|
sql`(${productRevision.parentInfo}->>'checkedAt')::timestamptz > ${since}::timestamptz`,
|
|
),
|
|
)
|
|
.limit(1);
|
|
let info = known?.info ?? undefined;
|
|
if (!info) {
|
|
const p = await this.imvu.product(parent);
|
|
info = {
|
|
found: p !== null,
|
|
image: p?.image ?? null,
|
|
categories: p?.categories ?? [],
|
|
gender: p?.gender ?? "",
|
|
checkedAt: new Date().toISOString(),
|
|
};
|
|
}
|
|
await this.db
|
|
.update(productRevision)
|
|
.set({ parentInfo: info })
|
|
.where(and(eq(productRevision.productId, productId), eq(productRevision.number, number)));
|
|
return info;
|
|
}
|
|
|
|
/** Looks up parent info for revisions that have a parent and no info yet, a few at a time. */
|
|
async fillParentInfo(limit = 20): Promise<number> {
|
|
const due = await this.db
|
|
.select({ productId: productRevision.productId, number: productRevision.number, parent: productRevision.parent })
|
|
.from(productRevision)
|
|
.where(and(gt(productRevision.parent, 0), isNull(productRevision.parentInfo)))
|
|
.orderBy(desc(productRevision.createdAt))
|
|
.limit(limit);
|
|
let n = 0;
|
|
for (const r of due) {
|
|
try {
|
|
if (await this.lookUpParent(r.productId, r.number, r.parent)) n++;
|
|
} catch {
|
|
// IMVU unavailable: try again next time.
|
|
}
|
|
}
|
|
return n;
|
|
}
|
|
|
|
// ---- products ----
|
|
|
|
private async own(personId: string, productId: string) {
|
|
const [p] = await this.db.select().from(product).where(eq(product.id, productId));
|
|
if (!p) throw new ProductError(404, "not_found", "No such product.");
|
|
if (p.creatorId !== personId) throw new ProductError(403, "forbidden", "That product isn't yours.");
|
|
if (p.removedAt) throw new ProductError(410, "removed", "This product was removed by moderation.");
|
|
if (p.deletedAt) throw new ProductError(410, "deleted", "You deleted this product.");
|
|
return p;
|
|
}
|
|
|
|
/** Its creator deletes a product: it's no longer listed or added to libraries (those who have it keep it). */
|
|
async delete(personId: string, id: string) {
|
|
await this.own(personId, id);
|
|
await this.db.update(product).set({ deletedAt: new Date() }).where(eq(product.id, id));
|
|
}
|
|
|
|
/** Moderation removes a product: gone everywhere. */
|
|
async removeByModeration(id: string, reason: string) {
|
|
const [p] = await this.db
|
|
.update(product)
|
|
.set({ removedAt: new Date(), removedReason: reason })
|
|
.where(and(eq(product.id, id), isNull(product.removedAt)))
|
|
.returning();
|
|
if (!p) throw new ProductError(404, "not_found", "No such product, or it's removed already.");
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* Products, newest first; adult ones only if adult. `category`: only those whose latest revision's parent is in
|
|
* that IMVU category (anywhere in its path). Each comes with its latest revision's parent and parent info.
|
|
*/
|
|
async list(opts: { q?: string; creator?: string; category?: number; adult: boolean; limit?: number }) {
|
|
const conds = [ne(product.latest, 0), isNull(product.deletedAt), isNull(product.removedAt)];
|
|
if (!opts.adult) conds.push(eq(product.rating, "general"));
|
|
if (opts.q) conds.push(ilike(product.name, `%${opts.q.replace(/[%_\\]/g, (c) => "\\" + c)}%`));
|
|
if (opts.creator) conds.push(eq(user.username, opts.creator.toLowerCase()));
|
|
if (opts.category !== undefined)
|
|
conds.push(sql`${productRevision.parentInfo}->'categories' @> ${JSON.stringify([{ id: opts.category }])}::jsonb`);
|
|
const limit = Math.max(1, Math.min(Math.trunc(opts.limit ?? 60) || 60, 200));
|
|
return this.db
|
|
.select({
|
|
product,
|
|
creator: user.displayUsername,
|
|
creatorUsername: user.username,
|
|
parent: productRevision.parent,
|
|
parentInfo: productRevision.parentInfo,
|
|
})
|
|
.from(product)
|
|
.innerJoin(user, eq(user.id, product.creatorId))
|
|
.leftJoin(productRevision, latestJoin)
|
|
.where(and(...conds))
|
|
.orderBy(desc(product.createdAt))
|
|
.limit(limit);
|
|
}
|
|
|
|
/** A product's latest revision's parent and parent info (for views of one product). */
|
|
async latestParent(p: Product) {
|
|
const [r] = await this.db
|
|
.select({ parent: productRevision.parent, parentInfo: productRevision.parentInfo })
|
|
.from(productRevision)
|
|
.where(and(eq(productRevision.productId, p.id), eq(productRevision.number, p.latest)));
|
|
return r;
|
|
}
|
|
|
|
async get(id: string, adult: boolean) {
|
|
const [row] = await this.db
|
|
.select({ product, creator: user.displayUsername, creatorUsername: user.username })
|
|
.from(product)
|
|
.innerJoin(user, eq(user.id, product.creatorId))
|
|
.where(eq(product.id, id));
|
|
if (!row || row.product.latest === 0) throw new ProductError(404, "not_found", "No such product.");
|
|
if (row.product.removedAt) throw new ProductError(410, "removed", "This product was removed by moderation.");
|
|
if (row.product.rating === "adult" && !adult) throw new ProductError(404, "not_found", "No such product.");
|
|
const revisions = await this.db
|
|
.select()
|
|
.from(productRevision)
|
|
.where(eq(productRevision.productId, id))
|
|
.orderBy(desc(productRevision.number));
|
|
const hosts = await this.db
|
|
.select({ number: hosting.number, name: catalog.name, url: catalog.url })
|
|
.from(hosting)
|
|
.innerJoin(catalog, eq(catalog.id, hosting.catalogId))
|
|
.where(and(eq(hosting.productId, id), eq(catalog.status, "approved")));
|
|
return { ...row, revisions, hosts };
|
|
}
|
|
|
|
async update(personId: string, id: string, input: { name?: string; description?: string; rating?: string }) {
|
|
const p = await this.own(personId, id);
|
|
const set: Partial<Product> = {};
|
|
if (input.name !== undefined) {
|
|
const name = nameRule(input.name, 64);
|
|
if (!name) throw new ProductError(400, "invalid", "Names are 1-64 characters.");
|
|
set.name = name;
|
|
}
|
|
if (input.description !== undefined) {
|
|
if (input.description.length > maxDescription)
|
|
throw new ProductError(400, "invalid", "That description is too long.");
|
|
set.description = cleanHTML(input.description);
|
|
}
|
|
if (input.rating !== undefined) {
|
|
if (input.rating === "adult") set.rating = "adult";
|
|
else if (input.rating === "general" && p.rating === "adult")
|
|
// Lowering is reviewed by moderators first (design.md); until that exists, it's refused.
|
|
throw new ProductError(400, "review_needed", "Lowering a rating needs a moderator's review.");
|
|
}
|
|
const [updated] = await this.db.update(product).set(set).where(eq(product.id, id)).returning();
|
|
return updated!;
|
|
}
|
|
|
|
async retract(personId: string, id: string, number: number) {
|
|
await this.own(personId, id);
|
|
const [r] = await this.db
|
|
.update(productRevision)
|
|
.set({ retracted: true })
|
|
.where(and(eq(productRevision.productId, id), eq(productRevision.number, number)))
|
|
.returning();
|
|
if (!r) throw new ProductError(404, "not_found", "No such revision.");
|
|
return r;
|
|
}
|
|
|
|
// ---- libraries ----
|
|
|
|
async library(personId: string) {
|
|
return this.db
|
|
.select({
|
|
product,
|
|
stayOn: library.stayOn,
|
|
addedAt: library.addedAt,
|
|
creator: user.displayUsername,
|
|
parent: productRevision.parent,
|
|
parentInfo: productRevision.parentInfo,
|
|
})
|
|
.from(library)
|
|
.innerJoin(product, eq(product.id, library.productId))
|
|
.innerJoin(user, eq(user.id, product.creatorId))
|
|
.leftJoin(productRevision, latestJoin)
|
|
.where(and(eq(library.userId, personId), isNull(product.removedAt)))
|
|
.orderBy(desc(library.addedAt));
|
|
}
|
|
|
|
async inLibrary(personId: string, productId: string) {
|
|
const [row] = await this.db
|
|
.select({ stayOn: library.stayOn })
|
|
.from(library)
|
|
.where(and(eq(library.userId, personId), eq(library.productId, productId)));
|
|
return row;
|
|
}
|
|
|
|
async add(personId: string, productId: string, adult: boolean) {
|
|
const p = await this.get(productId, adult);
|
|
if (p.product.deletedAt && !(await this.inLibrary(personId, productId)))
|
|
throw new ProductError(410, "deleted", "Its creator deleted this product.");
|
|
await this.db.insert(library).values({ userId: personId, productId }).onConflictDoNothing();
|
|
}
|
|
|
|
async remove(personId: string, productId: string) {
|
|
await this.db.delete(library).where(and(eq(library.userId, personId), eq(library.productId, productId)));
|
|
}
|
|
|
|
async stayOn(personId: string, productId: string, number: number | null) {
|
|
if (number !== null) {
|
|
const [r] = await this.db
|
|
.select()
|
|
.from(productRevision)
|
|
.where(and(eq(productRevision.productId, productId), eq(productRevision.number, number)));
|
|
if (!r || r.retracted) throw new ProductError(404, "not_found", "No such revision.");
|
|
}
|
|
const [row] = await this.db
|
|
.update(library)
|
|
.set({ stayOn: number })
|
|
.where(and(eq(library.userId, personId), eq(library.productId, productId)))
|
|
.returning();
|
|
if (!row) throw new ProductError(404, "not_found", "That product isn't in your library.");
|
|
}
|
|
|
|
/**
|
|
* The revision a person uses of a product: the one they stay on, else the latest; a retracted one gives way to
|
|
* the nearest earlier one that isn't (or later, if none).
|
|
*/
|
|
async revisionFor(personId: string | undefined, productId: string, adult: boolean) {
|
|
const p = await this.get(productId, adult);
|
|
const pin = personId ? (await this.inLibrary(personId, productId))?.stayOn : undefined;
|
|
const want = pin ?? p.product.latest;
|
|
const usable = p.revisions.filter((r) => !r.retracted);
|
|
if (usable.length === 0) throw new ProductError(404, "not_found", "That product has no usable revision.");
|
|
const r =
|
|
usable.find((r) => r.number === want) ??
|
|
usable.find((r) => r.number < want) ??
|
|
usable[usable.length - 1]!;
|
|
const hosts = p.hosts.filter((h) => h.number === r.number).map((h) => h.url);
|
|
return { product: p.product, creator: p.creator, revision: r, catalogs: hosts };
|
|
}
|
|
|
|
/** People's display names for creators, by ID (for the console). */
|
|
async creators(ids: string[]) {
|
|
if (!ids.length) return [];
|
|
return this.db.select({ id: user.id, username: user.displayUsername }).from(user).where(inArray(user.id, ids));
|
|
}
|
|
}
|