remco/EpicNext-Cms
1
1 Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

fix(catalog): make the Builder Club catalog read and write its own offers
Gitea Actions Runner Test / test-job (push) Successful in 0s
Details
CI / check (push) Successful in 28s
Details
CI / tests-unit (push) Successful in 1m39s
Details
CI / tests-integration (push) Successful in 1m42s
Details
CI / tests-ui (push) Successful in 2m23s
Details
CI / preflight (push) Skipped
Details
CI / deploy (push) Successful in 2m6s
Details

Browse Source 
The previous commit taught bulk editing and delete-with-restore about the BC
catalog. Neither actually worked, and one of them was destructive.

`catalog_items_bc` has six columns: id, item_ids, page_id, catalog_name,
order_number, extradata. There is no price, points, currency, offer_id, limit or
membership column on it. The bulk path read and wrote columns that do not
exist, and the UPDATE was aimed at catalog_items while the SELECT came from
catalog_items_bc — so a BC category move wrote into the normal catalog. Two
tests now pin that pairing: reads and writes have to stay in the same table.

Underneath it the BC table was never being read at all. The inline editor
fetched `/api/admin/catalog/items?pageId=N` without the catalog, so opening a BC
category showed the normal catalog's offers, and the route selected BC rows
directly instead of going through the loader, skipping the furni enrichment the
table needs to render anything but a bare caption. Both catalogs now take the
same path, and the catalog is in the fetch callback's dependencies — without
that, a switch keeps reading the previous catalog's rows through a stale
closure.

Because a BC offer has no price, the editor no longer offers one. The server
refuses price, points and currency changes with a readable message instead of
letting them reach the database as an unknown-column error, and a BC bulk edit
is what it can actually be: a category move.

