openhands
d6af754211
The maintenance "Fix alles" now collapses catalog_pages that share the same caption_save + parent_id into a single survivor (moving catalog_items and reparenting child pages before deleting duplicates), so the catalog tree never renders double links. The duplicate-page count is also surfaced in the health panel.
643 lines
21 KiB
TypeScript
643 lines
21 KiB
TypeScript
import { sql } from "drizzle-orm";
|
|
import { db } from "@/lib/db";
|
|
import {
|
|
type CatalogOfferRebuildResult,
|
|
type FurniDataReconcileResult,
|
|
readFurniData,
|
|
rebuildCatalogOfferIds,
|
|
reconcileFurniDataWithItemsBase,
|
|
type SpriteIdVerifyResult,
|
|
verifyAndFixSpriteIds,
|
|
withFurniDataLock,
|
|
} from "@/lib/services/furni-data";
|
|
|
|
/**
|
|
* Catalog maintenance toolkit.
|
|
*
|
|
* The Catalog studio (and the raw furnidata import) already keep ids consistent
|
|
* on the happy path, but legacy rows / manual edits can drift. This module
|
|
* exposes safe, transaction-wrapped operations that the admin "Catalog
|
|
* maintenance" page triggers. Every mutating call has a `preview` (count-only)
|
|
* mode and an `apply` mode, and all writes run inside a single InnoDB
|
|
* transaction so a failure rolls back completely.
|
|
*/
|
|
|
|
/** Integer foreign-key columns that store a base id (item_id / sprite_id). */
|
|
const INT_COLS: Array<[string, string]> = [
|
|
["items", "item_id"],
|
|
["room_templates_items", "item_id"],
|
|
["catalog_items_limited", "item_id"],
|
|
["crafting_recipes_ingredients", "item_id"],
|
|
["items_crackable", "item_id"],
|
|
["gift_wrappers", "sprite_id"],
|
|
["gift_wrappers", "item_id"],
|
|
["trax_playlist", "item_id"],
|
|
["pet_drinks", "item_id"],
|
|
["pet_foods", "item_id"],
|
|
["pet_items", "item_id"],
|
|
["marketplace_items", "item_id"],
|
|
["calendar_rewards", "item_id"],
|
|
["builders_club_items", "item_id"],
|
|
["youtube_playlists", "item_id"],
|
|
["room_trax_playlist", "item_id"],
|
|
["recycler_prizes", "item_id"],
|
|
["website_event_prizes", "item_id"],
|
|
["website_rare_values", "item_id"],
|
|
["catalog_products", "item_id"],
|
|
["room_trade_log_items", "item_id"],
|
|
["logs_economy", "item_id"],
|
|
];
|
|
|
|
/** String columns that hold a single numeric base id. */
|
|
const STR_COLS: Array<[string, string]> = [
|
|
["catalog_items", "item_ids"],
|
|
["catalog_items_bc", "item_ids"],
|
|
["logs_shop_purchases", "item_ids"],
|
|
["catalog_version_offers", "item_ids"],
|
|
];
|
|
|
|
type Rows<T> = [T[], unknown];
|
|
|
|
async function query<T>(q: unknown): Promise<T[]> {
|
|
const [rows] = (await db.execute(q as never)) as unknown as Rows<T>;
|
|
return rows ?? [];
|
|
}
|
|
|
|
async function exists(table: string): Promise<boolean> {
|
|
const rows = await query<{ c: number }>(sql`SELECT COUNT(*) c
|
|
FROM information_schema.TABLES
|
|
WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ${table}`);
|
|
return Number(rows[0]?.c ?? 0) > 0;
|
|
}
|
|
|
|
/** Pre-resolve each string column's charset/collation so JOINs never mix them. */
|
|
async function loadCollationMap(): Promise<Map<string, [string, string]>> {
|
|
const map = new Map<string, [string, string]>();
|
|
for (const [table, col] of STR_COLS) {
|
|
if (!(await exists(table))) continue;
|
|
const rows = await query<{
|
|
CHARACTER_SET_NAME: string | null;
|
|
COLLATION_NAME: string | null;
|
|
}>(sql`
|
|
SELECT CHARACTER_SET_NAME, COLLATION_NAME
|
|
FROM information_schema.COLUMNS
|
|
WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ${table} AND COLUMN_NAME = ${col}`);
|
|
const r = rows[0];
|
|
if (r?.CHARACTER_SET_NAME)
|
|
map.set(`${table}.${col}`, [
|
|
r.CHARACTER_SET_NAME,
|
|
r.COLLATION_NAME ?? r.CHARACTER_SET_NAME,
|
|
]);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
/** Convert a numeric expression to CHAR in the column's own charset/collation. */
|
|
function numToStr(
|
|
map: Map<string, [string, string]>,
|
|
table: string,
|
|
col: string,
|
|
expr: string,
|
|
): string {
|
|
const info = map.get(`${table}.${col}`);
|
|
if (!info) return `CAST(${expr} AS CHAR)`;
|
|
return `CONVERT(${expr}, CHAR CHARACTER SET ${info[0]}) COLLATE ${info[1]}`;
|
|
}
|
|
|
|
export interface FurniHealth {
|
|
itemsBaseTotal: number;
|
|
spriteIdMismatch: number;
|
|
catalogOfferMismatch: number;
|
|
duplicateClassnames: number;
|
|
idMismatchVsFurnidata: number;
|
|
catalogDuplicates: number;
|
|
catalogBcDuplicates: number;
|
|
catalogPageDuplicates: number;
|
|
}
|
|
|
|
/** Read-only snapshot of how far the furniture tables have drifted. */
|
|
export async function getFurniHealth(): Promise<FurniHealth> {
|
|
const [ib] = await query<{ c: number }>(
|
|
sql`SELECT COUNT(*) c FROM items_base`,
|
|
);
|
|
const [sp] = await query<{ c: number }>(
|
|
sql`SELECT COUNT(*) c FROM items_base WHERE sprite_id <> id`,
|
|
);
|
|
const [co] = await query<{ c: number }>(
|
|
sql`SELECT COUNT(*) c FROM catalog_items WHERE offer_id <> id`,
|
|
);
|
|
const [dc] = await query<{ c: number }>(sql`
|
|
SELECT COUNT(*) c FROM (
|
|
SELECT item_name FROM items_base GROUP BY item_name HAVING COUNT(*) > 1
|
|
) g`);
|
|
|
|
const CAT_DUP_COLS = ["page_id", "item_ids"];
|
|
const BC_DUP_COLS = ["page_id", "item_ids", "catalog_name", "extradata"];
|
|
const catCols = CAT_DUP_COLS.join(",");
|
|
const bcCols = BC_DUP_COLS.join(",");
|
|
const [cd] = await query<{ c: number }>(sql`
|
|
SELECT COUNT(*) c FROM (
|
|
SELECT ${sql.raw(catCols)} FROM catalog_items
|
|
GROUP BY ${sql.raw(catCols)} HAVING COUNT(*) > 1
|
|
) g`);
|
|
const [cdb] = await query<{ c: number }>(sql`
|
|
SELECT COUNT(*) c FROM (
|
|
SELECT ${sql.raw(bcCols)} FROM catalog_items_bc
|
|
GROUP BY ${sql.raw(bcCols)} HAVING COUNT(*) > 1
|
|
) g`);
|
|
|
|
const [cpd] = await query<{ c: number }>(sql`
|
|
SELECT COUNT(*) c FROM (
|
|
SELECT caption_save, parent_id FROM catalog_pages
|
|
WHERE caption_save <> ''
|
|
GROUP BY caption_save, parent_id HAVING COUNT(*) > 1
|
|
) g`);
|
|
|
|
const furniData = (await readFurniData()) as Record<
|
|
string,
|
|
{ furnitype?: Array<{ id?: unknown; classname?: unknown }> }
|
|
>;
|
|
const desired = new Map<string, number>();
|
|
for (const section of ["roomitemtypes", "wallitemtypes"] as const) {
|
|
for (const e of furniData[section]?.furnitype ?? []) {
|
|
const cn = typeof e?.classname === "string" ? e.classname : "";
|
|
const id = Number(e?.id);
|
|
if (cn && Number.isFinite(id) && id > 0 && !desired.has(cn)) {
|
|
desired.set(cn, id);
|
|
}
|
|
}
|
|
}
|
|
const rows = await query<{ id: number; item_name: string }>(
|
|
sql`SELECT id, item_name FROM items_base`,
|
|
);
|
|
let idMismatch = 0;
|
|
for (const r of rows) {
|
|
const target = desired.get(r.item_name);
|
|
if (target !== undefined && target !== r.id) idMismatch++;
|
|
}
|
|
|
|
return {
|
|
itemsBaseTotal: Number(ib?.c ?? 0),
|
|
spriteIdMismatch: Number(sp?.c ?? 0),
|
|
catalogOfferMismatch: Number(co?.c ?? 0),
|
|
duplicateClassnames: Number(dc?.c ?? 0),
|
|
idMismatchVsFurnidata: idMismatch,
|
|
catalogDuplicates: Number(cd?.c ?? 0),
|
|
catalogBcDuplicates: Number(cdb?.c ?? 0),
|
|
catalogPageDuplicates: Number(cpd?.c ?? 0),
|
|
};
|
|
}
|
|
|
|
export interface FixSpriteResult extends SpriteIdVerifyResult {}
|
|
export interface FixOfferResult extends CatalogOfferRebuildResult {}
|
|
export interface ReconcileResult extends FurniDataReconcileResult {}
|
|
|
|
/** Fix items_base.sprite_id -> id (only where furnidata agrees). */
|
|
export async function fixSpriteIds(): Promise<FixSpriteResult> {
|
|
return verifyAndFixSpriteIds();
|
|
}
|
|
|
|
/** Force catalog_items.offer_id -> id (emulator offer lookup stays correct). */
|
|
export async function fixCatalogOffers(): Promise<FixOfferResult> {
|
|
return rebuildCatalogOfferIds();
|
|
}
|
|
|
|
/** Make FurnitureData.json ids/offerids agree with items_base (items_base authoritative). */
|
|
export async function reconcileIds(): Promise<ReconcileResult> {
|
|
return reconcileFurniDataWithItemsBase();
|
|
}
|
|
|
|
export interface DedupResult {
|
|
groups: number;
|
|
removed: number;
|
|
remapped: number;
|
|
catalogRemoved: number;
|
|
catalogBcRemoved: number;
|
|
catalogPageRemoved: number;
|
|
}
|
|
|
|
export interface CatalogPageDedupResult {
|
|
groups: number;
|
|
removed: number;
|
|
remapped: number;
|
|
}
|
|
|
|
/**
|
|
* Collapse duplicate catalog_pages that share the same (caption_save, parent_id)
|
|
* into a single survivor so the catalog tree never renders double links. The
|
|
* lowest id wins; its catalog_items (and builder-club items) are moved onto the
|
|
* survivor and any child pages are reparented to it, then the duplicates are
|
|
* deleted. Every write runs inside one transaction.
|
|
*/
|
|
export async function dedupeCatalogPages(): Promise<CatalogPageDedupResult> {
|
|
const groups = await query<{ caption_save: string; parent_id: number }>(sql`
|
|
SELECT caption_save, parent_id
|
|
FROM catalog_pages
|
|
WHERE caption_save <> ''
|
|
GROUP BY caption_save, parent_id
|
|
HAVING COUNT(*) > 1`);
|
|
if (groups.length === 0) return { groups: 0, removed: 0, remapped: 0 };
|
|
|
|
let removed = 0;
|
|
let remapped = 0;
|
|
await withFurniDataLock(async () => {
|
|
await db.transaction(async (tx) => {
|
|
for (const g of groups) {
|
|
const pages = await query<{ id: number }>(sql`
|
|
SELECT id FROM catalog_pages
|
|
WHERE caption_save = ${g.caption_save} AND parent_id = ${g.parent_id}
|
|
ORDER BY id ASC`);
|
|
if (pages.length < 2) continue;
|
|
const [winner, ...losers] = pages.map((p) => p.id);
|
|
for (const loser of losers) {
|
|
const ci = (await tx.execute(sql`
|
|
UPDATE catalog_items SET page_id = ${winner} WHERE page_id = ${loser}`)) as unknown as [
|
|
Record<string, unknown>,
|
|
unknown,
|
|
];
|
|
remapped += Number(ci[0]?.affectedRows ?? 0);
|
|
if (await exists("catalog_items_bc")) {
|
|
const bci = (await tx.execute(sql`
|
|
UPDATE catalog_items_bc SET page_id = ${winner} WHERE page_id = ${loser}`)) as unknown as [
|
|
Record<string, unknown>,
|
|
unknown,
|
|
];
|
|
remapped += Number(bci[0]?.affectedRows ?? 0);
|
|
}
|
|
// Keep any child pages by reparenting them onto the survivor.
|
|
await tx.execute(sql`
|
|
UPDATE catalog_pages SET parent_id = ${winner} WHERE parent_id = ${loser}`);
|
|
await tx.execute(sql`DELETE FROM catalog_pages WHERE id = ${loser}`);
|
|
removed++;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
return { groups: groups.length, removed, remapped };
|
|
}
|
|
|
|
/**
|
|
* Remove duplicate items_base rows that share the same item_name (classname).
|
|
* The lowest id in each group is kept; every referencing int/string column is
|
|
* remapped from the duplicate ids onto the keeper id, then the duplicates are
|
|
* deleted. All inside one transaction.
|
|
*/
|
|
export async function removeDuplicateItemsBase(): Promise<DedupResult> {
|
|
return withFurniDataLock(async () => {
|
|
// Fetch every row whose classname is duplicated (no GROUP_CONCAT, so it
|
|
// stays correct even for very large duplicate groups).
|
|
const dupRows = await query<{ id: number; item_name: string }>(sql`
|
|
SELECT b.id, b.item_name FROM items_base b
|
|
WHERE b.item_name IN (
|
|
SELECT item_name FROM items_base GROUP BY item_name HAVING COUNT(*) > 1
|
|
)
|
|
ORDER BY b.item_name, b.id`);
|
|
|
|
const groups = new Map<string, number[]>();
|
|
for (const r of dupRows) {
|
|
const arr = groups.get(r.item_name) ?? [];
|
|
arr.push(r.id);
|
|
groups.set(r.item_name, arr);
|
|
}
|
|
const groupList = [...groups.entries()].map(([item_name, ids]) => ({
|
|
item_name,
|
|
keeper: ids[0],
|
|
ids,
|
|
}));
|
|
|
|
const activeInt = (
|
|
await Promise.all(
|
|
INT_COLS.map(async ([t, c]) =>
|
|
(await exists(t)) ? ([t, c] as [string, string]) : null,
|
|
),
|
|
)
|
|
).filter(Boolean) as [string, string][];
|
|
const activeStr = (
|
|
await Promise.all(
|
|
STR_COLS.map(async ([t, c]) =>
|
|
(await exists(t)) ? ([t, c] as [string, string]) : null,
|
|
),
|
|
)
|
|
).filter(Boolean) as [string, string][];
|
|
|
|
let removed = 0;
|
|
let remapped = 0;
|
|
|
|
await db.transaction(async (tx) => {
|
|
await tx.execute(sql`SET FOREIGN_KEY_CHECKS = 0`);
|
|
for (const g of groupList) {
|
|
const ids = g.ids.filter((x) => x !== g.keeper);
|
|
for (const dupId of ids) {
|
|
for (const [table, col] of activeInt) {
|
|
const r = (await tx.execute(
|
|
sql`UPDATE ${sql.raw(table)} t SET ${sql.raw(col)} = ${g.keeper} WHERE ${sql.raw(col)} = ${dupId}`,
|
|
)) as unknown as [Record<string, unknown>, unknown];
|
|
remapped += Number(r[0]?.affectedRows ?? 0);
|
|
}
|
|
for (const [table, col] of activeStr) {
|
|
const from = String(dupId);
|
|
const to = String(g.keeper);
|
|
await tx.execute(
|
|
sql.raw(
|
|
`UPDATE ${table} t SET ${col} = TRIM(BOTH ',' FROM REPLACE(CONCAT(',', ${col}, ','), CONCAT(',', '${from}', ','), CONCAT(',', '${to}', ','))) WHERE CONCAT(',', ${col}, ',') LIKE '%,${from},%'`,
|
|
),
|
|
);
|
|
}
|
|
await tx.execute(sql`DELETE FROM items_base WHERE id = ${dupId}`);
|
|
removed++;
|
|
}
|
|
}
|
|
await tx.execute(sql`SET FOREIGN_KEY_CHECKS = 1`);
|
|
});
|
|
|
|
return {
|
|
groups: groupList.length,
|
|
removed,
|
|
remapped,
|
|
catalogRemoved: 0,
|
|
catalogBcRemoved: 0,
|
|
catalogPageRemoved: 0,
|
|
};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Remove duplicate rows from a catalog table. Two rows are duplicates when they
|
|
* are the exact same product on the same page (identical page_id, item_ids,
|
|
* catalog_name and every cost/limit/extra flag). The lowest id is kept, the rest
|
|
* deleted. No foreign keys reference catalog_items.id, so this is safe.
|
|
*/
|
|
async function dedupCatalogTable(table: string): Promise<number> {
|
|
if (!(await exists(table))) return 0;
|
|
const grp =
|
|
table === "catalog_items_bc"
|
|
? ["page_id", "item_ids", "catalog_name", "extradata"]
|
|
: ["page_id", "item_ids"];
|
|
const on = grp.map((c) => `t.${c} <=> d.${c}`).join(" AND ");
|
|
const r = (await db.execute(
|
|
sql.raw(
|
|
`DELETE t FROM ${table} t JOIN (SELECT ${grp.join(",")}, MIN(id) AS _keep FROM ${table} GROUP BY ${grp.join(",")} HAVING COUNT(*) > 1) d ON ${on} WHERE t.id <> d._keep`,
|
|
),
|
|
)) as unknown as [Record<string, unknown>, unknown];
|
|
return Number(r[0]?.affectedRows ?? 0);
|
|
}
|
|
|
|
/**
|
|
* Full duplicate cleanup: items_base (by classname) + catalog_pages (by
|
|
* caption_save + parent_id) + catalog_items / catalog_items_bc (by identical
|
|
* product on the same page). The page merge runs before the row dedup so items
|
|
* moved onto the survivor are still de-duplicated within the page afterwards.
|
|
*/
|
|
export async function removeDuplicates(): Promise<DedupResult> {
|
|
const ib = await removeDuplicateItemsBase();
|
|
const pageDedup = await dedupeCatalogPages();
|
|
const catalogRemoved = await dedupCatalogTable("catalog_items");
|
|
const catalogBcRemoved = await dedupCatalogTable("catalog_items_bc");
|
|
return {
|
|
...ib,
|
|
catalogPageRemoved: pageDedup.removed,
|
|
catalogRemoved,
|
|
catalogBcRemoved,
|
|
};
|
|
}
|
|
|
|
export interface AlignResult {
|
|
moves: number;
|
|
inserted: number;
|
|
skipped: string[];
|
|
}
|
|
|
|
/**
|
|
* Force items_base.id to equal the FurnitureData.json sprite id for every
|
|
* classname (FurnitureData is the source of truth). New classnames are inserted
|
|
* with their furnidata id; existing rows whose id differs are moved via a
|
|
* multi-pass primary-key swap that rewrites every referencing column so no
|
|
* foreign key / shop reference breaks. Mirrors scripts/align-db-ids-with-furnidata.ts.
|
|
*/
|
|
export async function forceItemsBaseIdsToFurnidata(
|
|
apply: boolean,
|
|
): Promise<AlignResult> {
|
|
const furniData = (await readFurniData()) as Record<
|
|
string,
|
|
{ furnitype?: Array<{ id?: unknown; classname?: unknown }> }
|
|
>;
|
|
|
|
const all: Array<{ classname: string; id: number }> = [];
|
|
for (const section of ["roomitemtypes", "wallitemtypes"] as const) {
|
|
for (const e of furniData[section]?.furnitype ?? []) {
|
|
const cn = typeof e?.classname === "string" ? e.classname : "";
|
|
const id = Number(e?.id);
|
|
if (cn && Number.isFinite(id) && id > 0) all.push({ classname: cn, id });
|
|
}
|
|
}
|
|
|
|
// Global iterative duplicate-id resolution (keep DB occupant, drop losers).
|
|
const desired = new Map<string, number>();
|
|
for (const e of all) {
|
|
if (!desired.has(e.classname)) desired.set(e.classname, e.id);
|
|
}
|
|
const rows = await query<{ id: number; item_name: string }>(
|
|
sql`SELECT id, item_name FROM items_base`,
|
|
);
|
|
const nameById = new Map<number, string>();
|
|
const idByName = new Map<string, number>();
|
|
let maxId = 0;
|
|
for (const r of rows) {
|
|
nameById.set(r.id, r.item_name);
|
|
idByName.set(r.item_name, r.id);
|
|
maxId = Math.max(maxId, r.id);
|
|
}
|
|
for (;;) {
|
|
const claims = new Map<number, string[]>();
|
|
for (const [cn, id] of desired) {
|
|
const arr = claims.get(id) ?? [];
|
|
arr.push(cn);
|
|
claims.set(id, arr);
|
|
}
|
|
let found = false;
|
|
for (const [id, claimants] of [...claims].sort((a, b) => a[0] - b[0])) {
|
|
if (claimants.length < 2) continue;
|
|
const live = claimants.filter((cn) => desired.get(cn) === id);
|
|
if (live.length < 2) continue;
|
|
found = true;
|
|
const dbHolder = nameById.get(id);
|
|
const winner =
|
|
dbHolder !== undefined && live.includes(dbHolder) ? dbHolder : live[0];
|
|
for (const cn of live) if (cn !== winner) desired.delete(cn);
|
|
}
|
|
if (!found) break;
|
|
}
|
|
|
|
let fresh = Math.max(maxId, ...desired.values()) + 1000;
|
|
const moves = new Map<number, number>();
|
|
for (const r of rows) {
|
|
const target = desired.get(r.item_name);
|
|
if (target !== undefined && target !== r.id) moves.set(r.id, target);
|
|
}
|
|
const occupied = new Map<number, true>(nameById.keys().map((k) => [k, true]));
|
|
for (;;) {
|
|
const dest = new Map<number, number>();
|
|
for (const t of moves.values()) dest.set(t, (dest.get(t) ?? 0) + 1);
|
|
let changed = false;
|
|
for (const [, target] of moves) {
|
|
if (!occupied.has(target) || moves.has(target)) continue;
|
|
const holder = nameById.get(target);
|
|
if (holder !== undefined && desired.get(holder) === target) continue;
|
|
moves.set(target, fresh++);
|
|
changed = true;
|
|
break;
|
|
}
|
|
if (!changed) break;
|
|
}
|
|
for (;;) {
|
|
let changed = false;
|
|
for (const [oldId, target] of moves) {
|
|
if (occupied.has(target) || moves.has(target)) continue;
|
|
const holder = nameById.get(target);
|
|
if (holder !== undefined && desired.get(holder) === target) {
|
|
moves.delete(oldId);
|
|
changed = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!changed) break;
|
|
}
|
|
|
|
if (!apply) {
|
|
return { moves: moves.size, inserted: 0, skipped: [] };
|
|
}
|
|
|
|
const activeInt = (
|
|
await Promise.all(
|
|
INT_COLS.map(async ([t, c]) =>
|
|
(await exists(t)) ? ([t, c] as [string, string]) : null,
|
|
),
|
|
)
|
|
).filter(Boolean) as [string, string][];
|
|
const activeStr = (
|
|
await Promise.all(
|
|
STR_COLS.map(async ([t, c]) =>
|
|
(await exists(t)) ? ([t, c] as [string, string]) : null,
|
|
),
|
|
)
|
|
).filter(Boolean) as [string, string][];
|
|
const collation = await loadCollationMap();
|
|
|
|
await withFurniDataLock(async () => {
|
|
await db.transaction(async (tx) => {
|
|
await tx.execute(sql`SET FOREIGN_KEY_CHECKS = 0`);
|
|
await tx.execute(sql`DROP TEMPORARY TABLE IF EXISTS _mm_id_map`);
|
|
await tx.execute(sql`CREATE TEMPORARY TABLE _mm_id_map (
|
|
old_id INT PRIMARY KEY, new_id INT NOT NULL, UNIQUE KEY uniq_new (new_id)
|
|
) ENGINE=InnoDB`);
|
|
|
|
const occupiedIds = new Map<number, true>(
|
|
nameById.keys().map((k) => [k, true]),
|
|
);
|
|
const pending = new Map(moves);
|
|
let scratch = fresh;
|
|
const applyPass = async (pairs: Array<[number, number]>) => {
|
|
if (pairs.length === 0) return;
|
|
await tx.execute(sql`TRUNCATE TABLE _mm_id_map`);
|
|
for (let i = 0; i < pairs.length; i += 500) {
|
|
const chunk = pairs.slice(i, i + 500);
|
|
await tx.execute(
|
|
sql`INSERT INTO _mm_id_map (old_id, new_id) VALUES ${sql.join(
|
|
chunk.map(([o, nw]) => sql`(${o}, ${nw})`),
|
|
sql`, `,
|
|
)}`,
|
|
);
|
|
}
|
|
await tx.execute(
|
|
sql`UPDATE items_base b JOIN _mm_id_map m ON b.id = m.old_id SET b.id = m.new_id`,
|
|
);
|
|
for (const [table, col] of activeInt) {
|
|
await tx.execute(
|
|
sql`UPDATE ${sql.raw(table)} t JOIN _mm_id_map m ON t.${sql.raw(col)} = m.old_id SET t.${sql.raw(col)} = m.new_id`,
|
|
);
|
|
}
|
|
for (const [table, col] of activeStr) {
|
|
await tx.execute(
|
|
sql`UPDATE ${sql.raw(table)} t JOIN _mm_id_map m ON t.${sql.raw(col)} = ${sql.raw(numToStr(collation, table, col, "m.old_id"))} SET t.${sql.raw(col)} = CAST(m.new_id AS CHAR)`,
|
|
);
|
|
}
|
|
for (const [o, nw] of pairs) {
|
|
occupiedIds.delete(o);
|
|
occupiedIds.set(nw, true);
|
|
}
|
|
};
|
|
|
|
while (pending.size > 0) {
|
|
const safe: Array<[number, number]> = [];
|
|
for (const [oldId, target] of pending) {
|
|
if (!occupiedIds.has(target)) safe.push([oldId, target]);
|
|
}
|
|
if (safe.length === 0) {
|
|
const oldest = Math.min(...pending.keys());
|
|
const target = pending.get(oldest);
|
|
if (target === undefined) break;
|
|
pending.delete(oldest);
|
|
await applyPass([[oldest, scratch]]);
|
|
pending.set(scratch, target);
|
|
scratch++;
|
|
continue;
|
|
}
|
|
await applyPass(safe);
|
|
for (const [oldId] of safe) pending.delete(oldId);
|
|
}
|
|
|
|
await tx.execute(sql`SET FOREIGN_KEY_CHECKS = 1`);
|
|
await tx.execute(sql`DROP TEMPORARY TABLE IF EXISTS _mm_id_map`);
|
|
});
|
|
});
|
|
|
|
// Insert missing classnames with their exact furnidata id.
|
|
let inserted = 0;
|
|
const skipped: string[] = [];
|
|
const currentIds = new Set(
|
|
(await query<{ id: number }>(sql`SELECT id FROM items_base`)).map(
|
|
(r) => r.id,
|
|
),
|
|
);
|
|
for (const [cn, id] of desired) {
|
|
if (idByName.has(cn)) continue;
|
|
if (currentIds.has(id)) {
|
|
skipped.push(`${cn} (id ${id} occupied)`);
|
|
continue;
|
|
}
|
|
await db.execute(
|
|
sql`INSERT INTO items_base (id, item_name, sprite_id) VALUES (${id}, ${cn}, ${id})`,
|
|
);
|
|
currentIds.add(id);
|
|
inserted++;
|
|
}
|
|
|
|
await db.execute(
|
|
sql`UPDATE items_base SET sprite_id = id WHERE sprite_id <> id`,
|
|
);
|
|
|
|
return { moves: moves.size, inserted, skipped };
|
|
}
|
|
|
|
export interface FixAllResult {
|
|
healthBefore: FurniHealth;
|
|
sprite: FixSpriteResult;
|
|
offers: FixOfferResult;
|
|
reconcile: ReconcileResult;
|
|
dedup: DedupResult;
|
|
align: AlignResult;
|
|
healthAfter: FurniHealth;
|
|
}
|
|
|
|
/** Run every repair in a sensible order, then return before/after health. */
|
|
export async function fixEverything(): Promise<FixAllResult> {
|
|
const healthBefore = await getFurniHealth();
|
|
const sprite = await fixSpriteIds();
|
|
const offers = await fixCatalogOffers();
|
|
const reconcile = await reconcileIds();
|
|
const dedup = await removeDuplicates();
|
|
const align = await forceItemsBaseIdsToFurnidata(true);
|
|
const healthAfter = await getFurniHealth();
|
|
return { healthBefore, sprite, offers, reconcile, dedup, align, healthAfter };
|
|
}
|