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

Revert "Merge pull request 'Complete Housekeeping migration and /ase cutover' (#52) from codex/housekeeping-complete into main"
CI / check (push) Successful in 27s
Details
CI / release (push) Skipped
Details
CI / deploy (push) Successful in 43s
Details

Browse Source 
This reverts commit 488b6e57c4, reversing
changes made to b506b4499a.
This commit is contained in:
Simo committed 2026-08-30 21:31:34 +02:00
1 parent 488b6e57c4
commit b1ddda66ff
802 files changed
+61370 -76659
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/features/housekeeping/domains/content/commands/content-commands.test.ts
-179
View File
@@ -1,179 +0,0 @@
import { describe, expect, it, vi } from "vitest";
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingCapabilityContext } from "../../../foundation/contracts";
import { CONTENT_COMMAND_IDS, createContentCommands } from "./content-commands";
const expected = [
["content.editorial.article.change", "article.change", PERMS.NEWS_EDIT],
["content.media.ad.change", "ad.change", PERMS.PAGES_EDIT],
["content.media.banner.change", "banner.change", PERMS.BANNERS_EDIT],
[
"content.engagement.event-type.change",
"event-type.change",
PERMS.EVENTS_EDIT,
],
["content.engagement.event.change", "event.change", PERMS.EVENTS_EDIT],
[
"content.engagement.event-prize.change",
"event-prize.change",
PERMS.EVENTS_EDIT,
],
[
"content.engagement.event-winner.add",
"event-winner.add",
PERMS.EVENTS_EDIT,
],
["content.engagement.poll.change", "poll.change", PERMS.POLLS_EDIT],
[
"content.engagement.poll-question.change",
"poll-question.change",
PERMS.POLLS_EDIT,
],
["content.media.photo.delete", "photo.delete", PERMS.PAGES_EDIT],
["content.media.asset.upload", "media.upload", PERMS.PAGES_EDIT],
["content.media.asset.delete", "media.delete", PERMS.PAGES_EDIT],
["content.editorial.tag.change", "tag.change", PERMS.PAGES_EDIT],
["content.engagement.prefix.change", "prefix.change", PERMS.PREFIXES_EDIT],
[
"content.engagement.prefix-blacklist.change",
"prefix-blacklist.change",
PERMS.PREFIXES_EDIT,
],
[
"content.engagement.prefix-settings.update",
"prefix-settings.update",
PERMS.PREFIXES_EDIT,
],
["content.help.question.change", "help-question.change", PERMS.PAGES_EDIT],
[
"content.editorial.writeable-box.change",
"writeable-box.change",
PERMS.PAGES_EDIT,
],
[
"content.help.email-template.change",
"email-template.change",
PERMS.PAGES_EDIT,
],
["content.brand.theme.update", "theme.update", PERMS.SETTINGS_EDIT],
[
"content.brand.theme.apply-preset",
"theme.apply-preset",
PERMS.SETTINGS_EDIT,
],
[
"content.brand.theme.custom-change",
"theme.custom-change",
PERMS.SETTINGS_EDIT,
],
[
"content.brand.theme.apply-custom",
"theme.apply-custom",
PERMS.SETTINGS_EDIT,
],
["content.brand.favicon.save", "favicon.save", PERMS.SETTINGS_EDIT],
["content.brand.favicon.delete", "favicon.delete", PERMS.SETTINGS_EDIT],
["content.brand.logo.save", "logo.save", PERMS.SETTINGS_EDIT],
[
"content.localization.cms.save",
"translation.cms.save",
PERMS.SETTINGS_EDIT,
],
[
"content.localization.client.save",
"translation.client.save",
PERMS.SETTINGS_EDIT,
],
[
"content.localization.emulator.save",
"translation.emulator.save",
PERMS.SETTINGS_EDIT,
],
] as const;
function context(): HousekeepingCapabilityContext {
return {
actor: { id: 42, username: "operator", rank: 7 },
isSuperAdmin: false,
has: () => true,
hasAny: () => true,
hasAll: () => true,
};
}
describe("Content commands", () => {
it("registers the exact complete operation matrix with existing ACLs", () => {
const service = { execute: vi.fn() };
const commands = createContentCommands(service as never);
expect(CONTENT_COMMAND_IDS).toEqual(expected.map(([id]) => id));
expect(
commands.map((command) => [
command.id,
command.operation,
command.capability.slugs[0],
]),
).toEqual(expected);
expect(commands.every((command) => command.owner === "content")).toBe(true);
});
it("marks global brand and localization writes sensitive with reason confirmation", () => {
const commands = createContentCommands({ execute: vi.fn() } as never);
const globalCommands = commands.filter(
(command) =>
command.id.startsWith("content.brand.") ||
command.id.startsWith("content.localization."),
);
expect(globalCommands.length).toBeGreaterThan(0);
expect(
globalCommands.every(
(command) => command.risk === "sensitive" && command.requiresReason,
),
).toBe(true);
expect(
globalCommands.every(
(command) =>
command.capability.mode === "any" &&
command.capability.slugs[0] === PERMS.SETTINGS_EDIT,
),
).toBe(true);
});
it("executes the real mutation service with actor-bound authority", async () => {
const execute = vi.fn(async () => ({
ok: true as const,
data: { before: null, after: { id: "1" } },
correlationId: "command-correlation",
}));
const [command] = createContentCommands({ execute } as never);
const result = await command.execute(
{
capability: context(),
correlationId: "command-correlation",
ipAddress: "127.0.0.1",
},
{ action: "create", title: "Launch" },
);
expect(execute).toHaveBeenCalledWith(
{
correlationId: "command-correlation",
expectedActorId: 42,
},
"article.change",
{ action: "create", title: "Launch" },
);
expect(result).toMatchObject({ ok: true });
});
it("isolates command validation schemas from later caller mutation", () => {
const commands = createContentCommands({ execute: vi.fn() } as never);
for (const command of commands) {
expect(command.input.safeParse(null).success, command.id).toBe(false);
expect(command.rateLimit.attempts).toBeGreaterThan(0);
expect(command.rateLimit.windowMs).toBeGreaterThan(0);
}
});
});
src/features/housekeeping/domains/content/commands/content-commands.ts
-139
View File
@@ -1,139 +0,0 @@
import "server-only";
import { z } from "zod";
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingCommand } from "../../../foundation/commands/registry";
import { anyCapability } from "../../../foundation/contracts";
import {
type ContentMutationOperation,
type ContentMutationService,
contentMutationService,
} from "../services/mutations";
const CONTENT_COMMAND_DEFINITIONS = [
["content.editorial.article.change", "article.change", PERMS.NEWS_EDIT],
["content.media.ad.change", "ad.change", PERMS.PAGES_EDIT],
["content.media.banner.change", "banner.change", PERMS.BANNERS_EDIT],
[
"content.engagement.event-type.change",
"event-type.change",
PERMS.EVENTS_EDIT,
],
["content.engagement.event.change", "event.change", PERMS.EVENTS_EDIT],
[
"content.engagement.event-prize.change",
"event-prize.change",
PERMS.EVENTS_EDIT,
],
[
"content.engagement.event-winner.add",
"event-winner.add",
PERMS.EVENTS_EDIT,
],
["content.engagement.poll.change", "poll.change", PERMS.POLLS_EDIT],
[
"content.engagement.poll-question.change",
"poll-question.change",
PERMS.POLLS_EDIT,
],
["content.media.photo.delete", "photo.delete", PERMS.PAGES_EDIT],
["content.media.asset.upload", "media.upload", PERMS.PAGES_EDIT],
["content.media.asset.delete", "media.delete", PERMS.PAGES_EDIT],
["content.editorial.tag.change", "tag.change", PERMS.PAGES_EDIT],
["content.engagement.prefix.change", "prefix.change", PERMS.PREFIXES_EDIT],
[
"content.engagement.prefix-blacklist.change",
"prefix-blacklist.change",
PERMS.PREFIXES_EDIT,
],
[
"content.engagement.prefix-settings.update",
"prefix-settings.update",
PERMS.PREFIXES_EDIT,
],
["content.help.question.change", "help-question.change", PERMS.PAGES_EDIT],
[
"content.editorial.writeable-box.change",
"writeable-box.change",
PERMS.PAGES_EDIT,
],
[
"content.help.email-template.change",
"email-template.change",
PERMS.PAGES_EDIT,
],
["content.brand.theme.update", "theme.update", PERMS.SETTINGS_EDIT],
[
"content.brand.theme.apply-preset",
"theme.apply-preset",
PERMS.SETTINGS_EDIT,
],
[
"content.brand.theme.custom-change",
"theme.custom-change",
PERMS.SETTINGS_EDIT,
],
[
"content.brand.theme.apply-custom",
"theme.apply-custom",
PERMS.SETTINGS_EDIT,
],
["content.brand.favicon.save", "favicon.save", PERMS.SETTINGS_EDIT],
["content.brand.favicon.delete", "favicon.delete", PERMS.SETTINGS_EDIT],
["content.brand.logo.save", "logo.save", PERMS.SETTINGS_EDIT],
[
"content.localization.cms.save",
"translation.cms.save",
PERMS.SETTINGS_EDIT,
],
[
"content.localization.client.save",
"translation.client.save",
PERMS.SETTINGS_EDIT,
],
[
"content.localization.emulator.save",
"translation.emulator.save",
PERMS.SETTINGS_EDIT,
],
] as const;
export const CONTENT_COMMAND_IDS = CONTENT_COMMAND_DEFINITIONS.map(
([id]) => id,
) as ReadonlyArray<(typeof CONTENT_COMMAND_DEFINITIONS)[number][0]>;
type ContentCommand = HousekeepingCommand<Record<string, unknown>, unknown> & {
readonly operation: ContentMutationOperation;
};
const commandInput = z.object({}).catchall(z.unknown());
export function createContentCommands(
service: Pick<ContentMutationService, "execute">,
): readonly ContentCommand[] {
return CONTENT_COMMAND_DEFINITIONS.map(
([id, operation, permission]): ContentCommand => ({
id,
owner: "content",
operation,
risk: "sensitive",
capability: anyCapability(permission),
input: commandInput,
requiresReason:
id.startsWith("content.brand.") ||
id.startsWith("content.localization."),
rateLimit: { attempts: 10, windowMs: 60_000 },
execute: (context, input) =>
service.execute(
{
correlationId: context.correlationId,
expectedActorId: context.capability.actor.id,
},
operation,
input,
),
}),
);
}
export const CONTENT_COMMANDS = createContentCommands(contentMutationService);
src/features/housekeeping/domains/content/content-providers-production.test.ts
-187
View File
@@ -1,187 +0,0 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingCapabilityContext } from "../../foundation/contracts";
import { loadContentInboxItems } from "./inbox-production";
import { loadContentSearchCandidates } from "./search-production";
import { loadContentWidget } from "./widgets-production";
const { run } = vi.hoisted(() => ({ run: vi.fn() }));
vi.mock("./queries/content-queries", () => ({
contentQuery: { run },
}));
const context = {
actor: { id: 42, username: "operator", rank: 7 },
isSuperAdmin: false,
has: () => true,
hasAny: () => true,
hasAll: () => true,
} satisfies HousekeepingCapabilityContext;
function capability(granted: readonly string[]): HousekeepingCapabilityContext {
const permissions = new Set(granted);
return {
...context,
has: (slug) => permissions.has(slug),
hasAny: (...slugs) => slugs.some((slug) => permissions.has(slug)),
hasAll: (...slugs) => slugs.every((slug) => permissions.has(slug)),
};
}
function result(
routeId: string,
total: number,
items: readonly Record<string, unknown>[] = [],
) {
return {
ok: true as const,
data: {
kind: routeId.split(".")[1],
items,
total,
partialDependencies: [],
},
correlationId: "provider-production",
};
}
describe("Content production providers", () => {
beforeEach(() => {
vi.clearAllMocks();
run.mockImplementation(async (_context, input) =>
result(input.routeId, input.routeId.includes("articles") ? 7 : 3),
);
});
it("returns only truthful persisted counts from editorial and localization widgets", async () => {
const signal = new AbortController().signal;
await expect(
loadContentWidget("editorial", context, signal),
).resolves.toEqual({ articles: 7 });
await expect(
loadContentWidget("localization", context, signal),
).resolves.toEqual({ stores: 3 });
});
it("loads real search candidates from bounded query routes", async () => {
run.mockImplementation(async (_context, input) =>
result(input.routeId, 1, [
{
id: "9",
title: "Launch",
description: "Published",
href: "/ase/content/editorial/articles/9",
},
]),
);
const candidates = await loadContentSearchCandidates(
"articles",
context,
"launch",
25,
);
expect(candidates).toEqual([
expect.objectContaining({
id: "content.editorial.articles:9",
href: "/ase/content/editorial/articles/9",
}),
]);
expect(run).toHaveBeenCalledWith(
context,
expect.objectContaining({
list: { search: "launch", pageSize: 25, offset: 0 },
}),
);
});
it("builds publication inbox items only from real query rows", async () => {
run.mockImplementation(async (_context, input) =>
result(input.routeId, 1, [
{
id: "5",
title: "Release",
status: "published",
updatedAt: new Date().toISOString(),
href: "/ase/content/editorial/articles/5",
},
]),
);
const items = await loadContentInboxItems(
"publication",
context,
new AbortController().signal,
);
expect(items).toEqual([]);
});
it("loads only capability-matched media counts", async () => {
const result = await loadContentWidget(
"media",
capability([PERMS.BANNERS_VIEW]),
new AbortController().signal,
);
expect(result).toEqual({ banners: 3 });
expect(run).toHaveBeenCalledTimes(1);
expect(run).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({ routeId: "content.media.banners" }),
);
});
it("does not invent a zero when a widget dependency is unavailable", async () => {
run.mockResolvedValueOnce({
ok: false,
error: { code: "DEPENDENCY_UNAVAILABLE", messageKey: "dependency" },
correlationId: "unavailable",
});
await expect(
loadContentWidget("editorial", context, new AbortController().signal),
).rejects.toThrow("Content widget query unavailable");
});
it("marks an inbox dependency unavailable instead of returning an available empty list", async () => {
run.mockResolvedValueOnce({
ok: false,
error: { code: "DEPENDENCY_UNAVAILABLE", messageKey: "dependency" },
correlationId: "unavailable",
});
await expect(
loadContentInboxItems(
"publication",
context,
new AbortController().signal,
),
).rejects.toThrow("Content inbox query unavailable");
});
it("emits only actionable publication statuses", async () => {
run.mockResolvedValueOnce(
result("content.editorial.articles", 2, [
{
id: "draft",
title: "Draft",
status: "draft",
updatedAt: new Date().toISOString(),
href: "/ase/content/editorial/articles/draft",
},
{
id: "published",
title: "Published",
status: "published",
updatedAt: new Date().toISOString(),
href: "/ase/content/editorial/articles/published",
},
]),
);
const items = await loadContentInboxItems(
"publication",
context,
new AbortController().signal,
);
expect(items.map((item) => item.itemId)).toEqual(["draft"]);
expect(items[0]?.state).toBe("draft");
});
});
src/features/housekeeping/domains/content/content-providers.test.ts
-163
View File
@@ -1,163 +0,0 @@
import { describe, expect, it, vi } from "vitest";
import { PERMS } from "@/lib/permission-slugs";
import {
anyCapability,
type HousekeepingCapabilityContext,
} from "../../foundation/contracts";
import { CONTENT_INBOX_SOURCE_IDS, createContentInboxSources } from "./inbox";
import {
CONTENT_SEARCH_PROVIDER_IDS,
createContentSearchProviders,
} from "./search";
import { CONTENT_WIDGET_IDS, createContentWidgets } from "./widgets";
function context(granted: readonly string[]): HousekeepingCapabilityContext {
const permissions = new Set(granted);
return {
actor: { id: 42, username: "operator", rank: 7 },
isSuperAdmin: false,
has: (slug) => permissions.has(slug),
hasAny: (...slugs) => slugs.some((slug) => permissions.has(slug)),
hasAll: (...slugs) => slugs.every((slug) => permissions.has(slug)),
};
}
describe("Content search providers", () => {
it("uses the four exact IDs, filters item capabilities, and caps results at 25", async () => {
const visible = anyCapability(PERMS.NEWS_VIEW);
const hidden = anyCapability(PERMS.EVENTS_VIEW);
const candidates = Array.from({ length: 30 }, (_, index) => ({
id: `article-${index}`,
title: `Article ${index}`,
href: `/ase/content/editorial/articles/${index + 1}`,
capability: index === 0 ? hidden : visible,
}));
const providerAdapters = {
articles: vi.fn(async () => candidates),
events: vi.fn(async () => []),
media: vi.fn(async () => []),
help: vi.fn(async () => []),
};
const providers = createContentSearchProviders(providerAdapters);
expect(CONTENT_SEARCH_PROVIDER_IDS).toEqual([
"content.articles",
"content.events",
"content.media",
"content.help",
]);
expect(providers.map((provider) => provider.id)).toEqual(
CONTENT_SEARCH_PROVIDER_IDS,
);
const result = await providers[0].search(context([PERMS.NEWS_VIEW]), {
term: " launch ",
limit: 999,
});
expect(providerAdapters.articles).toHaveBeenCalledWith(
expect.anything(),
"launch",
25,
);
expect(result.ok).toBe(true);
if (!result.ok) return;
expect(result.data).toHaveLength(25);
expect(result.data.some((item) => item.id === "article-0")).toBe(false);
});
it.each([
"/ase/content/%2e%2e/system",
"/ase/content/%252e%252e/system",
"/ase/content/%252f..%252fsystem",
"/ase/content/%255c..%255csystem",
"https://example.test/ase/content/editorial",
"//example.test/ase/content/editorial",
])(
"rejects normalized and double-encoded traversal href %s",
async (href) => {
const adapters = {
articles: async () => [
{
id: "unsafe",
title: "Unsafe",
href,
capability: anyCapability(PERMS.NEWS_VIEW),
},
],
events: async () => [],
media: async () => [],
help: async () => [],
};
const [provider] = createContentSearchProviders(adapters);
const result = await provider.search(context([PERMS.NEWS_VIEW]), {
term: "",
limit: 25,
});
expect(result).toMatchObject({ ok: true, data: [] });
},
);
});
describe("Content inbox and widgets", () => {
it("provides capability-selective publication and attention sources", async () => {
const publication = vi.fn(async () => []);
const attention = vi.fn(async () => []);
const sources = createContentInboxSources({ publication, attention });
expect(CONTENT_INBOX_SOURCE_IDS).toEqual([
"content.publication",
"content.attention",
]);
const controller = new AbortController();
const news = context([PERMS.NEWS_VIEW]);
await sources[0].getItems(news, controller.signal);
const forbidden = await sources[1].getItems(news, controller.signal);
expect(publication).toHaveBeenCalledTimes(1);
expect(attention).not.toHaveBeenCalled();
expect(forbidden).toMatchObject({
ok: false,
error: { code: "FORBIDDEN" },
});
});
it("does not advertise media permissions for an event-and-poll attention source", async () => {
const attention = vi.fn(async () => []);
const [, source] = createContentInboxSources({
publication: async () => [],
attention,
});
const result = await source.getItems(
context([PERMS.PAGES_VIEW, PERMS.BANNERS_VIEW]),
new AbortController().signal,
);
expect(result).toMatchObject({ ok: false, error: { code: "FORBIDDEN" } });
expect(attention).not.toHaveBeenCalled();
});
it("keeps editorial mandatory and media/localization optional without preview DB imports", async () => {
const adapters = {
editorial: vi.fn(async () => ({ drafts: 2, scheduled: 1 })),
media: vi.fn(async () => ({ items: 4 })),
localization: vi.fn(async () => ({ stores: 3, pending: 0 })),
};
const widgets = createContentWidgets(adapters);
expect(CONTENT_WIDGET_IDS).toEqual([
"content.editorial-summary",
"content.media-summary",
"content.localization-summary",
]);
expect(widgets.map((widget) => widget.kind)).toEqual([
"mandatory",
"optional",
"optional",
]);
const result = await widgets[0].load(
context([PERMS.NEWS_VIEW]),
new AbortController().signal,
);
expect(result).toMatchObject({
ok: true,
data: { drafts: 2, scheduled: 1 },
});
});
});
src/features/housekeeping/domains/content/inbox-production.ts
-82
View File
@@ -1,82 +0,0 @@
import "server-only";
import { PERMS } from "@/lib/permission-slugs";
import {
anyCapability,
type HousekeepingCapabilityContext,
type HousekeepingWorkItem,
} from "../../foundation/contracts";
import { contentQuery } from "./queries/content-queries";
type ContentInboxKind = "publication" | "attention";
const ACTIONABLE_STATUS = {
publication: new Set(["draft", "scheduled", "pending", "failed"]),
attention: new Set(["draft", "cancelled", "closed", "failed"]),
} as const;
function time(value: string | null | undefined) {
if (!value) return null;
const timestamp = Date.parse(value);
if (!Number.isFinite(timestamp)) return null;
const ageMs = Math.max(0, Date.now() - timestamp);
return {
occurredAt: new Date(timestamp).toISOString(),
ageMs,
freshness: ageMs > 86_400_000 ? ("stale" as const) : ("fresh" as const),
};
}
export async function loadContentInboxItems(
kind: ContentInboxKind,
context: HousekeepingCapabilityContext,
signal: AbortSignal,
): Promise<readonly HousekeepingWorkItem[]> {
if (signal.aborted) throw new Error("aborted Content inbox");
const definitions =
kind === "publication"
? ([
[
"content.editorial.articles",
PERMS.NEWS_VIEW,
"content.publication",
],
] as const)
: ([
["content.engagement.events", PERMS.EVENTS_VIEW, "content.attention"],
["content.engagement.polls", PERMS.POLLS_VIEW, "content.attention"],
] as const);
const items: HousekeepingWorkItem[] = [];
for (const [routeId, permission, sourceId] of definitions) {
if (!context.has(permission)) continue;
const result = await contentQuery.run(context, {
routeId,
list: { pageSize: 25, offset: 0 },
});
if (!result.ok) throw new Error("Content inbox query unavailable");
for (const item of result.data.items) {
const status = item.status?.toLocaleLowerCase() ?? "";
if (!ACTIONABLE_STATUS[kind].has(status)) continue;
const date = time(item.updatedAt);
if (!date || !item.href) continue;
items.push({
sourceId,
itemId: item.id,
deduplicationKey: `${sourceId}:${routeId}:${item.id}`,
domain: "content",
capability: anyCapability(permission),
severity:
status === "failed" || status === "cancelled" ? "warning" : "info",
priority: status === "failed" ? "high" : "normal",
...date,
state: status,
titleKey: "pages.housekeeping.items.content",
context: { title: item.title },
href: item.href as `/ase/${string}`,
actions: [],
});
if (items.length >= 25) return items;
}
}
return items;
}
src/features/housekeeping/domains/content/inbox.ts
-94
View File
@@ -1,94 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import { authorizeHousekeeping } from "../../foundation/authorization";
import { satisfiesCapability } from "../../foundation/capability-context";
import {
anyCapability,
type CapabilityRequirement,
fail,
type HousekeepingCapabilityContext,
type HousekeepingInboxSource,
type HousekeepingWorkItem,
ok,
} from "../../foundation/contracts";
import { isSafeHousekeepingHref } from "../../foundation/housekeeping-href";
export const CONTENT_INBOX_SOURCE_IDS = [
"content.publication",
"content.attention",
] as const;
type ContentInboxLoader = (
context: HousekeepingCapabilityContext,
signal: AbortSignal,
) => Promise<readonly HousekeepingWorkItem[]>;
export interface ContentInboxAdapters {
readonly publication: ContentInboxLoader;
readonly attention: ContentInboxLoader;
}
function createSource(
id: (typeof CONTENT_INBOX_SOURCE_IDS)[number],
capability: CapabilityRequirement,
load: ContentInboxLoader,
): HousekeepingInboxSource {
return {
id,
owner: "content",
capability,
async getItems(context, signal) {
const authorization = authorizeHousekeeping(context, capability);
if (!authorization.ok) return authorization;
try {
const items = await load(context, signal);
return ok(
{
availability: "available" as const,
items: items
.filter(
(item) =>
isSafeHousekeepingHref(item.href) &&
satisfiesCapability(context, item.capability),
)
.slice(0, 25),
},
authorization.correlationId,
);
} catch {
return fail(
"DEPENDENCY_UNAVAILABLE",
"errors.housekeeping.dependencyUnavailable",
authorization.correlationId,
);
}
},
};
}
export function createContentInboxSources(
adapters: ContentInboxAdapters,
): readonly HousekeepingInboxSource[] {
return [
createSource(
"content.publication",
anyCapability(PERMS.NEWS_VIEW),
adapters.publication,
),
createSource(
"content.attention",
anyCapability(PERMS.EVENTS_VIEW, PERMS.POLLS_VIEW),
adapters.attention,
),
];
}
export const CONTENT_INBOX_SOURCES = createContentInboxSources({
async publication(context, signal) {
const { loadContentInboxItems } = await import("./inbox-production");
return loadContentInboxItems("publication", context, signal);
},
async attention(context, signal) {
const { loadContentInboxItems } = await import("./inbox-production");
return loadContentInboxItems("attention", context, signal);
},
});
src/features/housekeeping/domains/content/manifest.ts
+5 -9
View File
@@ -3,17 +3,13 @@ import {
anyCapability,
type HousekeepingDomainManifest,
} from "../../foundation/contracts";
import { CONTENT_INBOX_SOURCES } from "./inbox";
import { CONTENT_ROUTES } from "./routes";
import { CONTENT_SEARCH_PROVIDERS } from "./search";
import { CONTENT_WIDGETS } from "./widgets";
export const contentManifest = {
id: "content",
labelKey: "pages.housekeeping.domains.content.title",
descriptionKey: "pages.housekeeping.domains.content.description",
iconId: "file-text",
canonicalHref: "/ase/content",
previewHref: "/admin-next/content",
capability: anyCapability(
PERMS.NEWS_VIEW,
PERMS.PAGES_VIEW,
@@ -30,8 +26,8 @@ export const contentManifest = {
PERMS.SETTINGS_VIEW,
PERMS.SETTINGS_EDIT,
),
routes: CONTENT_ROUTES,
searchProviders: CONTENT_SEARCH_PROVIDERS,
inboxSources: CONTENT_INBOX_SOURCES,
widgets: CONTENT_WIDGETS,
routes: [],
searchProviders: [],
inboxSources: [],
widgets: [],
} satisfies HousekeepingDomainManifest;
src/features/housekeeping/domains/content/pages/brand.tsx
-143
View File
@@ -1,143 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingPageInput } from "../../../route-handlers";
import { contentQuery } from "../queries/content-queries";
import { ContentCommandForm } from "./content-command-form";
import {
ContentPageFrame,
type ContentPageProps,
parseContentListInput,
} from "./content-page-frame";
export function ContentBrandPage({
context,
result,
routeId,
}: ContentPageProps) {
const forms = context.has(PERMS.SETTINGS_EDIT) ? (
<div className="grid gap-3 lg:grid-cols-2">
{routeId === "content.brand.theme" ? (
<>
<ContentCommandForm
commandId="content.brand.theme.update"
buttonLabel="Save theme values"
input={{}}
fields={[
{
name: "values",
label: "Theme values JSON",
type: "json",
required: true,
maxLength: 20_000,
},
]}
requiresReason
/>
<ContentCommandForm
commandId="content.brand.theme.apply-preset"
buttonLabel="Apply preset"
input={{}}
fields={[
{
name: "preset",
label: "Preset",
type: "text",
required: true,
maxLength: 100,
},
]}
requiresReason
/>
<ContentCommandForm
commandId="content.brand.theme.custom-change"
buttonLabel="Save custom theme"
input={{ action: "update" }}
fields={[
{ name: "id", label: "Theme ID", type: "identifier" },
{
name: "name",
label: "Name",
type: "text",
required: true,
maxLength: 100,
},
{
name: "values",
label: "Theme values JSON",
type: "json",
required: true,
maxLength: 20_000,
},
]}
requiresReason
/>
<ContentCommandForm
commandId="content.brand.theme.apply-custom"
buttonLabel="Apply custom theme"
input={{}}
fields={[
{
name: "id",
label: "Theme ID",
type: "identifier",
required: true,
},
]}
requiresReason
/>
</>
) : null}
{routeId === "content.brand.favicon" ? (
<>
<ContentCommandForm
commandId="content.brand.favicon.save"
buttonLabel="Save favicon"
input={{}}
fields={[
{ name: "file", label: "Favicon", type: "file", required: true },
]}
requiresReason
/>
<ContentCommandForm
commandId="content.brand.favicon.delete"
buttonLabel="Delete favicon"
input={{}}
requiresReason
/>
<ContentCommandForm
commandId="content.brand.logo.save"
buttonLabel="Save logo"
input={{}}
fields={[
{ name: "file", label: "Logo", type: "file", required: true },
]}
requiresReason
/>
</>
) : null}
</div>
) : null;
return (
<ContentPageFrame
title="Brand"
description="Manage theme, favicon, and logo assets."
result={result}
forms={forms}
/>
);
}
export async function renderContentBrandPage(input: HousekeepingPageInput) {
const routeId = input.match.routeId as ContentPageProps["routeId"];
const result = await contentQuery.run(input.context, {
routeId: routeId ?? "content.brand.theme",
params: input.match.params,
list: parseContentListInput(input.searchParams ?? {}),
});
return (
<ContentBrandPage
context={input.context}
result={result}
routeId={routeId}
/>
);
}
src/features/housekeeping/domains/content/pages/content-command-form.tsx
-250
View File
@@ -1,250 +0,0 @@
"use client";
import { useActionState } from "react";
import type { HousekeepingResult } from "../../../foundation/contracts";
export interface ContentCommandField {
readonly name: string;
readonly label: string;
readonly type:
| "identifier"
| "json"
| "text"
| "textarea"
| "number"
| "checkbox"
| "select"
| "file";
readonly required?: boolean;
readonly min?: number;
readonly max?: number;
readonly maxLength?: number;
readonly defaultValue?: string | number | boolean;
readonly allowUnchanged?: boolean;
readonly options?: readonly Readonly<{
value: string | number;
label: string;
}>[];
}
export interface ContentCommandSubmission {
readonly commandId: string;
readonly input: Readonly<Record<string, unknown>>;
readonly fields?: readonly ContentCommandField[];
readonly requiresReason?: boolean;
}
interface ContentCommandFormProps extends ContentCommandSubmission {
readonly buttonLabel: string;
}
const OMIT_FIELD = Symbol("omit optional Content command field");
function parseField(field: ContentCommandField, formData: FormData): unknown {
const rawValue = formData.get(field.name);
if (field.type === "checkbox") {
if (field.allowUnchanged) {
if (rawValue === null || rawValue === "") return OMIT_FIELD;
if (rawValue === "true") return true;
if (rawValue === "false") return false;
return OMIT_FIELD;
}
return rawValue === "on";
}
if (rawValue === null && !field.required) return OMIT_FIELD;
if (field.type === "file") return rawValue instanceof File ? rawValue : null;
const raw = String(rawValue ?? "")
.normalize("NFC")
.trim();
if (!raw && !field.required) return OMIT_FIELD;
if (field.type === "number") {
if (!raw) return raw;
const value = Number(raw);
if (!Number.isSafeInteger(value)) return 0;
return Math.min(field.max ?? value, Math.max(field.min ?? value, value));
}
if (field.type === "select") {
const selected = field.options?.find(
(option) => String(option.value) === raw,
)?.value;
return selected ?? raw.slice(0, 500);
}
if (field.type === "json") {
try {
return JSON.parse(raw.slice(0, field.maxLength ?? 20_000));
} catch {
return null;
}
}
return raw.slice(
0,
field.maxLength ?? (field.type === "textarea" ? 20_000 : 500),
);
}
const initialState: HousekeepingResult<unknown> | null = null;
export async function submitContentCommandForm(
configuration: ContentCommandSubmission,
_previous: HousekeepingResult<unknown> | null,
formData: FormData,
): Promise<HousekeepingResult<unknown>> {
const submittedFields = (configuration.fields ?? []).flatMap((field) => {
const value = parseField(field, formData);
return value === OMIT_FIELD ? [] : [[field.name, value] as const];
});
const input = {
...configuration.input,
...Object.fromEntries(submittedFields),
};
const reason = String(formData.get("reason") ?? "")
.normalize("NFC")
.trim()
.slice(0, 1000);
const { executeHousekeepingCommand } = await import(
"@/actions/housekeeping-command"
);
return executeHousekeepingCommand({
commandId: configuration.commandId,
input,
...(configuration.requiresReason ? { reason } : {}),
});
}
export function ContentCommandForm({
commandId,
buttonLabel,
input,
fields = [],
requiresReason = false,
}: ContentCommandFormProps) {
const [result, submit, pending] = useActionState(
submitContentCommandForm.bind(null, {
commandId,
input,
fields,
requiresReason,
}),
initialState,
);
return (
<form
action={submit}
data-housekeeping-command={commandId}
className="space-y-3 rounded border border-[var(--admin-border)] p-3"
>
{fields.map((field) => (
<label
key={field.name}
htmlFor={`${commandId}-${field.name}`}
className="block text-sm"
>
{field.type === "checkbox" && field.allowUnchanged ? (
<>
{field.label}
<select
id={`${commandId}-${field.name}`}
name={field.name}
defaultValue=""
className="mt-1 block w-full"
>
<option value="">No change</option>
<option value="true">Enabled</option>
<option value="false">Disabled</option>
</select>
</>
) : field.type === "checkbox" ? (
<>
<input
id={`${commandId}-${field.name}`}
name={field.name}
type="checkbox"
defaultChecked={field.defaultValue === true}
/>{" "}
{field.label}
</>
) : field.type === "select" ? (
<>
{field.label}
<select
id={`${commandId}-${field.name}`}
name={field.name}
defaultValue={
typeof field.defaultValue === "boolean"
? undefined
: field.defaultValue
}
required={field.required}
className="mt-1 block w-full"
>
{field.required ? null : <option value="">No change</option>}
{field.options?.map((option) => (
<option key={option.value} value={option.value}>
{option.label}
</option>
))}
</select>
</>
) : field.type === "textarea" || field.type === "json" ? (
<>
{field.label}
<textarea
id={`${commandId}-${field.name}`}
name={field.name}
required={field.required}
maxLength={field.maxLength}
className="mt-1 block w-full"
/>
</>
) : (
<>
{field.label}
<input
id={`${commandId}-${field.name}`}
name={field.name}
type={
field.type === "number"
? "number"
: field.type === "file"
? "file"
: "text"
}
defaultValue={
field.type === "file" ||
typeof field.defaultValue === "boolean"
? undefined
: field.defaultValue
}
required={field.required}
min={field.min}
max={field.max}
maxLength={field.maxLength}
className="mt-1 block w-full"
/>
</>
)}
</label>
))}
{requiresReason ? (
<label htmlFor={`${commandId}-reason`} className="block text-sm">
Reason
<textarea
id={`${commandId}-reason`}
name="reason"
required
maxLength={1000}
className="mt-1 block w-full"
/>
</label>
) : null}
<button type="submit" disabled={pending}>
{pending ? "Working..." : buttonLabel}
</button>
{result ? (
<p role="status" className="text-xs text-[var(--admin-text-muted)]">
{result.ok ? "Completed" : "Failed"} ({result.correlationId})
</p>
) : null}
</form>
);
}
src/features/housekeeping/domains/content/pages/content-page-frame.tsx
-77
View File
@@ -1,77 +0,0 @@
import type { ReactNode } from "react";
import type { HousekeepingResult } from "../../../foundation/contracts";
import type { ContentQueryData } from "../queries/content-queries";
export interface ContentPageProps {
readonly context: import("../../../foundation/contracts").HousekeepingCapabilityContext;
readonly result?: HousekeepingResult<ContentQueryData>;
readonly routeId: import("../routes").ContentRouteId | null;
}
export function ContentPageFrame({
title,
description,
result,
forms,
}: {
readonly title: string;
readonly description: string;
readonly result?: HousekeepingResult<ContentQueryData>;
readonly forms?: ReactNode;
}) {
if (!result) {
return (
<section data-housekeeping-state="loading">
<h1>{title}</h1>
<p>{description}</p>
<p>Loading content…</p>
</section>
);
}
if (!result.ok) {
const state = result.error.code === "FORBIDDEN" ? "forbidden" : "error";
return (
<section data-housekeeping-state={state} role="alert">
<h1>{title}</h1>
<p>{result.error.messageKey}</p>
</section>
);
}
const state = result.data.items.length === 0 ? "empty" : "ready";
return (
<section data-housekeeping-state={state} className="space-y-4">
<header>
<h1>{title}</h1>
<p>{description}</p>
</header>
{forms}
{result.data.items.length === 0 ? (
<p>No matching content.</p>
) : (
<ul className="divide-y divide-[var(--admin-border)]">
{result.data.items.map((item) => (
<li key={item.id} className="py-2">
{item.href ? <a href={item.href}>{item.title}</a> : item.title}
{item.status ? <span> — {item.status}</span> : null}
{item.description ? <p>{item.description}</p> : null}
</li>
))}
</ul>
)}
</section>
);
}
export function parseContentListInput(
searchParams: Readonly<
Record<string, string | readonly string[] | undefined>
>,
) {
const first = (value: string | readonly string[] | undefined) =>
Array.isArray(value) ? value[0] : value;
return {
search: first(searchParams.search),
pageSize: Number(first(searchParams.pageSize) ?? 25),
offset: Number(first(searchParams.offset) ?? 0),
};
}
src/features/housekeeping/domains/content/pages/content-pages.test.tsx
-410
View File
@@ -1,410 +0,0 @@
import { renderToStaticMarkup } from "react-dom/server";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { executeHousekeepingCommand } from "@/actions/housekeeping-command";
import { PERMS } from "@/lib/permission-slugs";
import {
fail,
type HousekeepingCapabilityContext,
ok,
} from "../../../foundation/contracts";
import { ContentBrandPage } from "./brand";
import { submitContentCommandForm } from "./content-command-form";
import { ContentEditorialPage } from "./editorial";
import { ContentEngagementPage } from "./engagement";
import { ContentHelpPage } from "./help";
import { ContentLocalizationPage } from "./localization";
import { ContentMediaPage } from "./media";
vi.mock("@/actions/housekeeping-command", () => ({
executeHousekeepingCommand: vi.fn(),
}));
function context(granted: readonly string[]): HousekeepingCapabilityContext {
const permissions = new Set(granted);
return {
actor: { id: 42, username: "operator", rank: 7 },
isSuperAdmin: false,
has: (slug) => permissions.has(slug),
hasAny: (...slugs) => slugs.some((slug) => permissions.has(slug)),
hasAll: (...slugs) => slugs.every((slug) => permissions.has(slug)),
};
}
const cases = [
["editorial", ContentEditorialPage, PERMS.NEWS_EDIT],
["media", ContentMediaPage, PERMS.PAGES_EDIT],
["engagement", ContentEngagementPage, PERMS.EVENTS_EDIT],
["help", ContentHelpPage, PERMS.PAGES_EDIT],
["brand", ContentBrandPage, PERMS.SETTINGS_EDIT],
["localization", ContentLocalizationPage, PERMS.SETTINGS_EDIT],
] as const;
describe.each(cases)("Content %s page", (kind, Component, editPermission) => {
it("renders loading, forbidden, empty, and real ready states", () => {
const read = context(Object.values(PERMS));
const render = (result?: unknown) =>
renderToStaticMarkup(
<Component context={read} result={result as never} routeId={null} />,
);
expect(render()).toContain('data-housekeeping-state="loading"');
expect(
render(fail("FORBIDDEN", "errors.housekeeping.forbidden", "forbidden")),
).toContain('data-housekeeping-state="forbidden"');
expect(
render(
ok({ kind, items: [], total: 0, partialDependencies: [] }, "empty"),
),
).toContain('data-housekeeping-state="empty"');
const ready = render(
ok(
{
kind,
items: [
{
id: "18446744073709551615",
title: "Canonical item",
status: "ready",
href: `/ase/content/${kind}`,
},
],
total: 1,
partialDependencies: [],
},
"ready",
),
);
expect(ready).toContain('data-housekeeping-state="ready"');
expect(ready).toContain("Canonical item");
expect(ready).not.toContain("/admin");
expect(read.has(editPermission)).toBe(true);
});
});
describe("Content actionable form wiring", () => {
beforeEach(() => vi.clearAllMocks());
it("submits canonical identifiers and a bounded reason through the real server action", async () => {
vi.mocked(executeHousekeepingCommand).mockResolvedValue(
ok({ before: null, after: { id: "18446744073709551615" } }, "form"),
);
const formData = new FormData();
formData.set("id", "18446744073709551615");
formData.set("title", " Updated title ");
formData.set("reason", ` ${"r".repeat(1100)} `);
const result = await submitContentCommandForm(
{
commandId: "content.editorial.article.change",
input: { action: "update" },
fields: [
{ name: "id", label: "ID", type: "identifier" },
{ name: "title", label: "Title", type: "text", maxLength: 255 },
],
requiresReason: true,
},
null,
formData,
);
expect(executeHousekeepingCommand).toHaveBeenCalledWith({
commandId: "content.editorial.article.change",
input: {
action: "update",
id: "18446744073709551615",
title: "Updated title",
},
reason: "r".repeat(1000),
});
expect(result).toMatchObject({ ok: true });
});
it("parses structured JSON fields before dispatching real brand and localization forms", async () => {
vi.mocked(executeHousekeepingCommand).mockResolvedValue(
ok({ before: null, after: { keyCount: 1 } }, "json-form"),
);
const formData = new FormData();
formData.set("data", '{ "welcome": "Hello" }');
await submitContentCommandForm(
{
commandId: "content.localization.cms.save",
input: { locale: "en" },
fields: [
{
name: "data",
label: "Translations",
type: "json",
maxLength: 500_000,
},
],
requiresReason: true,
},
null,
formData,
);
expect(executeHousekeepingCommand).toHaveBeenCalledWith({
commandId: "content.localization.cms.save",
input: { locale: "en", data: { welcome: "Hello" } },
reason: "",
});
});
it("omits untouched optional text and tri-state checkbox fields during updates", async () => {
vi.mocked(executeHousekeepingCommand).mockResolvedValue(
ok({ before: null, after: { id: "7" } }, "partial-form"),
);
const formData = new FormData();
formData.set("id", "7");
formData.set("title", "Renamed");
formData.set("image", "");
await submitContentCommandForm(
{
commandId: "content.media.banner.change",
input: { action: "update" },
fields: [
{ name: "id", label: "ID", type: "identifier", required: true },
{ name: "title", label: "Title", type: "text" },
{ name: "image", label: "Image", type: "text" },
{
name: "isActive",
label: "Active",
type: "checkbox",
allowUnchanged: true,
},
],
},
null,
formData,
);
expect(executeHousekeepingCommand).toHaveBeenCalledWith({
commandId: "content.media.banner.change",
input: {
action: "update",
id: "7",
title: "Renamed",
},
});
});
it.each([
["false", false],
["true", true],
] as const)(
"submits an explicit tri-state checkbox value %s as %s",
async (submitted, expected) => {
vi.mocked(executeHousekeepingCommand).mockResolvedValue(
ok({ before: null, after: { id: "7" } }, "explicit-checkbox"),
);
const formData = new FormData();
formData.set("id", "7");
formData.set("isActive", submitted);
await submitContentCommandForm(
{
commandId: "content.engagement.event-type.change",
input: { action: "update" },
fields: [
{ name: "id", label: "ID", type: "identifier", required: true },
{
name: "isActive",
label: "Active",
type: "checkbox",
allowUnchanged: true,
},
],
},
null,
formData,
);
expect(executeHousekeepingCommand).toHaveBeenCalledWith({
commandId: "content.engagement.event-type.change",
input: { action: "update", id: "7", isActive: expected },
});
},
);
it("renders poll creation with show-results checked by default", () => {
const html = renderToStaticMarkup(
<ContentEngagementPage
context={context([PERMS.POLLS_EDIT])}
result={ok(
{ kind: "engagement", items: [], total: 0, partialDependencies: [] },
"poll-create-checkbox",
)}
routeId="content.engagement.poll-create"
/>,
);
expect(html).toMatch(/name="showResults"[^>]*checked=""/u);
const multipleChoice = html.match(
/<input[^>]*name="multipleChoice"[^>]*>/u,
)?.[0];
expect(multipleChoice).toBeDefined();
expect(multipleChoice).not.toContain("checked");
});
it("renders poll updates with explicit unchanged, enabled, and disabled choices", () => {
const html = renderToStaticMarkup(
<ContentEngagementPage
context={context([PERMS.POLLS_EDIT])}
result={ok(
{ kind: "engagement", items: [], total: 0, partialDependencies: [] },
"poll-update-checkbox",
)}
routeId="content.engagement.poll-detail"
/>,
);
expect(html).toMatch(/<select[^>]*name="showResults"/u);
expect(html).toContain("No change");
expect(html).toContain('value="true"');
expect(html).toContain('value="false"');
});
it("renders mutation forms only with the exact capability", () => {
const result = ok(
{
kind: "brand" as const,
items: [{ id: "theme", title: "Theme", status: "active" }],
total: 1,
partialDependencies: [],
},
"brand",
);
const readOnly = renderToStaticMarkup(
<ContentBrandPage
context={context([PERMS.SETTINGS_VIEW])}
result={result}
routeId="content.brand.theme"
/>,
);
const editor = renderToStaticMarkup(
<ContentBrandPage
context={context([PERMS.SETTINGS_VIEW, PERMS.SETTINGS_EDIT])}
result={result}
routeId="content.brand.theme"
/>,
);
expect(readOnly).not.toContain("content.brand.theme.update");
expect(editor).toContain("content.brand.theme.update");
expect(editor).toContain("<form");
});
it("does not render email template bodies or localization payloads in summaries", () => {
const html = renderToStaticMarkup(
<ContentHelpPage
context={context([PERMS.PAGES_VIEW])}
result={ok(
{
kind: "help",
items: [
{
id: "1",
title: "Welcome",
status: "active",
privatePayload: "secret template body",
},
],
total: 1,
partialDependencies: [],
},
"help",
)}
routeId="content.help.email-templates"
/>,
);
expect(html).toContain("Welcome");
expect(html).not.toContain("secret template body");
});
it("renders create-event fields required by the production validator", () => {
const html = renderToStaticMarkup(
<ContentEngagementPage
context={context([PERMS.EVENTS_EDIT])}
result={ok(
{ kind: "engagement", items: [], total: 0, partialDependencies: [] },
"event-form",
)}
routeId="content.engagement.event-create"
/>,
);
for (const name of ["title", "description", "typeId", "startsAt"]) {
expect(html).toContain(`name="${name}"`);
}
});
it("renders validator-shaped prize, question, and prefix inputs", () => {
const eventHtml = renderToStaticMarkup(
<ContentEngagementPage
context={context([PERMS.EVENTS_EDIT])}
result={ok(
{ kind: "engagement", items: [], total: 0, partialDependencies: [] },
"event-prize-form",
)}
routeId="content.engagement.event-detail"
/>,
);
for (const name of [
"position",
"prizeType",
"badgeCode",
"credits",
"pixels",
"points",
"itemId",
"description",
]) {
expect(eventHtml).toContain(`name="${name}"`);
}
expect(eventHtml).not.toContain('name="prize"');
const pollHtml = renderToStaticMarkup(
<ContentEngagementPage
context={context([PERMS.POLLS_EDIT])}
result={ok(
{ kind: "engagement", items: [], total: 0, partialDependencies: [] },
"poll-question-form",
)}
routeId="content.engagement.poll-detail"
/>,
);
expect(pollHtml).toContain('name="options"');
const prefixHtml = renderToStaticMarkup(
<ContentEngagementPage
context={context([PERMS.PREFIXES_EDIT])}
result={ok(
{ kind: "engagement", items: [], total: 0, partialDependencies: [] },
"prefix-form",
)}
routeId="content.engagement.prefixes"
/>,
);
expect(prefixHtml).toContain('name="color"');
});
it("matches emulator setting fields to the database column bounds", () => {
const html = renderToStaticMarkup(
<ContentLocalizationPage
context={context([PERMS.SETTINGS_EDIT])}
result={ok(
{
kind: "localization",
items: [],
total: 0,
partialDependencies: [],
},
"emulator-form",
)}
routeId="content.localization.emulator"
/>,
);
expect(html).toContain('name="key"');
expect(html).toContain('maxLength="100"');
expect(html).toContain('name="value"');
expect(html).toContain('maxLength="512"');
});
});
src/features/housekeeping/domains/content/pages/editorial.tsx
-111
View File
@@ -1,111 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingPageInput } from "../../../route-handlers";
import { contentQuery } from "../queries/content-queries";
import { ContentCommandForm } from "./content-command-form";
import {
ContentPageFrame,
type ContentPageProps,
parseContentListInput,
} from "./content-page-frame";
export function ContentEditorialPage({
context,
result,
routeId,
}: ContentPageProps) {
const canNews = context.has(PERMS.NEWS_EDIT);
const canPages = context.has(PERMS.PAGES_EDIT);
return (
<ContentPageFrame
title="Editorial content"
description="Manage articles, navigation, tags, and writable boxes."
result={result}
forms={
<div className="grid gap-3 lg:grid-cols-2">
{canNews && routeId?.includes("article") ? (
<ContentCommandForm
commandId="content.editorial.article.change"
buttonLabel="Save article"
input={{
action: routeId.endsWith("create") ? "create" : "update",
}}
fields={[
{ name: "id", label: "Article ID", type: "identifier" },
{
name: "title",
label: "Title",
type: "text",
required: true,
maxLength: 255,
},
{
name: "content",
label: "Body",
type: "textarea",
required: true,
maxLength: 100_000,
},
]}
/>
) : null}
{canPages && routeId === "content.editorial.tags" ? (
<ContentCommandForm
commandId="content.editorial.tag.change"
buttonLabel="Save tag"
input={{ action: "update" }}
fields={[
{ name: "id", label: "Tag ID", type: "identifier" },
{
name: "name",
label: "Name",
type: "text",
required: true,
maxLength: 100,
},
]}
/>
) : null}
{canPages && routeId === "content.editorial.writeable-boxes" ? (
<ContentCommandForm
commandId="content.editorial.writeable-box.change"
buttonLabel="Save box"
input={{ action: "update" }}
fields={[
{ name: "id", label: "Box ID", type: "identifier" },
{
name: "title",
label: "Title",
type: "text",
required: true,
maxLength: 255,
},
{
name: "content",
label: "Content",
type: "textarea",
maxLength: 20_000,
},
]}
/>
) : null}
</div>
}
/>
);
}
export async function renderContentEditorialPage(input: HousekeepingPageInput) {
const routeId = input.match.routeId as ContentPageProps["routeId"];
const result = await contentQuery.run(input.context, {
routeId: routeId ?? "content.editorial.articles",
params: input.match.params,
list: parseContentListInput(input.searchParams ?? {}),
});
return (
<ContentEditorialPage
context={input.context}
result={result}
routeId={routeId}
/>
);
}
src/features/housekeeping/domains/content/pages/engagement.tsx
-429
View File
@@ -1,429 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingPageInput } from "../../../route-handlers";
import { contentQuery } from "../queries/content-queries";
import {
type ContentCommandField,
ContentCommandForm,
} from "./content-command-form";
import {
ContentPageFrame,
type ContentPageProps,
parseContentListInput,
} from "./content-page-frame";
export function ContentEngagementPage({
context,
result,
routeId,
}: ContentPageProps) {
const canEvents = context.has(PERMS.EVENTS_EDIT);
const canPolls = context.has(PERMS.POLLS_EDIT);
const canPrefixes = context.has(PERMS.PREFIXES_EDIT);
const creatingEvent = routeId === "content.engagement.event-create";
const creatingPoll = routeId === "content.engagement.poll-create";
const eventFields: readonly ContentCommandField[] = [
{
name: "id",
label: "Event ID",
type: "identifier",
required: !creatingEvent,
},
{
name: "title",
label: "Title",
type: "text",
required: creatingEvent,
maxLength: 255,
},
{
name: "description",
label: "Description",
type: "textarea",
required: creatingEvent,
maxLength: 20_000,
},
{
name: "typeId",
label: "Event type ID",
type: "identifier",
required: creatingEvent,
},
{ name: "roomId", label: "Room ID", type: "identifier" },
{
name: "startsAt",
label: "Starts at",
type: "text",
required: creatingEvent,
maxLength: 50,
},
{ name: "endsAt", label: "Ends at", type: "text", maxLength: 50 },
{ name: "maxPlayers", label: "Maximum players", type: "number", min: 1 },
{
name: "isRecurring",
label: "Recurring",
type: "checkbox",
allowUnchanged: !creatingEvent,
},
{
name: "recurrenceRule",
label: "Recurrence rule",
type: "text",
maxLength: 255,
},
{
name: "status",
label: "Status",
type: "select",
options: [
{ value: "draft", label: "Draft" },
{ value: "published", label: "Published" },
{ value: "cancelled", label: "Cancelled" },
{ value: "completed", label: "Completed" },
],
},
{ name: "image", label: "Image URL", type: "text", maxLength: 500 },
];
const pollFields: readonly ContentCommandField[] = [
{
name: "id",
label: "Poll ID",
type: "identifier",
required: !creatingPoll,
},
{
name: "title",
label: "Title",
type: "text",
required: creatingPoll,
maxLength: 255,
},
{
name: "description",
label: "Description",
type: "textarea",
maxLength: 2_000,
},
{
name: "status",
label: "Status",
type: "select",
options: [
{ value: "draft", label: "Draft" },
{ value: "active", label: "Active" },
{ value: "closed", label: "Closed" },
],
},
{
name: "showResults",
label: "Show results",
type: "checkbox",
defaultValue: creatingPoll,
allowUnchanged: !creatingPoll,
},
{
name: "multipleChoice",
label: "Allow multiple choices",
type: "checkbox",
allowUnchanged: !creatingPoll,
},
{ name: "startsAt", label: "Starts at", type: "text", maxLength: 50 },
{ name: "endsAt", label: "Ends at", type: "text", maxLength: 50 },
];
return (
<ContentPageFrame
title="Engagement"
description="Manage events, polls, and community prefixes."
result={result}
forms={
<div className="grid gap-3 lg:grid-cols-2">
{canEvents && routeId === "content.engagement.event-types" ? (
<ContentCommandForm
commandId="content.engagement.event-type.change"
buttonLabel="Save event type"
input={{ action: "update" }}
fields={[
{
name: "id",
label: "Type ID",
type: "identifier",
required: true,
},
{ name: "name", label: "Name", type: "text", maxLength: 100 },
{ name: "slug", label: "Slug", type: "text", maxLength: 100 },
{
name: "description",
label: "Description",
type: "textarea",
maxLength: 500,
},
{ name: "color", label: "Color", type: "text", maxLength: 20 },
{ name: "icon", label: "Icon", type: "text", maxLength: 50 },
{
name: "isActive",
label: "Active",
type: "checkbox",
allowUnchanged: true,
},
{
name: "minRank",
label: "Minimum rank",
type: "number",
min: 0,
max: 7,
},
]}
/>
) : null}
{canEvents &&
routeId?.includes("event") &&
routeId !== "content.engagement.event-types" ? (
<>
<ContentCommandForm
commandId="content.engagement.event.change"
buttonLabel="Save event"
input={{ action: creatingEvent ? "create" : "update" }}
fields={eventFields}
/>
<ContentCommandForm
commandId="content.engagement.event-prize.change"
buttonLabel="Save prize"
input={{ action: "create" }}
fields={[
{
name: "eventId",
label: "Event ID",
type: "identifier",
required: true,
},
{
name: "position",
label: "Position",
type: "number",
min: 1,
defaultValue: 1,
},
{
name: "prizeType",
label: "Prize type",
type: "select",
options: [
{ value: "badge", label: "Badge" },
{ value: "credits", label: "Credits" },
{ value: "pixels", label: "Pixels" },
{ value: "points", label: "Points" },
{ value: "item", label: "Item" },
],
},
{
name: "badgeCode",
label: "Badge code",
type: "text",
maxLength: 50,
},
{
name: "credits",
label: "Credits",
type: "number",
min: 0,
defaultValue: 0,
},
{
name: "pixels",
label: "Pixels",
type: "number",
min: 0,
defaultValue: 0,
},
{
name: "points",
label: "Points",
type: "number",
min: 0,
defaultValue: 0,
},
{ name: "itemId", label: "Item ID", type: "identifier" },
{
name: "description",
label: "Description",
type: "text",
maxLength: 255,
},
]}
/>
<ContentCommandForm
commandId="content.engagement.event-winner.add"
buttonLabel="Add winner"
input={{}}
fields={[
{
name: "eventId",
label: "Event ID",
type: "identifier",
required: true,
},
{
name: "userId",
label: "User ID",
type: "identifier",
required: true,
},
{
name: "position",
label: "Position",
type: "number",
min: 1,
defaultValue: 1,
},
]}
/>
</>
) : null}
{canPolls && routeId?.includes("poll") ? (
<>
<ContentCommandForm
commandId="content.engagement.poll.change"
buttonLabel="Save poll"
input={{ action: creatingPoll ? "create" : "update" }}
fields={pollFields}
/>
<ContentCommandForm
commandId="content.engagement.poll-question.change"
buttonLabel="Save question"
input={{ action: "create" }}
fields={[
{
name: "pollId",
label: "Poll ID",
type: "identifier",
required: true,
},
{
name: "question",
label: "Question",
type: "text",
required: true,
maxLength: 500,
},
{
name: "type",
label: "Question type",
type: "select",
options: [
{ value: "single", label: "Single choice" },
{ value: "multiple", label: "Multiple choice" },
{ value: "text", label: "Free text" },
],
},
{
name: "sortOrder",
label: "Sort order",
type: "number",
min: 0,
defaultValue: 0,
},
{
name: "options",
label: "Options",
type: "textarea",
required: true,
maxLength: 20_000,
},
]}
/>
</>
) : null}
{canPrefixes && routeId === "content.engagement.prefixes" ? (
<>
<ContentCommandForm
commandId="content.engagement.prefix.change"
buttonLabel="Save prefix"
input={{ action: "update" }}
fields={[
{
name: "id",
label: "Prefix ID",
type: "identifier",
required: true,
},
{
name: "text",
label: "Text",
type: "text",
required: true,
maxLength: 255,
},
{
name: "color",
label: "Color",
type: "text",
required: true,
maxLength: 32,
},
{ name: "icon", label: "Icon", type: "text", maxLength: 255 },
{
name: "effect",
label: "Effect",
type: "text",
maxLength: 255,
},
{
name: "active",
label: "Active",
type: "checkbox",
allowUnchanged: true,
},
]}
/>
<ContentCommandForm
commandId="content.engagement.prefix-blacklist.change"
buttonLabel="Update blacklist"
input={{ action: "add" }}
fields={[
{
name: "word",
label: "Word",
type: "text",
required: true,
maxLength: 255,
},
]}
/>
<ContentCommandForm
commandId="content.engagement.prefix-settings.update"
buttonLabel="Save prefix settings"
input={{}}
fields={[
{
name: "settings",
label: "Prefix settings JSON",
type: "json",
required: true,
maxLength: 20_000,
},
]}
/>
</>
) : null}
</div>
}
/>
);
}
export async function renderContentEngagementPage(
input: HousekeepingPageInput,
) {
const routeId = input.match.routeId as ContentPageProps["routeId"];
const result = await contentQuery.run(input.context, {
routeId: routeId ?? "content.engagement.events",
params: input.match.params,
list: parseContentListInput(input.searchParams ?? {}),
});
return (
<ContentEngagementPage
context={input.context}
result={result}
routeId={routeId}
/>
);
}
src/features/housekeeping/domains/content/pages/help.tsx
-97
View File
@@ -1,97 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingPageInput } from "../../../route-handlers";
import { contentQuery } from "../queries/content-queries";
import { ContentCommandForm } from "./content-command-form";
import {
ContentPageFrame,
type ContentPageProps,
parseContentListInput,
} from "./content-page-frame";
export function ContentHelpPage({
context,
result,
routeId,
}: ContentPageProps) {
const forms = context.has(PERMS.PAGES_EDIT) ? (
<div className="grid gap-3 lg:grid-cols-2">
{routeId?.includes("question") ? (
<ContentCommandForm
commandId="content.help.question.change"
buttonLabel="Save help question"
input={{ action: routeId.endsWith("create") ? "create" : "update" }}
fields={[
{ name: "id", label: "Question ID", type: "identifier" },
{
name: "name",
label: "Question",
type: "text",
required: true,
maxLength: 255,
},
{
name: "answer",
label: "Answer",
type: "textarea",
required: true,
maxLength: 20_000,
},
]}
/>
) : null}
{routeId === "content.help.email-templates" ? (
<ContentCommandForm
commandId="content.help.email-template.change"
buttonLabel="Save email template"
input={{ action: "update" }}
fields={[
{
name: "id",
label: "Template ID",
type: "identifier",
required: true,
},
{
name: "subject",
label: "Subject",
type: "text",
required: true,
maxLength: 255,
},
{
name: "body",
label: "Body",
type: "textarea",
required: true,
maxLength: 100_000,
},
]}
/>
) : null}
</div>
) : null;
return (
<ContentPageFrame
title="Help content"
description="Manage help questions and email templates."
result={result}
forms={forms}
/>
);
}
export async function renderContentHelpPage(input: HousekeepingPageInput) {
const routeId = input.match.routeId as ContentPageProps["routeId"];
const result = await contentQuery.run(input.context, {
routeId: routeId ?? "content.help.questions",
params: input.match.params,
list: parseContentListInput(input.searchParams ?? {}),
});
return (
<ContentHelpPage
context={input.context}
result={result}
routeId={routeId}
/>
);
}
src/features/housekeeping/domains/content/pages/localization.tsx
-118
View File
@@ -1,118 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingPageInput } from "../../../route-handlers";
import { contentQuery } from "../queries/content-queries";
import { ContentCommandForm } from "./content-command-form";
import {
ContentPageFrame,
type ContentPageProps,
parseContentListInput,
} from "./content-page-frame";
export function ContentLocalizationPage({
context,
result,
routeId,
}: ContentPageProps) {
const forms = context.has(PERMS.SETTINGS_EDIT) ? (
<div className="grid gap-3 lg:grid-cols-2">
{routeId === "content.localization.cms" ? (
<ContentCommandForm
commandId="content.localization.cms.save"
buttonLabel="Save CMS translations"
input={{}}
fields={[
{
name: "locale",
label: "Locale",
type: "text",
required: true,
maxLength: 16,
},
{
name: "data",
label: "Translation JSON",
type: "json",
required: true,
maxLength: 500_000,
},
]}
requiresReason
/>
) : null}
{routeId === "content.localization.client" ? (
<ContentCommandForm
commandId="content.localization.client.save"
buttonLabel="Save client translations"
input={{}}
fields={[
{
name: "fileId",
label: "Translation file",
type: "text",
required: true,
maxLength: 100,
},
{
name: "data",
label: "Translation JSON",
type: "json",
required: true,
maxLength: 500_000,
},
]}
requiresReason
/>
) : null}
{routeId === "content.localization.emulator" ? (
<ContentCommandForm
commandId="content.localization.emulator.save"
buttonLabel="Save emulator translation"
input={{}}
fields={[
{
name: "key",
label: "Key",
type: "text",
required: true,
maxLength: 100,
},
{
name: "value",
label: "Value",
type: "textarea",
required: true,
maxLength: 512,
},
]}
requiresReason
/>
) : null}
</div>
) : null;
return (
<ContentPageFrame
title="Localization"
description="Manage CMS, client, and emulator translation stores."
result={result}
forms={forms}
/>
);
}
export async function renderContentLocalizationPage(
input: HousekeepingPageInput,
) {
const routeId = input.match.routeId as ContentPageProps["routeId"];
const result = await contentQuery.run(input.context, {
routeId: routeId ?? "content.localization.overview",
params: input.match.params,
list: parseContentListInput(input.searchParams ?? {}),
});
return (
<ContentLocalizationPage
context={input.context}
result={result}
routeId={routeId}
/>
);
}
src/features/housekeeping/domains/content/pages/media.tsx
-127
View File
@@ -1,127 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingPageInput } from "../../../route-handlers";
import { contentQuery } from "../queries/content-queries";
import { ContentCommandForm } from "./content-command-form";
import {
ContentPageFrame,
type ContentPageProps,
parseContentListInput,
} from "./content-page-frame";
export function ContentMediaPage({
context,
result,
routeId,
}: ContentPageProps) {
const canPages = context.has(PERMS.PAGES_EDIT);
const canBanners = context.has(PERMS.BANNERS_EDIT);
return (
<ContentPageFrame
title="Media"
description="Manage photos, uploaded media, banners, and advertisements."
result={result}
forms={
<div className="grid gap-3 lg:grid-cols-2">
{canPages && routeId === "content.media.photos" ? (
<ContentCommandForm
commandId="content.media.photo.delete"
buttonLabel="Delete photo"
input={{}}
fields={[
{
name: "id",
label: "Photo ID",
type: "identifier",
required: true,
},
]}
/>
) : null}
{canPages && routeId === "content.media.library" ? (
<>
<ContentCommandForm
commandId="content.media.asset.upload"
buttonLabel="Upload media"
input={{}}
fields={[
{
name: "file",
label: "Media file",
type: "file",
required: true,
},
]}
/>
<ContentCommandForm
commandId="content.media.asset.delete"
buttonLabel="Delete media"
input={{}}
fields={[
{
name: "filename",
label: "Filename",
type: "text",
required: true,
maxLength: 255,
},
]}
/>
</>
) : null}
{canBanners && routeId === "content.media.banners" ? (
<ContentCommandForm
commandId="content.media.banner.change"
buttonLabel="Save banner"
input={{ action: "update" }}
fields={[
{ name: "id", label: "Banner ID", type: "identifier" },
{ name: "title", label: "Title", type: "text", maxLength: 255 },
]}
/>
) : null}
{canPages && routeId?.includes("ad") ? (
<ContentCommandForm
commandId="content.media.ad.change"
buttonLabel="Save advertisement"
input={{
action: routeId.endsWith("create") ? "create" : "update",
}}
fields={[
{ name: "id", label: "Advertisement ID", type: "identifier" },
{
name: "image",
label: "Image path",
type: "text",
required: true,
maxLength: 500,
},
{
name: "url",
label: "Destination",
type: "text",
maxLength: 1000,
},
]}
/>
) : null}
</div>
}
/>
);
}
export async function renderContentMediaPage(input: HousekeepingPageInput) {
const routeId = input.match.routeId as ContentPageProps["routeId"];
const result = await contentQuery.run(input.context, {
routeId: routeId ?? "content.media.photos",
params: input.match.params,
list: parseContentListInput(input.searchParams ?? {}),
});
return (
<ContentMediaPage
context={input.context}
result={result}
routeId={routeId}
/>
);
}
src/features/housekeeping/domains/content/queries/content-queries-production.ts
-418
View File
@@ -1,418 +0,0 @@
import "server-only";
import type { SQL } from "drizzle-orm";
import { type ContentRouteId, contentRouteGroup } from "../routes";
import type {
ContentQueryData,
ContentQueryItem,
NormalizedContentQueryInput,
} from "./content-queries";
type RawRow = Readonly<Record<string, unknown>>;
interface QueryDefinition {
readonly statement: string;
readonly href: string;
readonly appendId?: boolean;
}
export const CONTENT_QUERY_DEFINITIONS = {
"content.editorial.articles": {
statement:
"SELECT id, title, slug AS description, 'published' AS status, updated_at FROM website_articles ORDER BY created_at DESC",
href: "/ase/content/editorial/articles/",
appendId: true,
},
"content.editorial.article-detail": {
statement:
"SELECT id, title, slug AS description, 'published' AS status, updated_at FROM website_articles ORDER BY created_at DESC",
href: "/ase/content/editorial/articles/",
appendId: true,
},
"content.editorial.tags": {
statement:
"SELECT id, name AS title, background_color AS status, updated_at FROM tags ORDER BY name",
href: "/ase/content/editorial/tags",
},
"content.editorial.writeable-boxes": {
statement:
"SELECT id, title, CASE WHEN is_active = 1 THEN 'active' ELSE 'hidden' END AS status, updated_at FROM website_writeable_boxes ORDER BY position, id",
href: "/ase/content/editorial/writeable-boxes",
},
"content.media.photos": {
statement:
"SELECT id, url AS title, 'published' AS status, FROM_UNIXTIME(timestamp) AS updated_at FROM camera_web ORDER BY id DESC",
href: "/ase/content/media/photos",
},
"content.media.banners": {
statement:
"SELECT id, title, CASE WHEN is_active = 1 THEN 'active' ELSE 'hidden' END AS status, NULL AS updated_at FROM website_banners ORDER BY sort_order, id",
href: "/ase/content/media/banners",
},
"content.media.ads": {
statement:
"SELECT id, image AS title, 'active' AS status, updated_at FROM website_ads ORDER BY created_at DESC",
href: "/ase/content/media/ads/",
appendId: true,
},
"content.media.ad-detail": {
statement:
"SELECT id, image AS title, 'active' AS status, updated_at FROM website_ads ORDER BY created_at DESC",
href: "/ase/content/media/ads/",
appendId: true,
},
"content.engagement.events": {
statement:
"SELECT id, title, status, updated_at FROM website_events ORDER BY starts_at DESC",
href: "/ase/content/engagement/events/",
appendId: true,
},
"content.engagement.event-detail": {
statement:
"SELECT id, title, status, updated_at FROM website_events ORDER BY starts_at DESC",
href: "/ase/content/engagement/events/",
appendId: true,
},
"content.engagement.event-types": {
statement:
"SELECT id, name AS title, CASE WHEN is_active = 1 THEN 'active' ELSE 'inactive' END AS status, NULL AS updated_at FROM website_event_types ORDER BY name",
href: "/ase/content/engagement/events/types",
},
"content.engagement.polls": {
statement:
"SELECT id, title, status, updated_at FROM website_polls ORDER BY created_at DESC",
href: "/ase/content/engagement/polls/",
appendId: true,
},
"content.engagement.poll-detail": {
statement:
"SELECT id, title, status, updated_at FROM website_polls ORDER BY created_at DESC",
href: "/ase/content/engagement/polls/",
appendId: true,
},
"content.engagement.prefixes": {
statement:
"SELECT id, text AS title, color AS description, CASE WHEN active = 1 THEN 'active' ELSE 'inactive' END AS status, NULL AS updated_at FROM custom_prefixes ORDER BY id DESC",
href: "/ase/content/engagement/prefixes",
},
"content.help.questions": {
statement:
"SELECT id, name AS title, CONCAT('position-', position) AS status, NULL AS updated_at FROM website_help_center_categories ORDER BY position, id",
href: "/ase/content/help/questions/",
appendId: true,
},
"content.help.question-detail": {
statement:
"SELECT id, name AS title, CONCAT('position-', position) AS status, NULL AS updated_at FROM website_help_center_categories ORDER BY position, id",
href: "/ase/content/help/questions/",
appendId: true,
},
"content.help.email-templates": {
statement:
"SELECT id, name AS title, subject AS description, CASE WHEN is_active = 1 THEN 'active' ELSE 'inactive' END AS status, updated_at FROM email_templates ORDER BY name",
href: "/ase/content/help/email-templates",
},
"content.localization.emulator": {
statement:
"SELECT emulator_settings.key AS id, emulator_settings.key AS title, LEFT(emulator_settings.value, 120) AS description, 'configured' AS status, NULL AS updated_at FROM emulator_settings ORDER BY emulator_settings.key",
href: "/ase/content/localization/emulator",
},
} as const satisfies Partial<Record<ContentRouteId, QueryDefinition>>;
const EMPTY_ROUTES = new Set<ContentRouteId>([
"content.editorial.article-create",
"content.media.ad-create",
"content.engagement.event-create",
"content.engagement.poll-create",
"content.help.question-create",
]);
function rows(result: unknown): readonly RawRow[] {
if (!Array.isArray(result) || !Array.isArray(result[0])) {
throw new Error("invalid Content query result");
}
return result[0] as readonly RawRow[];
}
function value(value: unknown, fallback = ""): string {
return typeof value === "string"
? value
: value == null
? fallback
: String(value);
}
function updatedAt(value: unknown): string | null {
if (value == null) return null;
const parsed = value instanceof Date ? value : new Date(String(value));
return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : null;
}
function response(
input: NormalizedContentQueryInput,
items: readonly ContentQueryItem[],
total = items.length,
): ContentQueryData {
const start = input.list.offset;
return {
kind: contentRouteGroup(input.routeId),
items: items.slice(start, start + input.list.pageSize),
total,
partialDependencies: [],
};
}
function matchesListSearch(
input: NormalizedContentQueryInput,
item: ContentQueryItem,
): boolean {
const needle = input.list.search.toLocaleLowerCase();
return (
needle.length === 0 ||
item.title.toLocaleLowerCase().includes(needle) ||
item.description?.toLocaleLowerCase().includes(needle) === true
);
}
function mapRows(
definition: QueryDefinition,
rawRows: readonly RawRow[],
): readonly ContentQueryItem[] {
return rawRows.map((row) => {
const id = value(row.id);
if (!id) throw new Error("invalid Content identifier");
return {
id,
title: value(row.title, "Untitled content"),
description: value(row.description) || undefined,
status: value(row.status) || undefined,
updatedAt: updatedAt(row.updated_at),
href: definition.appendId ? definition.href + id : definition.href,
};
});
}
function statementParts(statement: string): {
readonly selection: string;
readonly ordering: string;
} {
const match = /^(.*?)(\s+ORDER BY\s+.+)$/iu.exec(statement);
return match
? { selection: match[1], ordering: match[2] }
: { selection: statement, ordering: "" };
}
function totalFromRows(rawRows: readonly RawRow[]): number {
const total = Number(rawRows[0]?.total ?? 0);
if (!Number.isSafeInteger(total) || total < 0)
throw new Error("invalid Content query total");
return total;
}
async function databaseRoute(
input: NormalizedContentQueryInput,
definition: QueryDefinition,
): Promise<ContentQueryData> {
const [{ sql }, { db }] = await Promise.all([
import("drizzle-orm"),
import("@/lib/db"),
]);
const { selection, ordering } = statementParts(definition.statement);
const filters: SQL[] = [];
if (input.list.search) {
const pattern = `%${input.list.search.toLocaleLowerCase()}%`;
filters.push(
/\bAS\s+description\b/iu.test(selection)
? sql`(LOWER(COALESCE(title, '')) LIKE ${pattern} OR LOWER(COALESCE(description, '')) LIKE ${pattern})`
: sql`LOWER(COALESCE(title, '')) LIKE ${pattern}`,
);
}
if (input.params.id) filters.push(sql`CAST(id AS CHAR) = ${input.params.id}`);
const filtered = filters.length
? sql`${sql.raw(selection)} HAVING ${sql.join(filters, sql` AND `)}`
: sql.raw(selection);
const total = totalFromRows(
rows(
await db.execute(
sql`SELECT COUNT(*) AS total FROM (${filtered}) AS content_rows`,
),
),
);
const items = mapRows(
definition,
rows(
await db.execute(
sql`${filtered} ${sql.raw(ordering)} LIMIT ${input.list.pageSize} OFFSET ${input.list.offset}`,
),
),
);
return {
kind: contentRouteGroup(input.routeId),
items,
total,
partialDependencies: [],
};
}
async function mediaLibrary(
input: NormalizedContentQueryInput,
): Promise<ContentQueryData> {
const [{ readdir, stat }, { resolve }, { MEDIA_ROOT }] = await Promise.all([
import("node:fs/promises"),
import("node:path"),
import("@/lib/media-storage"),
]);
let names: string[];
try {
names = (await readdir(MEDIA_ROOT)).filter((name) =>
/[.](png|jpe?g|gif|webp|svg|bmp)$/iu.test(name),
);
} catch (error) {
if ((error as NodeJS.ErrnoException).code === "ENOENT")
return response(input, []);
throw error;
}
const entries = await Promise.all(
names.map(async (name) => ({
name,
metadata: await stat(resolve(MEDIA_ROOT, name)),
})),
);
entries.sort((left, right) => right.metadata.mtimeMs - left.metadata.mtimeMs);
const items = entries
.map(({ name, metadata }) => ({
id: name,
title: name,
description: `${String(metadata.size)} bytes`,
status: "stored",
updatedAt: metadata.mtime.toISOString(),
href: "/ase/content/media/library",
}))
.filter((item) => matchesListSearch(input, item));
return response(input, items, items.length);
}
async function brand(
input: NormalizedContentQueryInput,
): Promise<ContentQueryData> {
const [{ siteSettings }, { listCustomThemes }] = await Promise.all([
import("@/lib/services/site-settings"),
import("@/lib/theme-custom-store"),
]);
if (input.routeId === "content.brand.favicon") {
const favicon = await siteSettings.get("cms_favicon", null);
return response(input, [
{
id: "favicon",
title: favicon || "Default favicon",
status: favicon ? "custom" : "default",
href: "/ase/content/brand/favicon",
},
]);
}
const [preset, customThemes] = await Promise.all([
siteSettings.get("theme_preset", "Atom (golden)"),
listCustomThemes(),
]);
return response(input, [
{
id: "active-theme",
title: preset || "Atom (golden)",
status: "active",
href: "/ase/content/brand/theme",
},
...customThemes.map((theme) => ({
id: theme.id,
title: theme.name,
status: "saved",
updatedAt: new Date(theme.createdAt).toISOString(),
href: "/ase/content/brand/theme",
})),
]);
}
async function localizationFiles(
input: NormalizedContentQueryInput,
): Promise<ContentQueryData> {
if (input.routeId === "content.localization.client") {
const { CLIENT_TRANSLATION_FILES } = await import(
"@/lib/client-translation-files"
);
return response(
input,
CLIENT_TRANSLATION_FILES.map((file) => ({
id: file.id,
title: file.id,
description: file.relPath,
status: file.readOnly ? "read-only" : "editable",
href: "/ase/content/localization/client",
})),
);
}
const [{ readdir }, { join }] = await Promise.all([
import("node:fs/promises"),
import("node:path"),
]);
let locales: string[] = [];
try {
locales = (await readdir(join(process.cwd(), "src", "messages")))
.filter((name) => name.endsWith(".json"))
.map((name) => name.slice(0, -5))
.sort();
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
}
if (input.routeId === "content.localization.overview") {
return response(input, [
{
id: "cms",
title: "CMS translations",
status: `${String(locales.length)} locales`,
href: "/ase/content/localization/cms",
},
{
id: "client",
title: "Client translations",
status: "configured sources",
href: "/ase/content/localization/client",
},
{
id: "emulator",
title: "Emulator translations",
status: "database store",
href: "/ase/content/localization/emulator",
},
]);
}
return response(
input,
locales.map((locale) => ({
id: locale,
title: locale,
status: "editable",
href: "/ase/content/localization/cms",
})),
);
}
export async function loadProductionContentQuery(
input: NormalizedContentQueryInput,
): Promise<ContentQueryData> {
if (EMPTY_ROUTES.has(input.routeId)) return response(input, []);
if (input.routeId === "content.media.library") return mediaLibrary(input);
if (input.routeId.startsWith("content.brand.")) return brand(input);
if (
input.routeId === "content.localization.overview" ||
input.routeId === "content.localization.client" ||
input.routeId === "content.localization.cms"
) {
return localizationFiles(input);
}
const definition = (
CONTENT_QUERY_DEFINITIONS as Partial<
Record<ContentRouteId, QueryDefinition>
>
)[input.routeId];
if (!definition) throw new Error("missing Content query adapter");
return databaseRoute(input, definition);
}
src/features/housekeeping/domains/content/queries/content-queries.test.ts
-215
View File
@@ -1,215 +0,0 @@
import { describe, expect, it, vi } from "vitest";
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingCapabilityContext } from "../../../foundation/contracts";
import { CONTENT_ROUTE_IDS } from "../routes";
import {
type ContentQueryData,
type ContentQueryInput,
createContentQuery,
} from "./content-queries";
import {
CONTENT_QUERY_DEFINITIONS,
loadProductionContentQuery,
} from "./content-queries-production";
const queryMocks = vi.hoisted(() => ({
execute: vi.fn(),
join: vi.fn((chunks: unknown[], separator: unknown) => ({
chunks,
separator,
})),
raw: vi.fn((statement: string) => ({ statement })),
tagged: vi.fn((strings: TemplateStringsArray, ...values: unknown[]) => ({
strings: Array.from(strings),
values,
})),
}));
vi.mock("drizzle-orm", () => ({
sql: Object.assign(queryMocks.tagged, {
join: queryMocks.join,
raw: queryMocks.raw,
}),
}));
vi.mock("@/lib/db", () => ({ db: { execute: queryMocks.execute } }));
function context(granted: readonly string[]): HousekeepingCapabilityContext {
const permissions = new Set(granted);
return {
actor: { id: 42, username: "operator", rank: 7 },
isSuperAdmin: false,
has: (slug) => permissions.has(slug),
hasAny: (...slugs) => slugs.some((slug) => permissions.has(slug)),
hasAll: (...slugs) => slugs.every((slug) => permissions.has(slug)),
};
}
const ready: ContentQueryData = {
kind: "editorial",
items: [
{
id: "18446744073709551615",
title: "Published article",
status: "published",
href: "/ase/content/editorial/articles/18446744073709551615",
},
],
total: 1,
partialDependencies: [],
};
describe("Content query", () => {
it("reports totals beyond the former 500-row adapter cap", async () => {
const pageRows = Array.from({ length: 25 }, (_, index) => ({
id: index + 1,
title: `Article ${index + 1}`,
status: "published",
updated_at: null,
}));
queryMocks.execute
.mockResolvedValueOnce([[{ total: 600 }]])
.mockResolvedValueOnce([pageRows]);
const result = await loadProductionContentQuery({
routeId: "content.editorial.articles",
params: {},
list: { search: "", pageSize: 25, offset: 0 },
});
expect(result.total).toBe(600);
expect(result.items).toHaveLength(25);
expect(queryMocks.execute).toHaveBeenCalledTimes(2);
const pageQuery = queryMocks.execute.mock.calls[1]?.[0];
expect(JSON.stringify(pageQuery)).toContain("25");
expect(JSON.stringify(pageQuery)).toContain("0");
});
it("binds search, limit, and offset into the bounded page query", async () => {
queryMocks.execute
.mockResolvedValueOnce([[{ total: 1 }]])
.mockResolvedValueOnce([
[{ id: 9, title: "Launch", status: "published", updated_at: null }],
]);
await loadProductionContentQuery({
routeId: "content.editorial.articles",
params: {},
list: { search: "Launch", pageSize: 7, offset: 14 },
});
const serialized = JSON.stringify(queryMocks.execute.mock.calls);
expect(serialized).toContain("%launch%");
expect(serialized).toContain("7");
expect(serialized).toContain("14");
});
it("searches only projected aliases for routes without descriptions", async () => {
queryMocks.execute
.mockResolvedValueOnce([[{ total: 0 }]])
.mockResolvedValueOnce([[]]);
await loadProductionContentQuery({
routeId: "content.engagement.events",
params: {},
list: { search: "launch", pageSize: 25, offset: 0 },
});
const serialized = JSON.stringify(queryMocks.execute.mock.calls.slice(-2));
expect(serialized).toContain("COALESCE(title");
expect(serialized).not.toContain("COALESCE(description");
});
it("never selects email template bodies into summary query results", () => {
const emailTemplates =
CONTENT_QUERY_DEFINITIONS["content.help.email-templates"];
expect(emailTemplates.statement).not.toMatch(/\bbody\b|private_payload/iu);
});
it("fails closed before production adapters are invoked", async () => {
const load = vi.fn(async () => ready);
const query = createContentQuery({ load });
const result = await query.run(context([]), {
routeId: "content.editorial.articles",
list: { search: "", pageSize: 25, offset: 0 },
});
expect(result).toMatchObject({
ok: false,
error: { code: "FORBIDDEN" },
});
expect(load).not.toHaveBeenCalled();
});
it("bounds list input, preserves canonical BIGINT strings, and returns real adapter data", async () => {
const load = vi.fn(async (_input: ContentQueryInput) => ready);
const query = createContentQuery({ load });
const result = await query.run(context([PERMS.NEWS_VIEW]), {
routeId: "content.editorial.articles",
list: {
search: " launch ",
pageSize: 1000,
offset: 999_999,
},
});
expect(load).toHaveBeenCalledWith({
routeId: "content.editorial.articles",
params: {},
list: { search: "launch", pageSize: 100, offset: 100_000 },
});
expect(result).toMatchObject({
ok: true,
data: {
items: [{ id: "18446744073709551615" }],
total: 1,
partialDependencies: [],
},
});
});
it("rejects a fake partial result and maps complete adapter failure", async () => {
const malformed = createContentQuery({
load: async () =>
({
kind: "media",
items: [],
total: 0,
partialDependencies: ["imaginary"],
}) as ContentQueryData,
});
const unavailable = createContentQuery({
load: async () => {
throw new Error("database unavailable");
},
});
expect(
await malformed.run(context([PERMS.PAGES_VIEW]), {
routeId: "content.media.library",
}),
).toMatchObject({
ok: false,
error: { code: "DEPENDENCY_UNAVAILABLE" },
});
expect(
await unavailable.run(context([PERMS.PAGES_VIEW]), {
routeId: "content.media.library",
}),
).toMatchObject({
ok: false,
error: { code: "DEPENDENCY_UNAVAILABLE" },
});
});
it("has an authorized production query path for every Content route", async () => {
const load = vi.fn(async (input: ContentQueryInput) => ({
kind: input.routeId.split(".")[1] as ContentQueryData["kind"],
items: [],
total: 0,
partialDependencies: [],
}));
const query = createContentQuery({ load });
const all = context(Object.values(PERMS));
for (const routeId of CONTENT_ROUTE_IDS) {
const result = await query.run(all, { routeId });
expect(result.ok, routeId).toBe(true);
}
expect(load).toHaveBeenCalledTimes(CONTENT_ROUTE_IDS.length);
});
});
src/features/housekeeping/domains/content/queries/content-queries.ts
-149
View File
@@ -1,149 +0,0 @@
import { authorizeHousekeeping } from "../../../foundation/authorization";
import {
fail,
type HousekeepingQuery,
ok,
} from "../../../foundation/contracts";
import { isSafeHousekeepingHref } from "../../../foundation/housekeeping-href";
import {
type ContentRouteGroup,
type ContentRouteId,
contentRouteById,
contentRouteGroup,
} from "../routes";
export interface ContentQueryListInput {
readonly search?: string;
readonly pageSize?: number;
readonly offset?: number;
}
export interface ContentQueryInput {
readonly routeId: ContentRouteId;
readonly params?: Readonly<Record<string, string>>;
readonly list?: ContentQueryListInput;
}
export interface ContentQueryItem {
readonly id: string;
readonly title: string;
readonly status?: string;
readonly description?: string;
readonly href?: string;
readonly updatedAt?: string | null;
readonly privatePayload?: unknown;
}
export interface ContentQueryData {
readonly kind: ContentRouteGroup;
readonly items: readonly ContentQueryItem[];
readonly total: number;
readonly partialDependencies: readonly string[];
}
export interface NormalizedContentQueryInput {
readonly routeId: ContentRouteId;
readonly params: Readonly<Record<string, string>>;
readonly list: Readonly<{
search: string;
pageSize: number;
offset: number;
}>;
}
export interface ContentQueryAdapters {
load(input: NormalizedContentQueryInput): Promise<ContentQueryData>;
}
function boundedInteger(
value: unknown,
fallback: number,
minimum: number,
maximum: number,
): number {
const parsed = Number(value);
if (!Number.isSafeInteger(parsed)) return fallback;
return Math.min(maximum, Math.max(minimum, parsed));
}
function normalizeInput(input: ContentQueryInput): NormalizedContentQueryInput {
return {
routeId: input.routeId,
params: Object.fromEntries(
Object.entries(input.params ?? {}).map(([key, value]) => [
key.normalize("NFC").trim().slice(0, 128),
value.normalize("NFC").trim().slice(0, 128),
]),
),
list: {
search: String(input.list?.search ?? "")
.normalize("NFC")
.trim()
.slice(0, 128),
pageSize: boundedInteger(input.list?.pageSize, 25, 1, 100),
offset: boundedInteger(input.list?.offset, 0, 0, 100_000),
},
};
}
function isValidData(
data: ContentQueryData,
input: NormalizedContentQueryInput,
): boolean {
if (
data.kind !== contentRouteGroup(input.routeId) ||
!Array.isArray(data.items) ||
!Number.isSafeInteger(data.total) ||
data.total < 0 ||
!Array.isArray(data.partialDependencies) ||
data.partialDependencies.length !== 0
) {
return false;
}
return data.items.every(
(item) =>
typeof item.id === "string" &&
item.id.length > 0 &&
typeof item.title === "string" &&
item.title.length > 0 &&
(item.href === undefined || isSafeHousekeepingHref(item.href)),
);
}
export function createContentQuery(
adapters: ContentQueryAdapters,
): HousekeepingQuery<ContentQueryInput, ContentQueryData> {
return {
id: "content.query",
owner: "content",
capability: contentRouteById("content.editorial.articles").capability,
async run(context, input) {
const route = contentRouteById(input.routeId);
const authorization = authorizeHousekeeping(context, route.capability);
if (!authorization.ok) return authorization;
const normalized = normalizeInput(input);
try {
const data = await adapters.load(normalized);
if (!isValidData(data, normalized)) {
throw new Error("invalid Content query data");
}
return ok(data, authorization.correlationId);
} catch {
return fail(
"DEPENDENCY_UNAVAILABLE",
"errors.housekeeping.dependencyUnavailable",
authorization.correlationId,
);
}
},
};
}
export const contentQuery = createContentQuery({
async load(input) {
const { loadProductionContentQuery } = await import(
"./content-queries-production"
);
return loadProductionContentQuery(input);
},
});
src/features/housekeeping/domains/content/route-handlers.ts
-31
View File
@@ -1,31 +0,0 @@
import type { HousekeepingRouteHandler } from "../../route-handlers";
import { renderContentBrandPage } from "./pages/brand";
import { renderContentEditorialPage } from "./pages/editorial";
import { renderContentEngagementPage } from "./pages/engagement";
import { renderContentHelpPage } from "./pages/help";
import { renderContentLocalizationPage } from "./pages/localization";
import { renderContentMediaPage } from "./pages/media";
import {
CONTENT_ROUTE_IDS,
type ContentRouteId,
contentRouteGroup,
} from "./routes";
function rendererFor(
routeId: ContentRouteId,
): HousekeepingRouteHandler["render"] {
const group = contentRouteGroup(routeId);
if (group === "editorial") return renderContentEditorialPage;
if (group === "media") return renderContentMediaPage;
if (group === "engagement") return renderContentEngagementPage;
if (group === "help") return renderContentHelpPage;
if (group === "brand") return renderContentBrandPage;
return renderContentLocalizationPage;
}
export const CONTENT_ROUTE_HANDLERS: readonly HousekeepingRouteHandler[] =
Object.freeze(
CONTENT_ROUTE_IDS.map((routeId) =>
Object.freeze({ routeId, render: rendererFor(routeId) }),
),
);
src/features/housekeeping/domains/content/routes.test.ts
-140
View File
@@ -1,140 +0,0 @@
import { describe, expect, it } from "vitest";
import { HOUSEKEEPING_MANIFESTS } from "../../manifests";
import { contentMigrationEntries } from "../../migration/content";
import { HOUSEKEEPING_ROUTE_HANDLERS } from "../../route-handlers";
import { contentManifest } from "./manifest";
import {
CONTENT_ROUTE_GROUPS,
CONTENT_ROUTE_IDS,
CONTENT_ROUTES,
type ContentRouteId,
contentRouteGroup,
} from "./routes";
const expected = [
[
"content.editorial.articles",
"/ase/content/editorial/articles",
"editorial",
],
[
"content.editorial.article-create",
"/ase/content/editorial/articles/new",
"editorial",
],
[
"content.editorial.article-detail",
"/ase/content/editorial/articles/:id",
"editorial",
],
["content.media.photos", "/ase/content/media/photos", "media"],
["content.media.library", "/ase/content/media/library", "media"],
["content.media.banners", "/ase/content/media/banners", "media"],
["content.media.ads", "/ase/content/media/ads", "media"],
["content.media.ad-create", "/ase/content/media/ads/new", "media"],
["content.media.ad-detail", "/ase/content/media/ads/:id", "media"],
["content.engagement.events", "/ase/content/engagement/events", "engagement"],
[
"content.engagement.event-create",
"/ase/content/engagement/events/create",
"engagement",
],
[
"content.engagement.event-types",
"/ase/content/engagement/events/types",
"engagement",
],
[
"content.engagement.event-detail",
"/ase/content/engagement/events/:id",
"engagement",
],
["content.engagement.polls", "/ase/content/engagement/polls", "engagement"],
[
"content.engagement.poll-create",
"/ase/content/engagement/polls/create",
"engagement",
],
[
"content.engagement.poll-detail",
"/ase/content/engagement/polls/:id",
"engagement",
],
["content.help.questions", "/ase/content/help/questions", "help"],
["content.help.question-create", "/ase/content/help/questions/new", "help"],
["content.help.question-detail", "/ase/content/help/questions/:id", "help"],
["content.editorial.tags", "/ase/content/editorial/tags", "editorial"],
[
"content.engagement.prefixes",
"/ase/content/engagement/prefixes",
"engagement",
],
[
"content.editorial.writeable-boxes",
"/ase/content/editorial/writeable-boxes",
"editorial",
],
["content.help.email-templates", "/ase/content/help/email-templates", "help"],
["content.brand.theme", "/ase/content/brand/theme", "brand"],
["content.brand.favicon", "/ase/content/brand/favicon", "brand"],
[
"content.localization.overview",
"/ase/content/localization",
"localization",
],
[
"content.localization.client",
"/ase/content/localization/client",
"localization",
],
["content.localization.cms", "/ase/content/localization/cms", "localization"],
[
"content.localization.emulator",
"/ase/content/localization/emulator",
"localization",
],
] as const;
describe("Content routes", () => {
it("declares the six exact route groups", () => {
expect(CONTENT_ROUTE_GROUPS).toEqual([
"editorial",
"media",
"engagement",
"help",
"brand",
"localization",
]);
});
it("maps every migration row to its canonical route and group", () => {
expect(
CONTENT_ROUTES.map((route) => [
route.id,
route.href,
contentRouteGroup(route.id as ContentRouteId),
]),
).toEqual(expected);
expect(CONTENT_ROUTE_IDS).toEqual(expected.map(([id]) => id));
expect(CONTENT_ROUTES.map((route) => route.href).sort()).toEqual(
contentMigrationEntries
.filter((entry) => entry.targetPath !== null)
.map((entry) => entry.targetPath)
.sort(),
);
});
it("keeps manifest routes and real handlers in exact equality", () => {
expect(contentManifest.routes).toBe(CONTENT_ROUTES);
expect(contentManifest.routes.map((route) => route.id)).toEqual(
HOUSEKEEPING_ROUTE_HANDLERS.filter((handler) =>
handler.routeId.startsWith("content."),
).map((handler) => handler.routeId),
);
expect(
HOUSEKEEPING_MANIFESTS.flatMap((manifest) =>
manifest.routes.map((route) => route.id),
),
).toEqual(HOUSEKEEPING_ROUTE_HANDLERS.map((handler) => handler.routeId));
});
});
src/features/housekeeping/domains/content/routes.ts
-205
View File
@@ -1,205 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import {
anyCapability,
type CanonicalHousekeepingHref,
type HousekeepingRouteDefinition,
} from "../../foundation/contracts";
export const CONTENT_ROUTE_GROUPS = [
"editorial",
"media",
"engagement",
"help",
"brand",
"localization",
] as const;
export type ContentRouteGroup = (typeof CONTENT_ROUTE_GROUPS)[number];
export const CONTENT_ROUTE_IDS = [
"content.editorial.articles",
"content.editorial.article-create",
"content.editorial.article-detail",
"content.media.photos",
"content.media.library",
"content.media.banners",
"content.media.ads",
"content.media.ad-create",
"content.media.ad-detail",
"content.engagement.events",
"content.engagement.event-create",
"content.engagement.event-types",
"content.engagement.event-detail",
"content.engagement.polls",
"content.engagement.poll-create",
"content.engagement.poll-detail",
"content.help.questions",
"content.help.question-create",
"content.help.question-detail",
"content.editorial.tags",
"content.engagement.prefixes",
"content.editorial.writeable-boxes",
"content.help.email-templates",
"content.brand.theme",
"content.brand.favicon",
"content.localization.overview",
"content.localization.client",
"content.localization.cms",
"content.localization.emulator",
] as const;
export type ContentRouteId = (typeof CONTENT_ROUTE_IDS)[number];
function contentRoute(
id: ContentRouteId,
href: CanonicalHousekeepingHref,
capabilities: readonly string[],
): HousekeepingRouteDefinition {
return {
id,
labelKey: `pages.housekeeping.routes.${id}`,
href,
capability: anyCapability(...capabilities),
};
}
export const CONTENT_ROUTES = [
contentRoute(
"content.editorial.articles",
"/ase/content/editorial/articles",
[PERMS.NEWS_VIEW],
),
contentRoute(
"content.editorial.article-create",
"/ase/content/editorial/articles/new",
[PERMS.NEWS_EDIT],
),
contentRoute(
"content.editorial.article-detail",
"/ase/content/editorial/articles/:id",
[PERMS.NEWS_VIEW],
),
contentRoute("content.media.photos", "/ase/content/media/photos", [
PERMS.PAGES_VIEW,
]),
contentRoute("content.media.library", "/ase/content/media/library", [
PERMS.PAGES_VIEW,
]),
contentRoute("content.media.banners", "/ase/content/media/banners", [
PERMS.BANNERS_VIEW,
]),
contentRoute("content.media.ads", "/ase/content/media/ads", [
PERMS.PAGES_VIEW,
]),
contentRoute("content.media.ad-create", "/ase/content/media/ads/new", [
PERMS.PAGES_EDIT,
]),
contentRoute("content.media.ad-detail", "/ase/content/media/ads/:id", [
PERMS.PAGES_VIEW,
]),
contentRoute("content.engagement.events", "/ase/content/engagement/events", [
PERMS.EVENTS_VIEW,
]),
contentRoute(
"content.engagement.event-create",
"/ase/content/engagement/events/create",
[PERMS.EVENTS_EDIT],
),
contentRoute(
"content.engagement.event-types",
"/ase/content/engagement/events/types",
[PERMS.EVENTS_EDIT],
),
contentRoute(
"content.engagement.event-detail",
"/ase/content/engagement/events/:id",
[PERMS.EVENTS_EDIT],
),
contentRoute("content.engagement.polls", "/ase/content/engagement/polls", [
PERMS.POLLS_VIEW,
]),
contentRoute(
"content.engagement.poll-create",
"/ase/content/engagement/polls/create",
[PERMS.POLLS_EDIT],
),
contentRoute(
"content.engagement.poll-detail",
"/ase/content/engagement/polls/:id",
[PERMS.POLLS_EDIT],
),
contentRoute("content.help.questions", "/ase/content/help/questions", [
PERMS.PAGES_VIEW,
]),
contentRoute(
"content.help.question-create",
"/ase/content/help/questions/new",
[PERMS.PAGES_EDIT],
),
contentRoute(
"content.help.question-detail",
"/ase/content/help/questions/:id",
[PERMS.PAGES_VIEW],
),
contentRoute("content.editorial.tags", "/ase/content/editorial/tags", [
PERMS.PAGES_VIEW,
]),
contentRoute(
"content.engagement.prefixes",
"/ase/content/engagement/prefixes",
[PERMS.PREFIXES_VIEW],
),
contentRoute(
"content.editorial.writeable-boxes",
"/ase/content/editorial/writeable-boxes",
[PERMS.PAGES_VIEW],
),
contentRoute(
"content.help.email-templates",
"/ase/content/help/email-templates",
[PERMS.PAGES_VIEW],
),
contentRoute("content.brand.theme", "/ase/content/brand/theme", [
PERMS.SETTINGS_VIEW,
]),
contentRoute("content.brand.favicon", "/ase/content/brand/favicon", [
PERMS.SETTINGS_VIEW,
]),
contentRoute("content.localization.overview", "/ase/content/localization", [
PERMS.SETTINGS_VIEW,
]),
contentRoute(
"content.localization.client",
"/ase/content/localization/client",
[PERMS.SETTINGS_VIEW],
),
contentRoute("content.localization.cms", "/ase/content/localization/cms", [
PERMS.SETTINGS_VIEW,
]),
contentRoute(
"content.localization.emulator",
"/ase/content/localization/emulator",
[PERMS.SETTINGS_VIEW],
),
] as const satisfies readonly HousekeepingRouteDefinition[];
const routeGroups = new Map<ContentRouteId, ContentRouteGroup>(
CONTENT_ROUTE_IDS.map((routeId) => [
routeId,
routeId.split(".")[1] as ContentRouteGroup,
]),
);
export function contentRouteGroup(routeId: ContentRouteId): ContentRouteGroup {
const group = routeGroups.get(routeId);
if (!group) throw new Error(`unknown Content route: ${routeId}`);
return group;
}
export function contentRouteById(
routeId: ContentRouteId,
): (typeof CONTENT_ROUTES)[number] {
const route = CONTENT_ROUTES.find((candidate) => candidate.id === routeId);
if (!route) throw new Error(`unknown Content route: ${routeId}`);
return route;
}
src/features/housekeeping/domains/content/search-production.ts
-54
View File
@@ -1,54 +0,0 @@
import "server-only";
import { PERMS } from "@/lib/permission-slugs";
import {
anyCapability,
type HousekeepingCapabilityContext,
} from "../../foundation/contracts";
import { contentQuery } from "./queries/content-queries";
import type { ContentSearchCandidate } from "./search";
type ContentSearchKind = "articles" | "events" | "media" | "help";
const SEARCH_ROUTES = {
articles: [["content.editorial.articles", anyCapability(PERMS.NEWS_VIEW)]],
events: [["content.engagement.events", anyCapability(PERMS.EVENTS_VIEW)]],
media: [
["content.media.photos", anyCapability(PERMS.PAGES_VIEW)],
["content.media.library", anyCapability(PERMS.PAGES_VIEW)],
["content.media.banners", anyCapability(PERMS.BANNERS_VIEW)],
["content.media.ads", anyCapability(PERMS.PAGES_VIEW)],
],
help: [
["content.help.questions", anyCapability(PERMS.PAGES_VIEW)],
["content.help.email-templates", anyCapability(PERMS.PAGES_VIEW)],
],
} as const;
export async function loadContentSearchCandidates(
kind: ContentSearchKind,
context: HousekeepingCapabilityContext,
term: string,
limit: number,
): Promise<readonly ContentSearchCandidate[]> {
const candidates: ContentSearchCandidate[] = [];
for (const [routeId, capability] of SEARCH_ROUTES[kind]) {
const result = await contentQuery.run(context, {
routeId,
list: { search: term, pageSize: limit, offset: 0 },
});
if (!result.ok) continue;
for (const item of result.data.items) {
if (!item.href) continue;
candidates.push({
id: `${routeId}:${item.id}`,
title: item.title,
description: item.description ?? item.status,
href: item.href,
capability,
});
if (candidates.length >= limit) return candidates;
}
}
return candidates;
}
src/features/housekeeping/domains/content/search.ts
-131
View File
@@ -1,131 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import { authorizeHousekeeping } from "../../foundation/authorization";
import { satisfiesCapability } from "../../foundation/capability-context";
import {
anyCapability,
type CapabilityRequirement,
fail,
type HousekeepingCapabilityContext,
type HousekeepingSearchProvider,
ok,
} from "../../foundation/contracts";
import { isSafeHousekeepingHref } from "../../foundation/housekeeping-href";
export const CONTENT_SEARCH_PROVIDER_IDS = [
"content.articles",
"content.events",
"content.media",
"content.help",
] as const;
export interface ContentSearchCandidate {
readonly id: string;
readonly title: string;
readonly description?: string;
readonly href: string;
readonly capability: CapabilityRequirement;
}
type ContentSearchLoader = (
context: HousekeepingCapabilityContext,
term: string,
limit: number,
) => Promise<readonly ContentSearchCandidate[]>;
export interface ContentSearchAdapters {
readonly articles: ContentSearchLoader;
readonly events: ContentSearchLoader;
readonly media: ContentSearchLoader;
readonly help: ContentSearchLoader;
}
function createProvider(
id: (typeof CONTENT_SEARCH_PROVIDER_IDS)[number],
capability: CapabilityRequirement,
load: ContentSearchLoader,
): HousekeepingSearchProvider {
return {
id,
owner: "content",
capability,
async search(context, input) {
const authorization = authorizeHousekeeping(context, capability);
if (!authorization.ok) return authorization;
const limit = Number.isFinite(input.limit)
? Math.min(25, Math.max(1, Math.trunc(input.limit)))
: 25;
const term = input.term.normalize("NFC").trim().slice(0, 128);
try {
const candidates = await load(context, term, limit);
return ok(
candidates
.filter(
(item) =>
isSafeHousekeepingHref(item.href) &&
satisfiesCapability(context, item.capability),
)
.slice(0, limit)
.map((item) => ({
...item,
domain: "content" as const,
type: "entity" as const,
href: item.href as `/ase/${string}`,
})),
authorization.correlationId,
);
} catch {
return fail(
"DEPENDENCY_UNAVAILABLE",
"errors.housekeeping.dependencyUnavailable",
authorization.correlationId,
);
}
},
};
}
export function createContentSearchProviders(
adapters: ContentSearchAdapters,
): readonly HousekeepingSearchProvider[] {
return [
createProvider(
"content.articles",
anyCapability(PERMS.NEWS_VIEW),
adapters.articles,
),
createProvider(
"content.events",
anyCapability(PERMS.EVENTS_VIEW),
adapters.events,
),
createProvider(
"content.media",
anyCapability(PERMS.PAGES_VIEW, PERMS.BANNERS_VIEW),
adapters.media,
),
createProvider(
"content.help",
anyCapability(PERMS.PAGES_VIEW),
adapters.help,
),
];
}
export const CONTENT_SEARCH_PROVIDERS = createContentSearchProviders({
async articles(context, term, limit) {
const { loadContentSearchCandidates } = await import("./search-production");
return loadContentSearchCandidates("articles", context, term, limit);
},
async events(context, term, limit) {
const { loadContentSearchCandidates } = await import("./search-production");
return loadContentSearchCandidates("events", context, term, limit);
},
async media(context, term, limit) {
const { loadContentSearchCandidates } = await import("./search-production");
return loadContentSearchCandidates("media", context, term, limit);
},
async help(context, term, limit) {
const { loadContentSearchCandidates } = await import("./search-production");
return loadContentSearchCandidates("help", context, term, limit);
},
});
src/features/housekeeping/domains/content/services/mutation-runtime-database.test.ts
-197
View File
@@ -1,197 +0,0 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { HousekeepingCapabilityContext } from "../../../foundation/contracts";
import { executeContentDatabaseMutation } from "./mutation-runtime-database";
const sqlMocks = vi.hoisted(() => ({
join: vi.fn((chunks: unknown[], separator: unknown) => ({
chunks,
separator,
})),
raw: vi.fn((statement: string) => statement),
tagged: vi.fn((strings: TemplateStringsArray, ...values: unknown[]) => ({
strings: Array.from(strings),
values,
})),
}));
const database = vi.hoisted(() => {
let selected: Record<string, unknown> = { id: 7, title: "Existing" };
const set = vi.fn((values: Record<string, unknown>) => ({
where: vi.fn(async () => undefined),
values,
}));
const update = vi.fn(() => ({ set }));
const limit = vi.fn(async () => [selected]);
const where = vi.fn(() => ({ limit }));
const from = vi.fn(() => ({ where }));
const select = vi.fn(() => ({ from }));
const execute = vi.fn(async () => undefined);
return {
execute,
set,
update,
select,
selected(value: Record<string, unknown>) {
selected = value;
},
};
});
vi.mock("drizzle-orm", () => ({
eq: vi.fn(),
sql: Object.assign(sqlMocks.tagged, {
join: sqlMocks.join,
raw: sqlMocks.raw,
}),
}));
vi.mock("@/lib/db", () => {
const table = new Proxy({}, { get: (_target, key) => String(key) });
return {
db: {
execute: database.execute,
select: database.select,
update: database.update,
},
EmailTemplates: table,
Taggables: table,
Tags: table,
User: table,
WebsiteAds: table,
WebsiteArticleComments: table,
WebsiteArticleReactions: table,
WebsiteArticles: table,
WebsiteBanner: table,
WebsiteEvent: table,
WebsiteEventPrize: table,
WebsiteEventType: table,
WebsiteEventWinner: table,
WebsiteHelpCenterCategories: table,
WebsitePoll: table,
WebsitePollQuestion: table,
WebsiteWriteableBoxes: table,
};
});
vi.mock("@/lib/services/staff-activity", () => ({
logStaffActivity: vi.fn(async () => undefined),
}));
const capability = {
actor: { id: 42, username: "operator", rank: 7 },
isSuperAdmin: false,
has: () => true,
hasAny: () => true,
hasAll: () => true,
} satisfies HousekeepingCapabilityContext;
const context = {
capability,
correlationId: "database-runtime",
legacy: false,
};
describe("Content database mutation runtime partial updates", () => {
beforeEach(() => {
vi.clearAllMocks();
database.selected({ id: 7, title: "Existing" });
});
it("does not reset omitted banner fields", async () => {
await executeContentDatabaseMutation(
"banner.change",
{ action: "update", id: 7, title: "Renamed" },
context,
undefined,
);
expect(database.set).toHaveBeenCalledWith({ title: "Renamed" });
});
it("does not reset a tag color omitted by the update form", async () => {
await executeContentDatabaseMutation(
"tag.change",
{ action: "update", id: "7", name: "News" },
context,
undefined,
);
const values = database.set.mock.calls[0]?.[0];
expect(values).toMatchObject({ name: "News" });
expect(values).not.toHaveProperty("backgroundColor");
});
it.each([
["help-question.change", { name: "Updated question" }, "name"],
["writeable-box.change", { title: "Updated box" }, "title"],
["email-template.change", { subject: "Updated subject" }, "subject"],
] as const)(
"updates only supplied fields for %s",
async (operation, patch, expectedKey) => {
await executeContentDatabaseMutation(
operation,
{ action: "update", id: "7", ...patch },
context,
undefined,
);
const values = database.set.mock.calls[0]?.[0];
expect(values).toHaveProperty(expectedKey);
for (const destructiveKey of [
"content",
"position",
"isActive",
"body",
"variables",
"imageUrl",
]) {
expect(values).not.toHaveProperty(destructiveKey);
}
},
);
it.each([
["help-question.change", { answer: "Updated answer" }, "content"],
["writeable-box.change", { content: "Updated content" }, "content"],
["email-template.change", { body: "Updated body" }, "body"],
] as const)(
"accepts a non-title partial patch for %s",
async (operation, patch, expectedKey) => {
await executeContentDatabaseMutation(
operation,
{ action: "update", id: "7", ...patch },
context,
undefined,
);
expect(database.set.mock.calls[0]?.[0]).toHaveProperty(expectedKey);
},
);
it("updates only submitted prefix columns and preserves omitted icon, effect, and active", async () => {
const snapshot = await executeContentDatabaseMutation(
"prefix.change",
{ action: "update", id: 7, text: "Renamed" },
context,
undefined,
);
const assignments = sqlMocks.join.mock.calls.at(-1)?.[0] as
| Array<{ strings: string[]; values: unknown[] }>
| undefined;
expect(assignments).toHaveLength(1);
expect(assignments?.[0]?.strings.join(" ")).toContain("text =");
expect(assignments?.[0]?.strings.join(" ")).not.toMatch(
/icon|effect|active/u,
);
expect(snapshot?.after).toEqual({ id: 7, text: "Renamed" });
});
it("submits an explicit false prefix active patch without touching other columns", async () => {
const snapshot = await executeContentDatabaseMutation(
"prefix.change",
{ action: "update", id: 7, active: false },
context,
undefined,
);
const assignments = sqlMocks.join.mock.calls.at(-1)?.[0] as
| Array<{ strings: string[]; values: unknown[] }>
| undefined;
expect(assignments).toHaveLength(1);
expect(assignments?.[0]?.strings.join(" ")).toContain("active =");
expect(assignments?.[0]?.values).toEqual([0]);
expect(snapshot?.after).toEqual({ id: 7, active: 0 });
});
});
src/features/housekeeping/domains/content/services/mutation-runtime-database.ts
-1123
View File
File diff suppressed because it is too large. Load diff
src/features/housekeeping/domains/content/services/mutation-runtime-external.test.ts
-316
View File
@@ -1,316 +0,0 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { HousekeepingCapabilityContext } from "../../../foundation/contracts";
import { executeContentExternalMutation } from "./mutation-runtime-external";
import type { ContentMutationFailure } from "./mutations";
const fsMocks = vi.hoisted(() => ({
mkdir: vi.fn(),
readFile: vi.fn(),
unlink: vi.fn(),
writeFile: vi.fn(),
}));
const dbMocks = vi.hoisted(() => {
const onDuplicateKeyUpdate = vi.fn(async () => undefined);
const values = vi.fn((_value: Record<string, unknown>) => ({
onDuplicateKeyUpdate,
}));
const insert = vi.fn(() => ({ values }));
const where = vi.fn(async () => undefined);
const deleteFn = vi.fn(() => ({ where }));
let selectedPhoto: Record<string, unknown> = {
id: 7,
url: "/photos/7.png",
};
const limit = vi.fn(async () => [selectedPhoto]);
const selectWhere = vi.fn(() => ({ limit }));
const from = vi.fn(() => ({ where: selectWhere }));
const select = vi.fn(() => ({ from }));
return {
deleteFn,
insert,
limit,
onDuplicateKeyUpdate,
select,
selectedPhoto(value: Record<string, unknown>) {
selectedPhoto = value;
},
values,
where,
};
});
const siteMocks = vi.hoisted(() => ({
get: vi.fn(),
reload: vi.fn(),
update: vi.fn(),
}));
const photoMocks = vi.hoisted(() => ({
activity: vi.fn(),
remove: vi.fn(),
}));
vi.mock("node:fs/promises", () => fsMocks);
vi.mock("drizzle-orm", () => ({ eq: vi.fn() }));
vi.mock("@/lib/db", () => ({
CameraWeb: {},
EmulatorSettings: {},
WebsiteSetting: {},
db: {
delete: dbMocks.deleteFn,
insert: dbMocks.insert,
select: dbMocks.select,
},
}));
vi.mock("@/lib/services/rcon", () => ({
rcon: { updateConfig: vi.fn() },
}));
vi.mock("@/lib/services/site-settings", () => ({
siteSettings: siteMocks,
}));
vi.mock("@/lib/services/staff-activity", () => ({
logStaffActivity: photoMocks.activity,
}));
vi.mock("@/lib/admin/photo-files", () => ({
tryRemoveLocalPhotoFile: photoMocks.remove,
}));
const capability = {
actor: { id: 42, username: "operator", rank: 7 },
isSuperAdmin: false,
has: () => true,
hasAny: () => true,
hasAll: () => true,
} satisfies HousekeepingCapabilityContext;
const context = {
capability,
correlationId: "external-runtime",
legacy: false,
};
describe("Content external mutation runtime", () => {
beforeEach(() => {
vi.clearAllMocks();
siteMocks.get.mockResolvedValue(undefined);
photoMocks.activity.mockResolvedValue(undefined);
photoMocks.remove.mockResolvedValue(true);
dbMocks.selectedPhoto({ id: 7, url: "/photos/7.png" });
});
it("preserves media upload bytes, type, size, and canonical public URL", async () => {
const file = new File(
[new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])],
"photo.png",
{ type: "image/png" },
);
const snapshot = await executeContentExternalMutation(
"media.upload",
{ file },
context,
);
expect(snapshot).toMatchObject({
before: null,
after: { size: file.size, type: "image/png" },
output: { url: expect.stringMatching(/^\/api\/media\/.+[.]png$/u) },
});
expect(fsMocks.mkdir).toHaveBeenCalledTimes(1);
expect(fsMocks.writeFile).toHaveBeenCalledWith(
expect.stringContaining("storage"),
expect.any(Buffer),
);
});
it("propagates a real storage failure before optimistic success", async () => {
fsMocks.writeFile.mockRejectedValueOnce(new Error("disk offline"));
const file = new File(
[new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])],
"photo.png",
{ type: "image/png" },
);
await expect(
executeContentExternalMutation("media.upload", { file }, context),
).rejects.toThrow("disk offline");
});
it("maps normalized media traversal to validation instead of dependency failure", async () => {
await expect(
executeContentExternalMutation(
"media.delete",
{ filename: "../private.txt" },
context,
),
).rejects.toMatchObject({
code: "VALIDATION",
messageKey: "errors.housekeeping.validation",
} satisfies Partial<ContentMutationFailure>);
expect(fsMocks.unlink).not.toHaveBeenCalled();
});
it.each(["favicon/brand.ico", "logo/brand.png", "favicon\\brand.ico"])(
"rejects nested media deletion outside the generic upload namespace: %s",
async (filename) => {
await expect(
executeContentExternalMutation("media.delete", { filename }, context),
).rejects.toMatchObject({
code: "VALIDATION",
messageKey: "errors.housekeeping.validation",
} satisfies Partial<ContentMutationFailure>);
expect(fsMocks.unlink).not.toHaveBeenCalled();
},
);
it("rejects declared MIME, filename extension, and actual bytes that disagree", async () => {
const disguisedSvg = new File(
['<svg xmlns="http://www.w3.org/2000/svg"></svg>'],
"photo.svg",
{ type: "image/png" },
);
await expect(
executeContentExternalMutation(
"media.upload",
{ file: disguisedSvg },
context,
),
).rejects.toMatchObject({ code: "VALIDATION" });
expect(fsMocks.writeFile).not.toHaveBeenCalled();
});
it("rejects an oversized logo before reading its bytes", async () => {
const arrayBuffer = vi.fn();
const file = {
name: "logo.png",
type: "image/png",
size: 5 * 1024 * 1024 + 1,
arrayBuffer,
};
await expect(
executeContentExternalMutation("logo.save", { file }, context),
).rejects.toMatchObject({ code: "VALIDATION" });
expect(arrayBuffer).not.toHaveBeenCalled();
expect(fsMocks.writeFile).not.toHaveBeenCalled();
});
it("removes a newly written favicon when the database write fails", async () => {
dbMocks.onDuplicateKeyUpdate.mockRejectedValueOnce(
new Error("database offline"),
);
const file = new File(
[new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])],
"favicon.png",
{ type: "image/png" },
);
await expect(
executeContentExternalMutation("favicon.save", { file }, context),
).rejects.toThrow("database offline");
const writtenPath = fsMocks.writeFile.mock.calls[0]?.[0];
expect(fsMocks.unlink).toHaveBeenCalledWith(writtenPath);
});
it("reports a partial favicon result when database failure compensation also fails", async () => {
dbMocks.onDuplicateKeyUpdate.mockRejectedValueOnce(
new Error("database offline"),
);
fsMocks.unlink.mockRejectedValueOnce(new Error("cleanup failed"));
const file = new File(
[new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])],
"favicon.png",
{ type: "image/png" },
);
await expect(
executeContentExternalMutation("favicon.save", { file }, context),
).rejects.toMatchObject({
name: "ContentCommittedExternalFailure",
snapshot: {
before: { value: null },
after: { value: null },
output: { compensation: "failed" },
},
});
});
it("removes a newly written logo when the database write fails", async () => {
dbMocks.onDuplicateKeyUpdate.mockRejectedValueOnce(
new Error("database offline"),
);
const file = new File(
[new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])],
"logo.png",
{ type: "image/png" },
);
await expect(
executeContentExternalMutation("logo.save", { file }, context),
).rejects.toThrow("database offline");
expect(fsMocks.unlink).toHaveBeenCalledWith(
fsMocks.writeFile.mock.calls[0]?.[0],
);
});
it("does not delete the existing favicon before the database delete commits", async () => {
siteMocks.get.mockResolvedValueOnce("/api/media/favicon/old.png");
dbMocks.where.mockRejectedValueOnce(new Error("database offline"));
await expect(
executeContentExternalMutation("favicon.delete", {}, context),
).rejects.toThrow("database offline");
expect(fsMocks.unlink).not.toHaveBeenCalled();
});
it("renames a custom theme without replacing its saved settings with the active site theme", async () => {
const storedTheme = {
id: "saved-theme",
name: "Stored",
createdAt: 123,
settings: { primary: "#stored", accent: "#saved" },
};
siteMocks.get.mockImplementation(async (key: string) =>
key === "custom_themes" ? JSON.stringify([storedTheme]) : "#active",
);
await executeContentExternalMutation(
"theme.custom-change",
{ action: "rename", id: storedTheme.id, name: "Renamed" },
context,
);
const write = dbMocks.values.mock.calls.find(
([value]) => value.key === "custom_themes",
)?.[0];
const persisted = JSON.parse(String(write?.value));
expect(persisted).toEqual([
{ ...storedTheme, name: "Renamed", settings: storedTheme.settings },
]);
});
it("reports typed partial completion when a committed photo delete cannot purge the file", async () => {
photoMocks.remove.mockResolvedValueOnce(false);
await expect(
executeContentExternalMutation("photo.delete", { id: 7 }, context),
).rejects.toMatchObject({
name: "ContentCommittedExternalFailure",
snapshot: {
before: { id: 7, url: "/photos/7.png" },
after: null,
},
});
expect(dbMocks.where).toHaveBeenCalled();
expect(photoMocks.activity).not.toHaveBeenCalled();
});
it("reports typed partial completion when photo audit fails after the delete", async () => {
photoMocks.activity.mockRejectedValueOnce(new Error("audit offline"));
await expect(
executeContentExternalMutation("photo.delete", { id: 7 }, context),
).rejects.toMatchObject({
name: "ContentCommittedExternalFailure",
snapshot: {
before: { id: 7, url: "/photos/7.png" },
after: null,
},
});
expect(photoMocks.remove).toHaveBeenCalledWith("/photos/7.png");
});
});
src/features/housekeeping/domains/content/services/mutation-runtime-external.ts
-799
View File
@@ -1,799 +0,0 @@
import "server-only";
import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
import path from "node:path";
import { eq } from "drizzle-orm";
import * as JSONC from "jsonc-parser";
import { tryRemoveLocalPhotoFile } from "@/lib/admin/photo-files";
import { getClientTranslationFile } from "@/lib/client-translation-files";
import { CameraWeb, db, EmulatorSettings, WebsiteSetting } from "@/lib/db";
import { patchJson5 } from "@/lib/json5-patch";
import { MEDIA_ROOT, resolveMediaPath } from "@/lib/media-storage";
import { rcon } from "@/lib/services/rcon";
import { siteSettings } from "@/lib/services/site-settings";
import { logStaffActivity } from "@/lib/services/staff-activity";
import { ensureReadableThemeColors } from "@/lib/theme-contrast";
import {
deleteCustomThemeStore,
getCustomTheme,
snapshotCurrentTheme,
upsertCustomTheme,
} from "@/lib/theme-custom-store";
import { FONTS, PRESETS, THEME_COLOR_KEYS } from "@/lib/theme-presets";
import { presetSettings, settingKey } from "@/lib/theme-settings";
import {
type ContentMutationContext,
ContentMutationFailure,
type ContentMutationOperation,
type ContentMutationSnapshot,
} from "./mutations";
import { ContentCommittedExternalFailure } from "./mutations-production";
const MEDIA_TYPES = [
"image/png",
"image/jpeg",
"image/gif",
"image/webp",
] as const;
const FAVICON_TYPES = [
...MEDIA_TYPES,
"image/x-icon",
"image/svg+xml",
] as const;
const IMAGE_EXTENSIONS = {
"image/png": [".png"],
"image/jpeg": [".jpg", ".jpeg"],
"image/gif": [".gif"],
"image/webp": [".webp"],
"image/x-icon": [".ico"],
"image/svg+xml": [".svg"],
} as const;
const CMS_LOCALES = new Set([
"en",
"it",
"nl",
"de",
"fr",
"es",
"pt",
"pl",
"sv",
"tr",
"ro",
"hu",
"cs",
"sk",
"da",
"no",
"el",
"bg",
"hr",
"sr",
"uk",
"ru",
]);
const COLOR_RE = /^[#a-zA-Z0-9(),.\s%-]+$/;
const ADMIN_COLOR_KEYS = [
"admin_canvas",
"admin_surface",
"admin_text",
"admin_text_muted",
"admin_border",
"admin_sidebar_bg",
] as const;
const HEADING_KEYS = [
"size_heading_h1",
"size_heading_h2",
"size_heading_h3",
] as const;
function validation(): ContentMutationFailure {
return new ContentMutationFailure(
"VALIDATION",
"errors.housekeeping.validation",
);
}
function notFound(): ContentMutationFailure {
return new ContentMutationFailure(
"NOT_FOUND",
"errors.housekeeping.notFound",
);
}
function record(value: unknown): Record<string, unknown> {
if (typeof value !== "object" || value === null || Array.isArray(value))
throw validation();
return value as Record<string, unknown>;
}
function text(value: unknown, maximum: number, required = false): string {
const normalized = String(value ?? "")
.normalize("NFC")
.trim()
.slice(0, maximum);
if (required && !normalized) throw validation();
return normalized;
}
function jsonRecord(value: unknown): Record<string, unknown> {
if (typeof value === "string") {
try {
return record(JSON.parse(value));
} catch {
throw validation();
}
}
return record(value);
}
function fileValue(value: unknown): File {
if (
typeof value !== "object" ||
value === null ||
typeof (value as File).arrayBuffer !== "function" ||
typeof (value as File).name !== "string" ||
typeof (value as File).type !== "string" ||
typeof (value as File).size !== "number"
) {
throw validation();
}
return value as File;
}
type SupportedImageType = keyof typeof IMAGE_EXTENSIONS;
function detectedImageType(bytes: Buffer): SupportedImageType | null {
if (
bytes.length >= 8 &&
bytes
.subarray(0, 8)
.equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))
)
return "image/png";
if (
bytes.length >= 3 &&
bytes[0] === 0xff &&
bytes[1] === 0xd8 &&
bytes[2] === 0xff
)
return "image/jpeg";
const header = bytes.subarray(0, 12).toString("ascii");
if (header.startsWith("GIF87a") || header.startsWith("GIF89a"))
return "image/gif";
if (header.startsWith("RIFF") && header.slice(8, 12) === "WEBP")
return "image/webp";
if (
bytes.length >= 4 &&
bytes[0] === 0 &&
bytes[1] === 0 &&
bytes[2] === 1 &&
bytes[3] === 0
)
return "image/x-icon";
const source = bytes
.toString("utf8")
.replace(/^\uFEFF/u, "")
.trimStart();
const svg = source.replace(/^<\?xml[^>]*>\s*/iu, "");
if (/^<svg(?:\s|>)/iu.test(svg)) return "image/svg+xml";
return null;
}
function isSafeSvg(bytes: Buffer): boolean {
const source = bytes.toString("utf8");
return (
!/<(?:script|foreignObject|iframe|object|embed|link|meta)(?:\s|>)/iu.test(
source,
) &&
!/\son[a-z]+\s*=/iu.test(source) &&
!/(?:href|src)\s*=\s*["']?\s*(?:javascript:|data:text\/html)/iu.test(source)
);
}
async function validatedImage(
value: unknown,
maximum: number,
allowedTypes: readonly SupportedImageType[],
): Promise<{
file: File;
bytes: Buffer;
type: SupportedImageType;
extension: string;
}> {
const file = fileValue(value);
if (file.size <= 0 || file.size > maximum) throw validation();
const bytes = Buffer.from(await file.arrayBuffer());
if (bytes.length <= 0 || bytes.length > maximum || bytes.length !== file.size)
throw validation();
const type = detectedImageType(bytes);
if (!type || !allowedTypes.includes(type) || file.type.toLowerCase() !== type)
throw validation();
if (type === "image/svg+xml" && !isSafeSvg(bytes)) throw validation();
const extension = path.extname(file.name).toLowerCase();
if (!(IMAGE_EXTENSIONS[type] as readonly string[]).includes(extension))
throw validation();
return { file, bytes, type, extension: IMAGE_EXTENSIONS[type][0].slice(1) };
}
async function writeWebsiteSetting(
key: string,
value: string,
comment: string,
): Promise<void> {
await db
.insert(WebsiteSetting)
.values({ key, value, comment })
.onDuplicateKeyUpdate({ set: { value } });
}
async function mediaUpload(input: unknown): Promise<ContentMutationSnapshot> {
const { file, bytes, type, extension } = await validatedImage(
record(input).file,
5 * 1024 * 1024,
MEDIA_TYPES,
);
await mkdir(MEDIA_ROOT, { recursive: true });
const name = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${extension}`;
const filePath = resolveMediaPath(name);
if (!filePath.startsWith(MEDIA_ROOT + path.sep)) throw validation();
await writeFile(filePath, bytes);
return {
before: null,
after: { name, size: file.size, type },
output: { name, url: `/api/media/${name}` },
};
}
async function mediaDelete(input: unknown): Promise<ContentMutationSnapshot> {
const name = text(record(input).filename ?? record(input).name, 255, true);
if (name.includes("/") || name.includes("\\")) throw validation();
let filePath: string;
try {
filePath = resolveMediaPath(name);
} catch {
throw validation();
}
if (!filePath.startsWith(MEDIA_ROOT + path.sep)) throw validation();
try {
await unlink(filePath);
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
}
return { before: { name }, after: null };
}
async function photoDelete(
input: unknown,
context: ContentMutationContext,
): Promise<ContentMutationSnapshot> {
const id = Number(record(input).id);
if (!Number.isSafeInteger(id) || id <= 0) throw validation();
const [row] = await db
.select({ id: CameraWeb.id, url: CameraWeb.url })
.from(CameraWeb)
.where(eq(CameraWeb.id, id))
.limit(1);
if (!row) throw notFound();
await db.delete(CameraWeb).where(eq(CameraWeb.id, id));
const snapshot: ContentMutationSnapshot = {
before: { id, url: row.url },
after: null,
};
try {
const removed = await tryRemoveLocalPhotoFile(row.url);
if (!removed) throw new Error("Photo file purge failed");
await logStaffActivity({
staffId: context.capability.actor.id,
action: "photo_delete",
description: `Deleted camera photo #${id}`,
targetType: "camera_web",
targetId: id,
});
} catch {
throw new ContentCommittedExternalFailure(snapshot);
}
return snapshot;
}
async function themeUpdate(
input: unknown,
context: ContentMutationContext,
): Promise<ContentMutationSnapshot> {
const data = record(input);
const source = jsonRecord(data.values ?? data);
const changed: string[] = [];
await db.transaction(async (transaction) => {
for (const mode of ["light", "dark"] as const) {
const bag: Record<string, string> = {};
for (const key of THEME_COLOR_KEYS) {
const databaseKey = settingKey(key, mode);
const raw = text(source[databaseKey], 255);
if (raw && COLOR_RE.test(raw)) bag[key] = raw;
}
for (const [key, value] of Object.entries(
ensureReadableThemeColors(bag),
)) {
const databaseKey = settingKey(
key as (typeof THEME_COLOR_KEYS)[number],
mode,
);
await transaction
.insert(WebsiteSetting)
.values({ key: databaseKey, value, comment: "Theme (housekeeping)" })
.onDuplicateKeyUpdate({ set: { value } });
changed.push(databaseKey);
}
}
const adminBag: Record<string, string> = {};
for (const key of ADMIN_COLOR_KEYS) {
const raw = text(source[key], 255);
if (raw && COLOR_RE.test(raw)) adminBag[key] = raw;
}
for (const [key, value] of Object.entries(
ensureReadableThemeColors(adminBag),
)) {
await transaction
.insert(WebsiteSetting)
.values({ key, value, comment: "Theme (housekeeping)" })
.onDuplicateKeyUpdate({ set: { value } });
changed.push(key);
}
const radius = text(source.border_radius, 3);
if (/^\d{1,3}$/u.test(radius)) {
await transaction
.insert(WebsiteSetting)
.values({
key: "border_radius",
value: radius,
comment: "Theme (housekeeping)",
})
.onDuplicateKeyUpdate({ set: { value: radius } });
changed.push("border_radius");
}
const font = text(source.font_family, 100);
if (font in FONTS) {
await transaction
.insert(WebsiteSetting)
.values({
key: "font_family",
value: font,
comment: "Theme (housekeeping)",
})
.onDuplicateKeyUpdate({ set: { value: font } });
changed.push("font_family");
}
for (const key of HEADING_KEYS) {
const value = text(source[key], 3);
if (!/^\d{1,3}$/u.test(value)) continue;
await transaction
.insert(WebsiteSetting)
.values({ key, value, comment: "Theme (housekeeping)" })
.onDuplicateKeyUpdate({ set: { value } });
changed.push(key);
}
if (Object.hasOwn(source, "custom_css")) {
const value = String(source.custom_css ?? "")
.normalize("NFC")
.slice(0, 20_000);
await transaction
.insert(WebsiteSetting)
.values({ key: "custom_css", value, comment: "Theme (housekeeping)" })
.onDuplicateKeyUpdate({ set: { value } });
changed.push("custom_css");
}
});
const snapshot: ContentMutationSnapshot = {
before: null,
after: { changedKeys: changed.sort() },
};
try {
siteSettings.reload();
await logStaffActivity({
staffId: context.capability.actor.id,
action: "theme_update",
description: "Updated theme settings",
});
} catch {
throw new ContentCommittedExternalFailure(snapshot);
}
return snapshot;
}
async function themeApplyPreset(
input: unknown,
context: ContentMutationContext,
): Promise<ContentMutationSnapshot> {
const name = text(record(input).preset, 100, true);
const preset = PRESETS[name];
if (!preset) throw validation();
await db.transaction(async (transaction) => {
for (const [key, value] of presetSettings(preset)) {
await transaction
.insert(WebsiteSetting)
.values({ key, value, comment: "Theme (housekeeping)" })
.onDuplicateKeyUpdate({ set: { value } });
}
await transaction
.insert(WebsiteSetting)
.values({
key: "theme_preset",
value: name,
comment: "Theme (housekeeping)",
})
.onDuplicateKeyUpdate({ set: { value: name } });
});
const snapshot: ContentMutationSnapshot = {
before: null,
after: { preset: name },
output: { name },
};
try {
siteSettings.reload();
await logStaffActivity({
staffId: context.capability.actor.id,
action: "theme_preset",
description: `Applied theme preset ${name}`,
});
} catch {
throw new ContentCommittedExternalFailure(snapshot);
}
return snapshot;
}
async function themeCustomChange(
input: unknown,
context: ContentMutationContext,
): Promise<ContentMutationSnapshot> {
const data = record(input);
const action = text(data.action, 16, true);
const id = text(data.id, 100);
if (action === "delete") {
if (!id) throw validation();
const existing = await getCustomTheme(id);
if (!existing) throw notFound();
await deleteCustomThemeStore(id);
return { before: { id, name: existing.name }, after: null };
}
if (action !== "create" && action !== "update" && action !== "rename")
throw validation();
const name = text(data.name, 100, true);
let settings: Record<string, string>;
if (action === "rename") {
if (!id) throw validation();
const existing = await getCustomTheme(id);
if (!existing) throw notFound();
settings = existing.settings;
} else {
settings = data.values
? Object.fromEntries(
Object.entries(jsonRecord(data.values)).map(([key, value]) => [
key,
String(value),
]),
)
: await snapshotCurrentTheme();
}
const theme = await upsertCustomTheme(name, settings, id || undefined);
await logStaffActivity({
staffId: context.capability.actor.id,
action: "theme_preset",
description: `Saved custom theme ${theme.name}`,
});
return {
before: id ? { id } : null,
after: { id: theme.id, name: theme.name },
output: { id: theme.id, name: theme.name },
};
}
async function themeApplyCustom(
input: unknown,
context: ContentMutationContext,
): Promise<ContentMutationSnapshot> {
const id = text(record(input).id, 100, true);
const theme = await getCustomTheme(id);
if (!theme) throw notFound();
await db.transaction(async (transaction) => {
for (const [key, value] of Object.entries(theme.settings)) {
if (!value) continue;
await transaction
.insert(WebsiteSetting)
.values({ key, value, comment: "Theme (housekeeping)" })
.onDuplicateKeyUpdate({ set: { value } });
}
await transaction
.insert(WebsiteSetting)
.values({
key: "theme_preset",
value: theme.name,
comment: "Theme (housekeeping)",
})
.onDuplicateKeyUpdate({ set: { value: theme.name } });
});
const snapshot: ContentMutationSnapshot = {
before: null,
after: { id, name: theme.name },
output: { name: theme.name },
};
try {
siteSettings.reload();
await logStaffActivity({
staffId: context.capability.actor.id,
action: "theme_preset",
description: `Applied custom theme ${theme.name}`,
});
} catch {
throw new ContentCommittedExternalFailure(snapshot);
}
return snapshot;
}
async function removeStoredAsset(
url: string | null | undefined,
directory: string,
prefix: string,
): Promise<void> {
if (!url?.startsWith(prefix)) return;
const name = url.slice(prefix.length);
if (!name || name.includes("..") || name.includes("/") || name.includes("\\"))
return;
const filePath = path.resolve(directory, name);
if (!filePath.startsWith(directory + path.sep)) return;
try {
await unlink(filePath);
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
}
}
async function faviconSave(input: unknown): Promise<ContentMutationSnapshot> {
const { bytes, extension } = await validatedImage(
record(input).file,
2 * 1024 * 1024,
FAVICON_TYPES,
);
const directory = resolveMediaPath("favicon");
const filename = `favicon-${Date.now()}.${extension}`;
const filePath = path.resolve(directory, filename);
if (!filePath.startsWith(directory + path.sep)) throw validation();
const oldUrl = await siteSettings.get("cms_favicon");
await mkdir(directory, { recursive: true });
await writeFile(filePath, bytes);
const url = `/api/media/favicon/${filename}`;
const snapshot: ContentMutationSnapshot = {
before: { value: oldUrl ?? null },
after: { value: url },
output: { url },
};
try {
await writeWebsiteSetting("cms_favicon", url, "Favicon URL");
} catch (error) {
try {
await unlink(filePath);
} catch {
throw new ContentCommittedExternalFailure({
before: { value: oldUrl ?? null },
after: { value: oldUrl ?? null },
output: { compensation: "failed" },
});
}
throw error;
}
try {
await removeStoredAsset(oldUrl, directory, "/api/media/favicon/");
siteSettings.reload();
} catch {
throw new ContentCommittedExternalFailure(snapshot);
}
return snapshot;
}
async function faviconDelete(): Promise<ContentMutationSnapshot> {
const oldUrl = await siteSettings.get("cms_favicon");
await db.delete(WebsiteSetting).where(eq(WebsiteSetting.key, "cms_favicon"));
const snapshot: ContentMutationSnapshot = {
before: { value: oldUrl ?? null },
after: null,
};
try {
await removeStoredAsset(
oldUrl,
resolveMediaPath("favicon"),
"/api/media/favicon/",
);
siteSettings.reload();
} catch {
throw new ContentCommittedExternalFailure(snapshot);
}
return snapshot;
}
async function logoSave(input: unknown): Promise<ContentMutationSnapshot> {
const { bytes, extension } = await validatedImage(
record(input).file,
5 * 1024 * 1024,
MEDIA_TYPES,
);
const directory = resolveMediaPath("logo");
const filename =
"logo-" +
Date.now() +
"-" +
Math.random().toString(36).slice(2, 8) +
"." +
extension;
const filePath = path.resolve(directory, filename);
if (!filePath.startsWith(directory + path.sep)) throw validation();
const oldUrl = await siteSettings.get("cms_logo");
await mkdir(directory, { recursive: true });
await writeFile(filePath, bytes);
const url = `/api/media/logo/${filename}`;
const snapshot: ContentMutationSnapshot = {
before: { value: oldUrl ?? null },
after: { value: url },
output: { url },
};
try {
await writeWebsiteSetting("cms_logo", url, "Logo (generator)");
} catch (error) {
try {
await unlink(filePath);
} catch {
throw new ContentCommittedExternalFailure({
before: { value: oldUrl ?? null },
after: { value: oldUrl ?? null },
output: { compensation: "failed" },
});
}
throw error;
}
try {
await removeStoredAsset(oldUrl, directory, "/api/media/logo/");
siteSettings.reload();
} catch {
throw new ContentCommittedExternalFailure(snapshot);
}
return snapshot;
}
async function cmsTranslationSave(
input: unknown,
): Promise<ContentMutationSnapshot> {
const data = record(input);
const locale = text(data.locale, 16, true);
if (!CMS_LOCALES.has(locale)) throw validation();
const translations = jsonRecord(data.data);
const filePath = path.join(
process.cwd(),
"src",
"messages",
`${locale}.json`,
);
await writeFile(filePath, JSON.stringify(translations, null, 2), "utf-8");
return {
before: null,
after: { locale, keyCount: Object.keys(translations).length },
};
}
async function clientTranslationSave(
input: unknown,
): Promise<ContentMutationSnapshot> {
const data = record(input);
const fileId = text(data.fileId, 100, true);
const translations = Object.fromEntries(
Object.entries(jsonRecord(data.data)).map(([key, value]) => [
key,
String(value),
]),
);
const file = getClientTranslationFile(fileId);
if (!file || file.readOnly) throw validation();
const absolutePath = path.join(process.cwd(), file.relPath);
const raw = await readFile(absolutePath, "utf-8");
if (file.format === "json") {
await writeFile(
absolutePath,
JSON.stringify(translations, null, 4),
"utf-8",
);
return {
before: null,
after: { fileId, keyCount: Object.keys(translations).length },
output: { commentsLost: false, unpatchedKeys: [] },
};
}
const original: Record<string, string> = {};
const parsed = JSONC.parse(raw);
if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
for (const [key, value] of Object.entries(parsed))
original[key] = value == null ? "" : String(value);
}
const patched = patchJson5(raw, original, translations);
if (patched.unpatchedKeys.length === 0) {
await writeFile(absolutePath, patched.content, "utf-8");
} else {
await writeFile(
absolutePath,
JSON.stringify(translations, null, 4),
"utf-8",
);
}
return {
before: null,
after: { fileId, keyCount: Object.keys(translations).length },
output: {
commentsLost: patched.unpatchedKeys.length > 0,
unpatchedKeys: patched.unpatchedKeys,
},
};
}
async function emulatorTranslationSave(
input: unknown,
context: ContentMutationContext,
): Promise<ContentMutationSnapshot> {
const data = record(input);
const source = data.settings
? jsonRecord(data.settings)
: data.key
? { [text(data.key, 100, true)]: text(data.value, 512) }
: jsonRecord(data);
const entries = Object.entries(source).map(
([key, value]) => [text(key, 100, true), text(value, 512)] as const,
);
await db.transaction(async (transaction) => {
for (const [key, value] of entries) {
await transaction
.insert(EmulatorSettings)
.values({ key, value })
.onDuplicateKeyUpdate({ set: { value } });
}
});
const snapshot: ContentMutationSnapshot = {
before: null,
after: { keys: entries.map(([key]) => key).sort() },
};
try {
const delivered = await rcon.updateConfig();
if (!context.legacy && !delivered)
throw new Error("emulator configuration sync failed");
} catch {
throw new ContentCommittedExternalFailure(snapshot);
}
return snapshot;
}
const EXTERNAL_HANDLERS: Partial<
Record<
ContentMutationOperation,
(
input: unknown,
context: ContentMutationContext,
) => Promise<ContentMutationSnapshot>
>
> = {
"media.upload": (input) => mediaUpload(input),
"media.delete": (input) => mediaDelete(input),
"photo.delete": photoDelete,
"theme.update": themeUpdate,
"theme.apply-preset": themeApplyPreset,
"theme.custom-change": themeCustomChange,
"theme.apply-custom": themeApplyCustom,
"favicon.save": (input) => faviconSave(input),
"favicon.delete": () => faviconDelete(),
"logo.save": (input) => logoSave(input),
"translation.cms.save": (input) => cmsTranslationSave(input),
"translation.client.save": (input) => clientTranslationSave(input),
"translation.emulator.save": emulatorTranslationSave,
};
export async function executeContentExternalMutation(
operation: ContentMutationOperation,
input: unknown,
context: ContentMutationContext,
): Promise<ContentMutationSnapshot | null> {
const handler = EXTERNAL_HANDLERS[operation];
return handler ? handler(input, context) : null;
}
src/features/housekeeping/domains/content/services/mutations-production.test.ts
-232
View File
@@ -1,232 +0,0 @@
import { describe, expect, it, vi } from "vitest";
import type { AuditEntry } from "@/lib/services/audit";
import type { HousekeepingCapabilityContext } from "../../../foundation/contracts";
import { CONTENT_MUTATION_OPERATIONS } from "./mutations";
import {
CONTENT_DATABASE_OPERATIONS,
CONTENT_EXTERNAL_OPERATIONS,
CONTENT_MIXED_OPERATIONS,
ContentCommittedExternalFailure,
createContentProductionMutationAdapter,
} from "./mutations-production";
const capability: HousekeepingCapabilityContext = {
actor: { id: 42, username: "operator", rank: 7 },
isSuperAdmin: false,
has: () => true,
hasAny: () => true,
hasAll: () => true,
};
const mutationContext = {
capability,
correlationId: "production-matrix",
legacy: false,
};
function dependencies() {
const transactionToken = { transaction: true };
const writeAudit = vi.fn(
async (_entry: AuditEntry, _transaction?: unknown) => undefined,
);
const executeOperation = vi.fn(async (operation: string) => ({
before: { operation, state: "before" },
after: { operation, state: "after" },
output: { id: "18446744073709551615" },
}));
const transaction = vi.fn(async (run) => run(transactionToken));
return {
transactionToken,
writeAudit,
executeOperation,
transaction,
adapter: createContentProductionMutationAdapter({
transaction,
writeAudit,
executeOperation,
}),
};
}
describe("Content production mutation adapter", () => {
it("classifies every operation exactly once", () => {
const classified = [
...CONTENT_DATABASE_OPERATIONS,
...CONTENT_EXTERNAL_OPERATIONS,
...CONTENT_MIXED_OPERATIONS,
];
expect([...classified].sort()).toEqual(
[...CONTENT_MUTATION_OPERATIONS].sort(),
);
expect(new Set(classified).size).toBe(classified.length);
});
it("executes every production operation and serializes identifiers", async () => {
const deps = dependencies();
for (const operation of CONTENT_MUTATION_OPERATIONS) {
const snapshot = await deps.adapter.execute(
operation,
{ action: "update" },
mutationContext,
);
expect(snapshot.output?.id, operation).toBe("18446744073709551615");
}
expect(deps.executeOperation).toHaveBeenCalledTimes(
CONTENT_MUTATION_OPERATIONS.length,
);
});
it("commits database mutation and canonical success audit in one transaction", async () => {
const deps = dependencies();
await deps.adapter.execute(
"article.change",
{ action: "update", id: "18446744073709551615" },
mutationContext,
);
expect(deps.transaction).toHaveBeenCalledTimes(1);
expect(deps.executeOperation).toHaveBeenCalledWith(
"article.change",
expect.anything(),
mutationContext,
deps.transactionToken,
);
expect(deps.writeAudit).toHaveBeenCalledWith(
expect.objectContaining({
action: "content.article.change",
outcome: "success",
domain: "content",
correlationId: "production-matrix",
}),
deps.transactionToken,
);
});
it("persists correlated intent and truthful outcome around external storage writes", async () => {
const deps = dependencies();
await deps.adapter.execute(
"translation.cms.save",
{ locale: "en", data: { welcome: "Hello" } },
mutationContext,
);
expect(deps.transaction).not.toHaveBeenCalled();
expect(deps.writeAudit.mock.calls.map(([entry]) => entry.outcome)).toEqual([
"intent",
"success",
]);
expect(
deps.writeAudit.mock.calls.every(
([entry]) => entry.correlationId === "production-matrix",
),
).toBe(true);
expect(JSON.stringify(deps.writeAudit.mock.calls)).not.toContain("Hello");
});
it.each(["favicon.save", "logo.save"] as const)(
"routes %s through correlated intent and outcome audit",
async (operation) => {
const deps = dependencies();
await deps.adapter.execute(
operation,
{ file: { name: "brand.png" } },
mutationContext,
);
expect(deps.executeOperation).toHaveBeenCalledWith(
operation,
expect.anything(),
mutationContext,
);
expect(deps.writeAudit.mock.calls.map(([entry]) => entry)).toEqual([
expect.objectContaining({
action: `content.${operation}`,
outcome: "intent",
correlationId: "production-matrix",
}),
expect.objectContaining({
action: `content.${operation}`,
outcome: "success",
correlationId: "production-matrix",
}),
]);
},
);
it.each(["favicon.save", "logo.save"] as const)(
"returns a typed partial for %s when its outcome audit is unavailable",
async (operation) => {
const deps = dependencies();
deps.writeAudit
.mockResolvedValueOnce(undefined)
.mockRejectedValueOnce(new Error("audit offline"));
const snapshot = await deps.adapter.execute(
operation,
{ file: { name: "brand.png" } },
mutationContext,
);
expect(snapshot.completion).toEqual({
status: "partial",
external: "completed",
audit: "unavailable",
});
expect(deps.writeAudit.mock.calls).toEqual([
[
expect.objectContaining({
action: `content.${operation}`,
outcome: "intent",
}),
],
[
expect.objectContaining({
action: `content.${operation}`,
outcome: "success",
}),
],
]);
},
);
it("returns typed partial when database committed but the external effect failed", async () => {
const deps = dependencies();
deps.executeOperation.mockRejectedValueOnce(
new ContentCommittedExternalFailure({
before: { value: "/old.ico" },
after: { value: "/new.ico" },
}),
);
const snapshot = await deps.adapter.execute(
"favicon.save",
{ file: { name: "favicon.ico" } },
mutationContext,
);
expect(snapshot).toMatchObject({
before: { value: "/old.ico" },
after: { value: "/new.ico" },
completion: {
status: "partial",
external: "failed",
audit: "persisted",
},
});
expect(deps.writeAudit.mock.calls.at(-1)?.[0]).toMatchObject({
outcome: "partial",
});
});
it("records failure without optimistic after-state when external storage fails before commit", async () => {
const deps = dependencies();
deps.executeOperation.mockRejectedValueOnce(new Error("disk offline"));
await expect(
deps.adapter.execute(
"media.upload",
{ file: { name: "image.png" } },
mutationContext,
),
).rejects.toThrow("disk offline");
expect(deps.writeAudit.mock.calls.at(-1)?.[0]).toMatchObject({
outcome: "failure",
before: undefined,
after: undefined,
});
});
});
src/features/housekeeping/domains/content/services/mutations-production.ts
-214
View File
@@ -1,214 +0,0 @@
import type { AuditEntry } from "@/lib/services/audit";
import type {
ContentMutationAdapter,
ContentMutationContext,
ContentMutationOperation,
ContentMutationSnapshot,
} from "./mutations";
export const CONTENT_DATABASE_OPERATIONS = [
"article.change",
"ad.change",
"banner.change",
"event-type.change",
"event.change",
"event-prize.change",
"event-winner.add",
"poll.change",
"poll-question.change",
"tag.change",
"prefix.change",
"prefix-blacklist.change",
"prefix-settings.update",
"help-question.change",
"writeable-box.change",
"email-template.change",
] as const satisfies readonly ContentMutationOperation[];
export const CONTENT_EXTERNAL_OPERATIONS = [
"media.upload",
"media.delete",
"translation.cms.save",
"translation.client.save",
] as const satisfies readonly ContentMutationOperation[];
export const CONTENT_MIXED_OPERATIONS = [
"photo.delete",
"theme.update",
"theme.apply-preset",
"theme.custom-change",
"theme.apply-custom",
"favicon.save",
"favicon.delete",
"logo.save",
"translation.emulator.save",
] as const satisfies readonly ContentMutationOperation[];
type TransactionToken = unknown;
export interface ContentProductionMutationDependencies {
transaction<T>(
run: (transaction: TransactionToken) => Promise<T>,
): Promise<T>;
writeAudit(entry: AuditEntry, transaction?: TransactionToken): Promise<void>;
executeOperation(
operation: ContentMutationOperation,
input: unknown,
context: ContentMutationContext,
transaction?: TransactionToken,
): Promise<ContentMutationSnapshot>;
}
export class ContentCommittedExternalFailure extends Error {
constructor(readonly snapshot: ContentMutationSnapshot) {
super("Content database change committed but external effect failed");
this.name = "ContentCommittedExternalFailure";
}
}
function auditEntry(
operation: ContentMutationOperation,
context: ContentMutationContext,
outcome: NonNullable<AuditEntry["outcome"]>,
snapshot?: ContentMutationSnapshot,
): AuditEntry {
return {
userId: context.capability.actor.id,
action: `content.${operation}`,
target: "Content",
correlationId: context.correlationId,
domain: "content",
outcome,
before:
snapshot?.before === null || snapshot?.before === undefined
? undefined
: { ...snapshot.before },
after:
snapshot?.after === null || snapshot?.after === undefined
? undefined
: { ...snapshot.after },
};
}
function includesOperation(
operations: readonly ContentMutationOperation[],
operation: ContentMutationOperation,
): boolean {
return operations.includes(operation);
}
async function writeOutcomeOrMarkUnavailable(
dependencies: ContentProductionMutationDependencies,
operation: ContentMutationOperation,
context: ContentMutationContext,
snapshot: ContentMutationSnapshot,
outcome: "success" | "partial",
): Promise<ContentMutationSnapshot> {
try {
await dependencies.writeAudit(
auditEntry(operation, context, outcome, snapshot),
);
return snapshot;
} catch {
const completion = {
status: "partial" as const,
external:
outcome === "partial" ? ("failed" as const) : ("completed" as const),
audit: "unavailable" as const,
};
return { ...snapshot, completion };
}
}
export function createContentProductionMutationAdapter(
dependencies: ContentProductionMutationDependencies,
): ContentMutationAdapter {
return {
async execute(operation, input, context) {
if (includesOperation(CONTENT_DATABASE_OPERATIONS, operation)) {
return dependencies.transaction(async (transaction) => {
const snapshot = await dependencies.executeOperation(
operation,
input,
context,
transaction,
);
await dependencies.writeAudit(
auditEntry(operation, context, "success", snapshot),
transaction,
);
return snapshot;
});
}
await dependencies.writeAudit(auditEntry(operation, context, "intent"));
try {
const snapshot = await dependencies.executeOperation(
operation,
input,
context,
);
return writeOutcomeOrMarkUnavailable(
dependencies,
operation,
context,
snapshot,
"success",
);
} catch (error) {
if (
includesOperation(CONTENT_MIXED_OPERATIONS, operation) &&
error instanceof ContentCommittedExternalFailure
) {
const snapshot: ContentMutationSnapshot = {
...error.snapshot,
completion: {
status: "partial",
external: "failed",
audit: "persisted",
},
};
return writeOutcomeOrMarkUnavailable(
dependencies,
operation,
context,
snapshot,
"partial",
);
}
try {
await dependencies.writeAudit(
auditEntry(operation, context, "failure"),
);
} catch {
// Preserve the original dependency failure; the missing outcome is observable
// through the durable correlated intent.
}
throw error;
}
},
};
}
export const contentProductionMutationAdapter =
createContentProductionMutationAdapter({
async transaction(run) {
const { db } = await import("@/lib/db");
return db.transaction((transaction) => run(transaction));
},
async writeAudit(entry, transaction) {
const { logAudit } = await import("@/lib/services/audit");
await logAudit(entry, transaction as never);
},
async executeOperation(operation, input, context, transaction) {
const { executeContentMutationOperation } = await import(
"./mutations-runtime"
);
return executeContentMutationOperation(
operation,
input,
context,
transaction,
);
},
});
src/features/housekeeping/domains/content/services/mutations-runtime.ts
-35
View File
@@ -1,35 +0,0 @@
import "server-only";
import { executeContentDatabaseMutation } from "./mutation-runtime-database";
import { executeContentExternalMutation } from "./mutation-runtime-external";
import type {
ContentMutationContext,
ContentMutationOperation,
ContentMutationSnapshot,
} from "./mutations";
import { ContentMutationFailure } from "./mutations";
export async function executeContentMutationOperation(
operation: ContentMutationOperation,
input: unknown,
context: ContentMutationContext,
transaction?: unknown,
): Promise<ContentMutationSnapshot> {
const databaseResult = await executeContentDatabaseMutation(
operation,
input,
context,
transaction,
);
if (databaseResult) return databaseResult;
const externalResult = await executeContentExternalMutation(
operation,
input,
context,
);
if (externalResult) return externalResult;
throw new ContentMutationFailure(
"VALIDATION",
"errors.housekeeping.validation",
);
}
src/features/housekeeping/domains/content/services/mutations.test.ts
-106
View File
@@ -1,106 +0,0 @@
import { describe, expect, it, vi } from "vitest";
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingCapabilityContext } from "../../../foundation/contracts";
import {
CONTENT_MUTATION_OPERATIONS,
createContentMutationInvocation,
createContentMutationService,
} from "./mutations";
function context(
granted: readonly string[],
actorId = 42,
): HousekeepingCapabilityContext {
const permissions = new Set(granted);
return {
actor: { id: actorId, username: "operator", rank: 7 },
isSuperAdmin: false,
has: (slug) => permissions.has(slug),
hasAny: (...slugs) => slugs.some((slug) => permissions.has(slug)),
hasAll: (...slugs) => slugs.every((slug) => permissions.has(slug)),
};
}
describe("Content mutation service authority", () => {
it("rehydrates server authority and rejects forged actor identity", async () => {
const adapter = { execute: vi.fn() };
const service = createContentMutationService(adapter, async () =>
context([PERMS.NEWS_EDIT], 42),
);
const result = await service.execute(
{ correlationId: "forged", expectedActorId: 7 },
"article.change",
{ action: "create", title: "Forged" },
);
expect(result).toMatchObject({
ok: false,
error: { code: "FORBIDDEN" },
});
expect(adapter.execute).not.toHaveBeenCalled();
});
it("requires the exact operation ACL even after dispatcher authorization", async () => {
const adapter = { execute: vi.fn() };
const service = createContentMutationService(adapter, async () =>
context([PERMS.NEWS_EDIT]),
);
const result = await service.execute(
{ correlationId: "brand", expectedActorId: 42 },
"theme.update",
{},
);
expect(result).toMatchObject({
ok: false,
error: { code: "FORBIDDEN" },
});
expect(adapter.execute).not.toHaveBeenCalled();
});
it("executes every declared operation through the real service boundary", async () => {
const execute = vi.fn(async (_operation, _input, mutationContext) => ({
before: null,
after: { actorId: mutationContext.capability.actor.id },
}));
const service = createContentMutationService({ execute }, async () =>
context(Object.values(PERMS)),
);
const invocation = createContentMutationInvocation(
{ id: 42 },
"operation-matrix",
);
for (const operation of CONTENT_MUTATION_OPERATIONS) {
const result = await service.execute(invocation, operation, {});
expect(result.ok, operation).toBe(true);
}
expect(execute).toHaveBeenCalledTimes(CONTENT_MUTATION_OPERATIONS.length);
});
it("maps adapter failures without exposing storage or template payloads", async () => {
const service = createContentMutationService(
{
execute: async () => {
throw new Error("C:\\private\\template.json: secret body");
},
},
async () => context([PERMS.SETTINGS_EDIT]),
);
const result = await service.execute(
{ correlationId: "redacted", expectedActorId: 42 },
"translation.cms.save",
{ data: { secret: "body" } },
);
expect(result).toMatchObject({
ok: false,
error: {
code: "DEPENDENCY_UNAVAILABLE",
messageKey: "errors.housekeeping.dependencyUnavailable",
},
});
expect(JSON.stringify(result)).not.toContain("secret body");
});
});
src/features/housekeeping/domains/content/services/mutations.ts
-206
View File
@@ -1,206 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import { satisfiesCapability } from "../../../foundation/capability-context";
import {
anyCapability,
fail,
type HousekeepingCapabilityContext,
type HousekeepingErrorCode,
type HousekeepingPartialCompletion,
type HousekeepingResult,
ok,
} from "../../../foundation/contracts";
export const CONTENT_MUTATION_OPERATIONS = [
"article.change",
"ad.change",
"banner.change",
"event-type.change",
"event.change",
"event-prize.change",
"event-winner.add",
"poll.change",
"poll-question.change",
"photo.delete",
"media.upload",
"media.delete",
"tag.change",
"prefix.change",
"prefix-blacklist.change",
"prefix-settings.update",
"help-question.change",
"writeable-box.change",
"email-template.change",
"theme.update",
"theme.apply-preset",
"theme.custom-change",
"theme.apply-custom",
"favicon.save",
"favicon.delete",
"logo.save",
"translation.cms.save",
"translation.client.save",
"translation.emulator.save",
] as const;
export type ContentMutationOperation =
(typeof CONTENT_MUTATION_OPERATIONS)[number];
export interface ContentMutationSnapshot {
readonly before: Readonly<Record<string, unknown>> | null;
readonly after: Readonly<Record<string, unknown>> | null;
readonly output?: Readonly<Record<string, unknown>>;
readonly completion?: HousekeepingPartialCompletion;
}
export interface ContentMutationInvocation {
readonly correlationId: string;
readonly expectedActorId: number;
readonly legacy?: boolean;
}
export interface ContentMutationContext {
readonly capability: HousekeepingCapabilityContext;
readonly correlationId: string;
readonly legacy: boolean;
}
export interface ContentMutationAdapter {
execute(
operation: ContentMutationOperation,
input: unknown,
context: ContentMutationContext,
): Promise<ContentMutationSnapshot>;
}
export interface ContentMutationService {
execute(
invocation: ContentMutationInvocation,
operation: ContentMutationOperation,
input: unknown,
): Promise<HousekeepingResult<ContentMutationSnapshot>>;
}
export class ContentMutationFailure extends Error {
constructor(
readonly code: HousekeepingErrorCode,
readonly messageKey: string,
readonly fieldErrors?: Readonly<Record<string, readonly string[]>>,
) {
super(messageKey);
this.name = "ContentMutationFailure";
}
}
const OPERATION_PERMISSION = Object.freeze({
"article.change": PERMS.NEWS_EDIT,
"ad.change": PERMS.PAGES_EDIT,
"banner.change": PERMS.BANNERS_EDIT,
"event-type.change": PERMS.EVENTS_EDIT,
"event.change": PERMS.EVENTS_EDIT,
"event-prize.change": PERMS.EVENTS_EDIT,
"event-winner.add": PERMS.EVENTS_EDIT,
"poll.change": PERMS.POLLS_EDIT,
"poll-question.change": PERMS.POLLS_EDIT,
"photo.delete": PERMS.PAGES_EDIT,
"media.upload": PERMS.PAGES_EDIT,
"media.delete": PERMS.PAGES_EDIT,
"tag.change": PERMS.PAGES_EDIT,
"prefix.change": PERMS.PREFIXES_EDIT,
"prefix-blacklist.change": PERMS.PREFIXES_EDIT,
"prefix-settings.update": PERMS.PREFIXES_EDIT,
"help-question.change": PERMS.PAGES_EDIT,
"writeable-box.change": PERMS.PAGES_EDIT,
"email-template.change": PERMS.PAGES_EDIT,
"theme.update": PERMS.SETTINGS_EDIT,
"theme.apply-preset": PERMS.SETTINGS_EDIT,
"theme.custom-change": PERMS.SETTINGS_EDIT,
"theme.apply-custom": PERMS.SETTINGS_EDIT,
"favicon.save": PERMS.SETTINGS_EDIT,
"favicon.delete": PERMS.SETTINGS_EDIT,
"logo.save": PERMS.SETTINGS_EDIT,
"translation.cms.save": PERMS.SETTINGS_EDIT,
"translation.client.save": PERMS.SETTINGS_EDIT,
"translation.emulator.save": PERMS.SETTINGS_EDIT,
} satisfies Record<ContentMutationOperation, string>);
export function contentMutationCapability(operation: ContentMutationOperation) {
return anyCapability(OPERATION_PERMISSION[operation]);
}
export function createContentMutationService(
adapter: ContentMutationAdapter,
resolveCapabilityContext: () => Promise<HousekeepingCapabilityContext>,
): ContentMutationService {
return {
async execute(invocation, operation, input) {
let capability: HousekeepingCapabilityContext;
try {
capability = await resolveCapabilityContext();
} catch {
return fail(
"UNAUTHENTICATED",
"errors.housekeeping.unauthenticated",
invocation.correlationId,
);
}
if (
capability.actor.id !== invocation.expectedActorId ||
!satisfiesCapability(capability, contentMutationCapability(operation))
) {
return fail(
"FORBIDDEN",
"errors.housekeeping.forbidden",
invocation.correlationId,
);
}
try {
const snapshot = await adapter.execute(operation, input, {
capability,
correlationId: invocation.correlationId,
legacy: invocation.legacy === true,
});
return ok(snapshot, invocation.correlationId, snapshot.completion);
} catch (error) {
if (error instanceof ContentMutationFailure) {
return fail(
error.code,
error.messageKey,
invocation.correlationId,
error.fieldErrors,
);
}
return fail(
"DEPENDENCY_UNAVAILABLE",
"errors.housekeeping.dependencyUnavailable",
invocation.correlationId,
);
}
},
};
}
export function createContentMutationInvocation(
actor: { readonly id: number },
correlationId: string,
): ContentMutationInvocation {
return { correlationId, expectedActorId: actor.id, legacy: true };
}
const productionAdapter: ContentMutationAdapter = {
async execute(operation, input, context) {
const { contentProductionMutationAdapter } = await import(
"./mutations-production"
);
return contentProductionMutationAdapter.execute(operation, input, context);
},
};
export const contentMutationService = createContentMutationService(
productionAdapter,
async () => {
const { getHousekeepingCapabilityContext } = await import(
"../../../foundation/server-capability-context"
);
return getHousekeepingCapabilityContext();
},
);
src/features/housekeeping/domains/content/widgets-production.ts
-54
View File
@@ -1,54 +0,0 @@
import "server-only";
import { PERMS } from "@/lib/permission-slugs";
import type { HousekeepingCapabilityContext } from "../../foundation/contracts";
import { contentQuery } from "./queries/content-queries";
type ContentWidgetKind = "editorial" | "media" | "localization";
async function total(
context: HousekeepingCapabilityContext,
routeId:
| "content.editorial.articles"
| "content.media.banners"
| "content.media.photos"
| "content.media.library"
| "content.localization.overview",
): Promise<number> {
const result = await contentQuery.run(context, {
routeId,
list: { pageSize: 1, offset: 0 },
});
if (!result.ok) throw new Error("Content widget query unavailable");
return result.data.total;
}
export async function loadContentWidget(
kind: ContentWidgetKind,
context: HousekeepingCapabilityContext,
signal: AbortSignal,
): Promise<Readonly<Record<string, number>>> {
if (signal.aborted) throw new Error("aborted Content widget");
if (kind === "editorial") {
const articles = await total(context, "content.editorial.articles");
return { articles };
}
if (kind === "media") {
const counts: Record<string, number> = {};
if (context.has(PERMS.PAGES_VIEW)) {
const [photos, library] = await Promise.all([
total(context, "content.media.photos"),
total(context, "content.media.library"),
]);
counts.photos = photos;
counts.library = library;
counts.items = photos + library;
}
if (context.has(PERMS.BANNERS_VIEW)) {
counts.banners = await total(context, "content.media.banners");
}
return counts;
}
const stores = await total(context, "content.localization.overview");
return { stores };
}
src/features/housekeeping/domains/content/widgets.ts
-94
View File
@@ -1,94 +0,0 @@
import { PERMS } from "@/lib/permission-slugs";
import { authorizeHousekeeping } from "../../foundation/authorization";
import {
anyCapability,
type CapabilityRequirement,
fail,
type HousekeepingCapabilityContext,
type HousekeepingWidgetDefinition,
ok,
} from "../../foundation/contracts";
export const CONTENT_WIDGET_IDS = [
"content.editorial-summary",
"content.media-summary",
"content.localization-summary",
] as const;
type ContentWidgetLoader = (
context: HousekeepingCapabilityContext,
signal: AbortSignal,
) => Promise<Readonly<Record<string, number>>>;
export interface ContentWidgetAdapters {
readonly editorial: ContentWidgetLoader;
readonly media: ContentWidgetLoader;
readonly localization: ContentWidgetLoader;
}
function createWidget(
id: (typeof CONTENT_WIDGET_IDS)[number],
kind: "mandatory" | "optional",
capability: CapabilityRequirement,
load: ContentWidgetLoader,
): HousekeepingWidgetDefinition {
return {
id,
owner: "content",
kind,
capability,
async load(context, signal) {
const authorization = authorizeHousekeeping(context, capability);
if (!authorization.ok) return authorization;
try {
return ok(await load(context, signal), authorization.correlationId);
} catch {
return fail(
"DEPENDENCY_UNAVAILABLE",
"errors.housekeeping.dependencyUnavailable",
authorization.correlationId,
);
}
},
};
}
export function createContentWidgets(
adapters: ContentWidgetAdapters,
): readonly HousekeepingWidgetDefinition[] {
return [
createWidget(
"content.editorial-summary",
"mandatory",
anyCapability(PERMS.NEWS_VIEW),
adapters.editorial,
),
createWidget(
"content.media-summary",
"optional",
anyCapability(PERMS.PAGES_VIEW, PERMS.BANNERS_VIEW),
adapters.media,
),
createWidget(
"content.localization-summary",
"optional",
anyCapability(PERMS.SETTINGS_VIEW),
adapters.localization,
),
];
}
export const CONTENT_WIDGETS = createContentWidgets({
async editorial(context, signal) {
const { loadContentWidget } = await import("./widgets-production");
return loadContentWidget("editorial", context, signal);
},
async media(context, signal) {
const { loadContentWidget } = await import("./widgets-production");
return loadContentWidget("media", context, signal);
},
async localization(context, signal) {
const { loadContentWidget } = await import("./widgets-production");
return loadContentWidget("localization", context, signal);
},
});