BC deletions also went through a bare DELETE, which made them the one catalog
mutation with no way back. They now keep their rows and hand back a restoreId
like the normal ones. The catalog is recorded in the audit target rather than
in the payload, so a restore can never put a BC row into the normal offers
table.
This commit is contained in:
openhands committed 2026-09-30 19:17:20 +02:00
1 parent cebcf440c5
commit e0efbef30d
12 files changed
+548 -218
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/features/catalog/components/bulk-offer-editor.tsx
+142 -119
View File
@@ -288,104 +288,120 @@ export function BulkOfferEditor({
{!preview ? (
<div className="space-y-4">
<p className="text-sm text-muted-foreground">{t("fieldHint")}</p>
{(["costCredits", "costPoints"] as const).map((field) => (
<div key={field} className="space-y-3 rounded-md border p-3">
<Label className="flex items-center gap-2">
<Checkbox
checked={prices[field].enabled}
onCheckedChange={(value) =>
updatePrice(field, { enabled: value === true })
}
disabled={busy}
/>
{t(field)}
</Label>
{prices[field].enabled && (
<div className="grid gap-3 sm:grid-cols-2">
<div className="space-y-1">
<Label htmlFor={`bulk-${field}-mode`}>
{t("operation")}
</Label>
<Select
value={prices[field].mode}
onValueChange={(value) =>
updatePrice(field, { mode: value as PriceMode })
}
disabled={busy}
>
<SelectTrigger id={`bulk-${field}-mode`}>
<SelectValue />
</SelectTrigger>
<SelectContent>
{(["set", "add", "percent"] as const).map(
(mode) => (
<SelectItem key={mode} value={mode}>
{t(`modes.${mode}`)}
</SelectItem>
),
)}
</SelectContent>
</Select>
</div>
<div className="space-y-1">
<Label htmlFor={`bulk-${field}-value`}>
{t(
prices[field].mode === "percent"
? "percentage"
: "value",
)}
</Label>
<Input
id={`bulk-${field}-value`}
type="number"
step={prices[field].mode === "percent" ? "any" : 1}
value={prices[field].value}
onChange={(event) =>
updatePrice(field, { value: event.target.value })
{/* A BC offer has no price, points or currency column to
write. The server refuses those changes too; hiding the
fields keeps the dialog from offering what cannot be done. */}
{catalog !== "bc" && (
<>
{(["costCredits", "costPoints"] as const).map((field) => (
<div
key={field}
className="space-y-3 rounded-md border p-3"
>
<Label className="flex items-center gap-2">
<Checkbox
checked={prices[field].enabled}
onCheckedChange={(value) =>
updatePrice(field, { enabled: value === true })
}
disabled={busy}
/>
</div>
</div>
)}
</div>
))}
<div className="space-y-3 rounded-md border p-3">
<Label className="flex items-center gap-2">
<Checkbox
checked={currencyEnabled}
onCheckedChange={(value) =>
setCurrencyEnabled(value === true)
}
disabled={busy}
/>
{t("currency")}
</Label>
{currencyEnabled && (
<Select
value={String(pointsType)}
onValueChange={(value) => setPointsType(Number(value))}
disabled={busy}
>
<SelectTrigger aria-label={t("currency")}>
<SelectValue />
</SelectTrigger>
<SelectContent>
{Object.keys(POINTS_TYPES).map((type) => (
<SelectItem key={type} value={type}>
<span className="flex items-center gap-2">
<CurrencyIcon
kind={currencyKindFromPointsType(Number(type))}
alt=""
{t(field)}
</Label>
{prices[field].enabled && (
<div className="grid gap-3 sm:grid-cols-2">
<div className="space-y-1">
<Label htmlFor={`bulk-${field}-mode`}>
{t("operation")}
</Label>
<Select
value={prices[field].mode}
onValueChange={(value) =>
updatePrice(field, { mode: value as PriceMode })
}
disabled={busy}
>
<SelectTrigger id={`bulk-${field}-mode`}>
<SelectValue />
</SelectTrigger>
<SelectContent>
{(["set", "add", "percent"] as const).map(
(mode) => (
<SelectItem key={mode} value={mode}>
{t(`modes.${mode}`)}
</SelectItem>
),
)}
</SelectContent>
</Select>
</div>
<div className="space-y-1">
<Label htmlFor={`bulk-${field}-value`}>
{t(
prices[field].mode === "percent"
? "percentage"
: "value",
)}
</Label>
<Input
id={`bulk-${field}-value`}
type="number"
step={
prices[field].mode === "percent" ? "any" : 1
}
value={prices[field].value}
onChange={(event) =>
updatePrice(field, {
value: event.target.value,
})
}
disabled={busy}
/>
{currencyName(Number(type))}
</span>
</SelectItem>
))}
</SelectContent>
</Select>
)}
</div>
</div>
</div>
)}
</div>
))}
<div className="space-y-3 rounded-md border p-3">
<Label className="flex items-center gap-2">
<Checkbox
checked={currencyEnabled}
onCheckedChange={(value) =>
setCurrencyEnabled(value === true)
}
disabled={busy}
/>
{t("currency")}
</Label>
{currencyEnabled && (
<Select
value={String(pointsType)}
onValueChange={(value) => setPointsType(Number(value))}
disabled={busy}
>
<SelectTrigger aria-label={t("currency")}>
<SelectValue />
</SelectTrigger>
<SelectContent>
{Object.keys(POINTS_TYPES).map((type) => (
<SelectItem key={type} value={type}>
<span className="flex items-center gap-2">
<CurrencyIcon
kind={currencyKindFromPointsType(
Number(type),
)}
alt=""
/>
{currencyName(Number(type))}
</span>
</SelectItem>
))}
</SelectContent>
</Select>
)}
</div>
</>
)}
<div className="space-y-3 rounded-md border p-3">
<Label className="flex items-center gap-2">
<Checkbox
@@ -434,13 +450,16 @@ export function BulkOfferEditor({
<Table>
<TableHeader>
<TableRow>
{[
"offer",
"costCredits",
"costPoints",
"currency",
"destination",
].map((key) => (
{(catalog === "bc"
? ["offer", "destination"]
: [
"offer",
"costCredits",
"costPoints",
"currency",
"destination",
]
).map((key) => (
<TableHead key={key}>{t(key)}</TableHead>
))}
</TableRow>
@@ -456,24 +475,28 @@ export function BulkOfferEditor({
#{row.id}
</span>
</TableCell>
<TableCell>
{renderChange(
row.before.costCredits,
row.after.costCredits,
)}
</TableCell>
<TableCell>
{renderChange(
row.before.costPoints,
row.after.costPoints,
)}
</TableCell>
<TableCell>
{renderChange(
currencyName(row.before.pointsType),
currencyName(row.after.pointsType),
)}
</TableCell>
{catalog !== "bc" && (
<>
<TableCell>
{renderChange(
row.before.costCredits,
row.after.costCredits,
)}
</TableCell>
<TableCell>
{renderChange(
row.before.costPoints,
row.after.costPoints,
)}
</TableCell>
<TableCell>
{renderChange(
currencyName(row.before.pointsType),
currencyName(row.after.pointsType),
)}
</TableCell>
</>
)}
<TableCell>
{renderChange(
`${pageNames.get(row.before.pageId) ?? ""} #${row.before.pageId}`,
src/features/catalog/server/bulk-offers.test.ts
+45
View File
@@ -196,6 +196,51 @@ it("locks pages before offers and commits the entire batch", async () => {
.every((q) => !q.includes("cost_points")),
).toBe(true);
});
it("refuses a price change on a BC offer, which has no price column", async () => {
await expect(
previewBulkOffersCommand(
{
ids: [1, 2],
changes: { costCredits: { mode: "set", value: 5 } },
},
"bc",
),
).rejects.toThrow(/Builder Club offer has no price/);
expect(state.writes).toBe(0);
});
it("refuses a currency change on a BC offer too", async () => {
await expect(
previewBulkOffersCommand({ ids: [1], changes: { pointsType: 5 } }, "bc"),
).rejects.toThrow(/currency/);
});
it("allows a BC category move and writes no column BC lacks", async () => {
const p = await previewBulkOffersCommand(
{ ids: [1, 2], changes: { pageId: 9 } },
"bc",
);
expect(p.changedCount).toBe(2);
state.queries = [];
await applyBulkOffersCommand(
{ ids: [1, 2], changes: { pageId: 9 } },
p.fingerprint,
undefined,
undefined,
"bc",
);
// The read and the write both have to stay inside the BC table: reading from
// BC and writing to normal is how a category move would silently corrupt the
// wrong catalog.
expect(state.queries.some((q) => q.includes("catalog_items_bc"))).toBe(true);
expect(
state.queries.some(
(q) => q.startsWith("UPDATE") && !q.includes("catalog_items_bc"),
),
).toBe(false);
expect(state.audit).toHaveLength(0);
});
it("refuses stale prices and changed intent before writing", async () => {
const p = await previewBulkOffersCommand(input);
state.rows[0].costCredits = 100;
src/features/catalog/server/bulk-offers.ts
+38 -3
View File
@@ -25,6 +25,29 @@ import {
type Tx = Parameters<Parameters<typeof db.transaction>[0]>[0];
export type BulkCatalogKind = "normal" | "bc";
/**
* `catalog_items_bc` stores only a reference to the furniture: there are no
* cost, points, currency or offer_id columns on it at all. So BC bulk editing is
* a category move and nothing else — the other fields are refused here rather
* than reaching the database as an unknown-column error.
*/
const BC_FIELD_LABELS: Record<string, string> = {
costCredits: "price",
costPoints: "points",
pointsType: "currency",
};
function assertEditableFields(input: BulkOfferInput, kind: BulkCatalogKind) {
if (kind !== "bc") return;
const refused = Object.keys(input.changes).filter(
(key) => BC_FIELD_LABELS[key] !== undefined,
);
if (refused.length)
throw new CatalogInputError(
`A Builder Club offer has no ${refused.map((key) => BC_FIELD_LABELS[key]).join(" or ")}. It can only be moved to another category.`,
);
}
/**
* The BC catalog has the same offer columns under a second table, so bulk
* editing is a table choice rather than a second code path. Only normal offers
@@ -46,7 +69,11 @@ async function readOffers(
): Promise<OfferRow[]> {
const offers = rowsFrom<OfferRow>(
await tx.execute(
sql`SELECT id, catalog_name AS catalogName, page_id AS pageId, cost_credits AS costCredits, cost_points AS costPoints, points_type AS pointsType FROM ${offerTable(kind)} WHERE id IN (${sql.join(ids, sql`, `)}) ORDER BY id ${lock ? sql`FOR UPDATE` : sql``}`,
sql`SELECT id, catalog_name AS catalogName, page_id AS pageId ${
kind === "bc"
? sql`, 0 AS costCredits, 0 AS costPoints, 0 AS pointsType`
: sql`, cost_credits AS costCredits, cost_points AS costPoints, points_type AS pointsType`
} FROM ${offerTable(kind)} WHERE id IN (${sql.join(ids, sql`, `)}) ORDER BY id ${lock ? sql`FOR UPDATE` : sql``}`,
),
).map((row) => ({
...row,
@@ -126,6 +153,7 @@ export async function previewBulkOffersCommand(
kind: BulkCatalogKind = "normal",
): Promise<BulkOfferPreview> {
const input = bulkOfferInputSchema.parse(value);
assertEditableFields(input, kind);
return db.transaction(async (tx) => {
const offers = await readOffers(tx, input.ids, kind);
return preview(input, offers, await readPages(tx, offers, input, kind));
@@ -139,6 +167,7 @@ export async function applyBulkOffersCommand(
kind: BulkCatalogKind = "normal",
) {
const input = bulkOfferInputSchema.parse(value);
assertEditableFields(input, kind);
if (!/^[a-f0-9]{64}$/.test(fingerprint))
throw new CatalogInputError("A valid preview is required");
const work = async (tx: Tx, operationId?: string) => {
@@ -163,10 +192,16 @@ export async function applyBulkOffersCommand(
for (const row of result.rows) {
const changes = (
Object.keys(input.changes) as Array<keyof BulkOfferValues>
).filter((key) => row.before[key] !== row.after[key]);
).filter(
(key) =>
// `assertEditableFields` already refused these, so a BC update
// only ever writes page_id.
(kind !== "bc" || key === "pageId") &&
row.before[key] !== row.after[key],
);
if (!changes.length) continue;
await tx.execute(
sql`UPDATE catalog_items SET ${sql.join(
sql`UPDATE ${offerTable(kind)} SET ${sql.join(
changes.map(
(key) =>
sql`${sql.identifier(columns[key])}=${key === "pageId" ? String(row.after[key]) : row.after[key]}`,
src/features/catalog/server/item-deletes.test.ts
+122 -3
View File
@@ -44,6 +44,19 @@ const state = vi.hoisted(() => ({
// Categories that still exist; a restore must not write offers onto
// categories that are gone.
pages: [4] as number[],
// The BC table has six columns and no prices at all, which is exactly why it
// needs its own column list rather than a filtered subset of the normal one.
bcRows: [
{
id: 5,
itemIds: "50",
pageId: 7,
catalogName: "BC Chair",
orderNumber: 1,
extradata: "",
},
] as Array<Record<string, unknown>>,
bcPages: [7] as number[],
audit: [] as Array<{
id: number;
action: string;
@@ -97,15 +110,20 @@ vi.mock("@/lib/db", async () => {
},
transaction: async (fn: (tx: unknown) => Promise<unknown>) => {
const rowsBefore = structuredClone(state.rows);
const bcRowsBefore = structuredClone(state.bcRows);
const auditBefore = structuredClone(state.audit);
const pagesBefore = [...state.pages];
const bcPagesBefore = [...state.bcPages];
try {
return await fn({
execute: async (query: SQL) => {
const { text, params } = run(query);
const isBc = text.includes("_bc");
const rows = isBc ? state.bcRows : state.rows;
if (text.startsWith("SELECT") && text.includes("catalog_pages")) {
const pool = isBc ? state.bcPages : state.pages;
return [
state.pages
pool
.filter((id) =>
params.some((param) => Number(param) === id),
)
@@ -114,16 +132,25 @@ vi.mock("@/lib/db", async () => {
];
}
if (text.startsWith("SELECT") && text.includes("catalog_items")) {
const wanted = text.includes("FROM catalog_items WHERE id IN");
const wanted = /FROM catalog_items(_bc)? WHERE id IN/.test(
text,
);
return [
wanted
? state.rows.filter((row) =>
? rows.filter((row) =>
params.some((param) => Number(param) === row.id),
)
: [],
[],
];
}
if (text.startsWith("DELETE FROM catalog_items_bc")) {
for (const param of params)
state.bcRows = state.bcRows.filter(
(row) => row.id !== Number(param),
);
return [{ affectedRows: params.length }, []];
}
if (text.startsWith("DELETE FROM catalog_items")) {
for (const param of params)
state.rows = state.rows.filter(
@@ -131,6 +158,23 @@ vi.mock("@/lib/db", async () => {
);
return [{ affectedRows: params.length }, []];
}
if (text.startsWith("INSERT INTO catalog_items_bc")) {
// Read the column names back out of the statement, so a
// column the BC table does not have fails the test.
const columns = text.slice(
text.indexOf("(") + 1,
text.indexOf(") VALUES"),
);
const names = columns
.split(",")
.map((name) => name.trim().replace(/`/g, ""));
state.bcRows.push(
Object.fromEntries(
names.map((name, index) => [name, params[index]]),
),
);
return [{ affectedRows: 1 }, []];
}
if (text.startsWith("INSERT INTO catalog_items")) {
state.rows.push({
id: Number(params[0]),
@@ -196,6 +240,8 @@ vi.mock("@/lib/db", async () => {
state.rows = rowsBefore;
state.audit = auditBefore;
state.pages = pagesBefore;
state.bcRows = bcRowsBefore;
state.bcPages = bcPagesBefore;
state.rollbacks++;
throw error;
}
@@ -268,6 +314,17 @@ beforeEach(() => {
] as typeof state.rows);
state.audit = [];
state.pages = [4];
state.bcRows = [
{
id: 5,
itemIds: "50",
pageId: 7,
catalogName: "BC Chair",
orderNumber: 1,
extradata: "",
},
];
state.bcPages = [7];
state.queries = [];
state.nextAuditId = 900;
state.failInsert = false;
@@ -396,6 +453,68 @@ it("skips a corrupt record instead of failing the whole list", async () => {
expect(listed.map((row) => row.offers)).toEqual([1]);
});
it("deletes and restores a BC offer without touching the normal table", async () => {
const { deleted, restoreId } = await deleteCatalogItemsCommand(
[5],
7,
undefined,
"bc",
);
expect(deleted).toBe(1);
expect(state.bcRows).toHaveLength(0);
// The normal catalog is a different table and must be untouched.
expect(state.rows.map((row) => row.id)).toEqual([1, 2]);
expect(state.audit.at(-1)?.target).toBe("catalog_items_bc");
const restored = await restoreDeletedCatalogItemsCommand(restoreId, 7);
expect(restored.restored).toBe(1);
// Column names, because that is what the INSERT carries: proving the restore
// writes the real columns is the point of the BC path existing separately.
expect(state.bcRows[0]).toMatchObject({
id: 5,
item_ids: "50",
// Numbers stay numbers through the audit JSON round trip.
page_id: 7,
catalog_name: "BC Chair",
order_number: 1,
});
// Exactly the six columns the BC table has. A price column here would be an
// unknown-column error against a real database.
expect(Object.keys(state.bcRows[0]).sort()).toEqual([
"catalog_name",
"extradata",
"id",
"item_ids",
"order_number",
"page_id",
]);
});
it("refuses a BC restore whose category is gone", async () => {
const { restoreId } = await deleteCatalogItemsCommand(
[5],
7,
undefined,
"bc",
);
state.bcPages = [];
await expect(restoreDeletedCatalogItemsCommand(restoreId, 7)).rejects.toThrow(
/no longer exist/,
);
expect(state.bcRows).toHaveLength(0);
});
it("lists BC and normal deletions side by side", async () => {
await deleteCatalogItemsCommand([1], 7);
await deleteCatalogItemsCommand([5], 7, undefined, "bc");
const listed = await listRestorableDeletionsCommand();
expect(listed.map((row) => row.catalog)).toEqual(["bc", "normal"]);
});
it("deletes nothing when part of the selection is already gone", async () => {
await expect(deleteCatalogItemsCommand([1, 99], 7)).rejects.toThrow();
expect(state.rows.map((row) => row.id)).toEqual([1, 2]);
src/features/catalog/server/item-deletes.ts
+84 -28
View File
@@ -12,7 +12,15 @@ import { CatalogInputError, CatalogNotFound } from "../domain/hierarchy";
* have reused the id. So the full row is serialised into the audit log at delete
* time and the restore is a re-insert of that exact row.
*/
const RESTORE_COLUMNS = [
export type ItemCatalog = "normal" | "bc";
/**
* The BC table stores only a reference to the furniture — no price, limit or
* membership columns exist there. Reading or writing them would be an unknown
* column error, so the two catalogs get their own column list rather than one
* that silently drops fields.
*/
const NORMAL_COLUMNS = [
"id",
"itemIds",
"pageId",
@@ -31,13 +39,34 @@ const RESTORE_COLUMNS = [
"clubOnly",
] as const;
type DeletedOffer = Record<(typeof RESTORE_COLUMNS)[number], string | number>;
const BC_COLUMNS = [
"id",
"itemIds",
"pageId",
"catalogName",
"orderNumber",
"extradata",
] as const;
function columnsFor(catalog: ItemCatalog): readonly string[] {
return catalog === "bc" ? BC_COLUMNS : NORMAL_COLUMNS;
}
function offersTable(catalog: ItemCatalog) {
return catalog === "bc" ? "catalog_items_bc" : "catalog_items";
}
function pagesTable(catalog: ItemCatalog) {
return catalog === "bc" ? "catalog_pages_bc" : "catalog_pages";
}
type DeletedOffer = Record<string, string | number>;
/**
* `haveOffer` is camelCase in the database itself; every other column is
* snake_case, so the mapping is written out once rather than derived per call.
*/
const COLUMN_SQL_NAMES: Record<(typeof RESTORE_COLUMNS)[number], string> = {
const COLUMN_SQL_NAMES: Record<(typeof NORMAL_COLUMNS)[number], string> = {
id: "id",
itemIds: "item_ids",
pageId: "page_id",
@@ -56,24 +85,41 @@ const COLUMN_SQL_NAMES: Record<(typeof RESTORE_COLUMNS)[number], string> = {
clubOnly: "club_only",
};
const RESTORE_IDS = sql.join(
RESTORE_COLUMNS.map((key) => sql.identifier(COLUMN_SQL_NAMES[key])),
sql`, `,
);
function deletedOfferSelect() {
function restoreIds(catalog: ItemCatalog) {
return sql.join(
RESTORE_COLUMNS.map(
(key) =>
sql`${sql.identifier(COLUMN_SQL_NAMES[key])} AS ${sql.identifier(key)}`,
columnsFor(catalog).map((key) =>
sql.identifier(COLUMN_SQL_NAMES[key as keyof typeof COLUMN_SQL_NAMES]),
),
sql`, `,
);
}
const DELETE_ACTION = "catalog_items_delete_restore";
function deletedOfferSelect(catalog: ItemCatalog) {
return sql.join(
columnsFor(catalog).map(
(key) =>
sql`${sql.identifier(COLUMN_SQL_NAMES[key as keyof typeof COLUMN_SQL_NAMES])} AS ${sql.identifier(key)}`,
),
sql`, `,
);
}
function parseOffers(raw: string | null): DeletedOffer[] {
/**
* The catalog is encoded in the action and target columns rather than inferred
* from the payload, so a restore can never re-insert a BC row into the normal
* offers table.
*/
function deleteAction(catalog: ItemCatalog) {
return `${offersTable(catalog)}_delete_restore`;
}
function catalogFromTarget(target: string): ItemCatalog | null {
if (target === "catalog_items_bc") return "bc";
if (target === "catalog_items") return "normal";
return null;
}
function parseOffers(raw: string | null, catalog: ItemCatalog): DeletedOffer[] {
let value: unknown;
try {
value = JSON.parse(raw ?? "null");
@@ -86,7 +132,7 @@ function parseOffers(raw: string | null): DeletedOffer[] {
throw Error("unavailable");
}
const record = row as Record<string, unknown>;
if (!RESTORE_COLUMNS.every((key) => key in record)) {
if (!columnsFor(catalog).every((key) => key in record)) {
throw Error("unavailable");
}
}
@@ -101,6 +147,7 @@ export async function deleteCatalogItemsCommand(
ids: number[],
userId: number,
requestKey: string = randomUUID(),
catalog: ItemCatalog = "normal",
) {
const selection = [...new Set(ids)].sort((a, b) => a - b);
if (
@@ -114,12 +161,14 @@ export async function deleteCatalogItemsCommand(
actorId: userId,
kind: "catalog.items.delete",
key: requestKey,
input: { ids: selection },
// The catalog is part of the request identity: one delete key replayed
// against the other catalog is not the same work.
input: { ids: selection, catalog },
},
async (tx, operationId) => {
const removed = rowsFrom<DeletedOffer>(
await tx.execute(
sql`SELECT ${deletedOfferSelect()} FROM catalog_items WHERE id IN (${sql.join(
sql`SELECT ${deletedOfferSelect(catalog)} FROM ${sql.raw(offersTable(catalog))} WHERE id IN (${sql.join(
selection,
sql`, `,
)}) ORDER BY id FOR UPDATE`,
@@ -133,12 +182,12 @@ export async function deleteCatalogItemsCommand(
"Some selected offers were already deleted. Reload the selection.",
);
await tx.execute(
sql`DELETE FROM catalog_items WHERE id IN (${sql.join(selection, sql`, `)})`,
sql`DELETE FROM ${sql.raw(offersTable(catalog))} WHERE id IN (${sql.join(selection, sql`, `)})`,
);
const inserted = await tx.insert(AdminAuditLog).values({
userId,
action: DELETE_ACTION,
target: "catalog_items",
action: deleteAction(catalog),
target: offersTable(catalog),
targetId: null,
details: JSON.stringify(getOperationContext()),
before: JSON.stringify(removed),
@@ -165,6 +214,7 @@ export async function deleteCatalogItemsCommand(
*/
export interface RestorableDeletion {
restoreId: number;
catalog: ItemCatalog;
offers: number;
deletedAt: string;
staffId: number;
@@ -177,19 +227,23 @@ export async function listRestorableDeletionsCommand(
const rows = rowsFrom<{
id: number;
userId: number;
target: string;
before: string | null;
createdAt: string;
}>(
await db.execute(
sql`SELECT id, user_id AS userId, before, created_at AS createdAt FROM ${AdminAuditLog} WHERE action=${DELETE_ACTION} ORDER BY id DESC LIMIT ${capped}`,
sql`SELECT id, user_id AS userId, target, before, created_at AS createdAt FROM ${AdminAuditLog} WHERE action IN (${deleteAction("normal")}, ${deleteAction("bc")}) ORDER BY id DESC LIMIT ${capped}`,
),
);
const entries: RestorableDeletion[] = [];
for (const row of rows) {
const catalog = catalogFromTarget(String(row.target));
if (catalog === null) continue;
try {
entries.push({
restoreId: Number(row.id),
offers: parseOffers(row.before).length,
catalog,
offers: parseOffers(row.before, catalog).length,
deletedAt: String(row.createdAt ?? ""),
staffId: Number(row.userId),
});
@@ -223,13 +277,14 @@ export async function restoreDeletedCatalogItemsCommand(
.from(AdminAuditLog)
.where(sql`${AdminAuditLog.id}=${restoreId} FOR UPDATE`)
.limit(1);
if (!entry || entry.action !== DELETE_ACTION)
const catalog = entry ? catalogFromTarget(entry.target) : null;
if (!entry || catalog === null || entry.action !== deleteAction(catalog))
throw new CatalogNotFound("This deletion can no longer be restored");
const offers = parseOffers(entry.before);
const offers = parseOffers(entry.before, catalog);
const ids = offers.map((offer) => Number(offer.id));
const taken = rowsFrom<{ id: number }>(
await tx.execute(
sql`SELECT id FROM catalog_items WHERE id IN (${sql.join(ids, sql`, `)}) ORDER BY id FOR UPDATE`,
sql`SELECT id FROM ${sql.raw(offersTable(catalog))} WHERE id IN (${sql.join(ids, sql`, `)}) ORDER BY id FOR UPDATE`,
),
);
if (taken.length)
@@ -248,7 +303,7 @@ export async function restoreDeletedCatalogItemsCommand(
const found = new Set(
rowsFrom<{ id: number }>(
await tx.execute(
sql`SELECT id FROM catalog_pages WHERE id IN (${sql.join(pageIds, sql`, `)}) ORDER BY id FOR UPDATE`,
sql`SELECT id FROM ${sql.raw(pagesTable(catalog))} WHERE id IN (${sql.join(pageIds, sql`, `)}) ORDER BY id FOR UPDATE`,
),
).map((row) => Number(row.id)),
);
@@ -258,10 +313,11 @@ export async function restoreDeletedCatalogItemsCommand(
`These categories no longer exist, so the offers would be unreachable: ${missing.join(", ")}. Restore was not applied.`,
);
}
const keys = columnsFor(catalog);
for (const offer of offers) {
await tx.execute(
sql`INSERT INTO catalog_items (${RESTORE_IDS}) VALUES (${sql.join(
RESTORE_COLUMNS.map((key) => sql`${offer[key]}`),
sql`INSERT INTO ${sql.raw(offersTable(catalog))} (${restoreIds(catalog)}) VALUES (${sql.join(
keys.map((key) => sql`${offer[key]}`),
sql`, `,
)})`,
);