Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -12,7 +12,7 @@ import { adminPath } from "~/utils/app/CanonicalUrlUtils";
export default function KbCategorySectionForm({
knowledgeBase,
category,
category: _category,
language,
item,
onDelete,
@@ -33,8 +33,8 @@ export default function KnowledgeBaseForm({ item, onDelete }: { item?: Knowledge
}, 100);
}, []);
const [basePath, setBasePath] = useState<string | number | undefined>(item ? item.basePath : "/");
const [slug, setSlug] = useState(item ? item.slug : "docs");
const [_basePath, setBasePath] = useState<string | number | undefined>(item ? item.basePath : "/");
const [_slug, setSlug] = useState(item ? item.slug : "docs");
const [title, setTitle] = useState(item?.title || "");
const [description, setDescription] = useState(item?.description || "");
const [defaultLanguage, setDefaultLanguage] = useState<string | undefined>(item?.defaultLanguage || KnowledgeBaseUtils.defaultLanguage);
@@ -28,6 +28,16 @@ const sourceFiles = [
];
describe("knowledge base authoring i18n", () => {
it("keeps authorable content languages separate from product UI locales", () => {
const source = fs.readFileSync(path.join(repoRoot, "apps/web/app/modules/knowledgeBase/utils/KnowledgeBaseUtils.ts"), "utf8");
expect(source).toContain('{ name: "Deutsch", value: "de"');
expect(source).toContain('{ name: "English", value: "en"');
for (const locale of ["pl", "ru", "uk", "hu"]) {
expect(source).not.toContain(`value: "${locale}"`);
}
});
it("uses semantic keys for visible admin authoring labels", () => {
const sources = sourceFiles.map((file) => fs.readFileSync(path.join(repoRoot, file), "utf8")).join("\n");
@@ -1,6 +1,6 @@
import TableSimple from "~/components/ui/tables/TableSimple";
import { KnowledgeBasesTemplateDto } from "../../dtos/KnowledgeBasesTemplateDto";
import { t as i18nT } from "i18next";
import { requestScopedT as i18nT } from "~/locale/request-scoped-t";
export default function PreviewKbsTemplate({ template }: { template: KnowledgeBasesTemplateDto }) {
return (
@@ -356,12 +356,14 @@ export async function getKbArticleBySlug({
slug: string;
language: string;
}): Promise<KnowledgeBaseArticleWithDetails | null> {
// cachified expects milliseconds. Keep this short until article mutations
// publish cross-replica invalidations for this lookup.
const publicArticleCacheTtlMs = 60_000;
return await cachified({
key: `kb-article:${knowledgeBaseId}:${slug}:${language}`,
ttl: 60 * 60 * 24,
ttl: publicArticleCacheTtlMs,
getFreshValue: () =>
// Public KB article fetch (cached for 24h) — replica-safe; lag is
// well under the cache TTL.
// Public KB article fetch — replica-safe; lag is below the short cache TTL.
dbRead.knowledgeBaseArticle
.findFirstOrThrow({
where: {
@@ -458,7 +460,7 @@ export async function updateKnowledgeBaseArticle(
seoImage: data.seoImage,
publishedAt: data.publishedAt,
};
const updated = await db.knowledgeBaseArticle
await db.knowledgeBaseArticle
.update({
where: { id },
data: update,
@@ -603,15 +605,7 @@ export async function deleteKnowledgeBaseArticle(id: string) {
return result;
}
export async function deleteKnowledgeBaseArticleInKnowledgeBase({
id,
knowledgeBaseId,
language,
}: {
id: string;
knowledgeBaseId: string;
language: string;
}) {
export async function deleteKnowledgeBaseArticleInKnowledgeBase({ id, knowledgeBaseId, language }: { id: string; knowledgeBaseId: string; language: string }) {
const item = await db.knowledgeBaseArticle.findFirst({
where: { id, knowledgeBaseId, language },
select: { id: true, slug: true },
@@ -5,12 +5,13 @@ import { createKnowledgeBaseArticleView, getArticleStateByUserAnalyticsId, voteA
import { KbArticleDto } from "../../dtos/KbArticleDto";
import { KbCategoryDto } from "../../dtos/KbCategoryDto";
import { KnowledgeBaseDto } from "../../dtos/KnowledgeBaseDto";
import KnowledgeBaseService from "../../service/KnowledgeBaseService.server";
import KnowledgeBaseService, { KnowledgeBaseServiceError } from "../../service/KnowledgeBaseService.server";
import KnowledgeBaseUtils from "../../utils/KnowledgeBaseUtils";
import { KbSearchResultDto } from "../../dtos/KbSearchResultDto";
import { getUser } from "~/utils/db/users.db.server";
import { getAnalyticsInfo } from "~/utils/analyticsCookie.server";
import { getTranslations } from "~/locale/i18next.server";
import { withPublicKnowledgeBaseRlsContext } from "../../services/publicKnowledgeBaseRls.server";
export namespace KbRoutesArticleApi {
export type LoaderData = {
@@ -29,69 +30,78 @@ export namespace KbRoutesArticleApi {
categories: KbCategoryDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs, { kbSlug }: { kbSlug?: string } = {}) => {
const analyticsInfo = await getAnalyticsInfo(request);
const userInfo = await getUserInfo(request);
const kb = await KnowledgeBaseService.get({ slug: kbSlug ?? params.slug!, enabled: true, request });
const item = await KnowledgeBaseService.getArticle({
kb,
slug: params.article ?? "",
params,
request,
});
if (!item) {
throw redirect(KnowledgeBaseUtils.getKbUrl({ kb, params }));
}
if (item?.article) {
createKnowledgeBaseArticleView({ userAnalyticsId: analyticsInfo.userAnalyticsId, articleId: item.article.id });
}
let userState = await getArticleStateByUserAnalyticsId({
userAnalyticsId: analyticsInfo.userAnalyticsId,
articleId: item?.article.id ?? "",
});
const searchParams = new URL(request.url).searchParams;
const query = searchParams.get("q")?.toString();
const currentUser = await getUser(userInfo.userId);
KnowledgeBaseUtils.fixDarkMode({ article: item.article });
const data: LoaderData = {
metatags: item?.article.metatags,
kb,
search: await KnowledgeBaseService.search({ query, kb, params, request }),
item,
userState,
isAdmin: !!currentUser?.admin,
categories: await KnowledgeBaseService.getCategories({
const slug = kbSlug ?? params.slug ?? "";
const result = await withPublicKnowledgeBaseRlsContext(slug, async () => {
const analyticsInfo = await getAnalyticsInfo(request);
const userInfo = await getUserInfo(request);
const kb = await KnowledgeBaseService.get({ slug, enabled: true, request });
const item = await KnowledgeBaseService.getArticle({
kb,
slug: params.article ?? "",
params,
request,
}),
};
return data;
});
if (!item) {
throw redirect(KnowledgeBaseUtils.getKbUrl({ kb, params }));
}
await createKnowledgeBaseArticleView({ userAnalyticsId: analyticsInfo.userAnalyticsId, articleId: item.article.id });
const userState = await getArticleStateByUserAnalyticsId({
userAnalyticsId: analyticsInfo.userAnalyticsId,
articleId: item.article.id,
});
const searchParams = new URL(request.url).searchParams;
const query = searchParams.get("q")?.toString();
const currentUser = await getUser(userInfo.userId);
KnowledgeBaseUtils.fixDarkMode({ article: item.article });
const data: LoaderData = {
metatags: item.article.metatags,
kb,
search: await KnowledgeBaseService.search({ query, kb, params, request }),
item,
userState,
isAdmin: !!currentUser?.admin,
categories: await KnowledgeBaseService.getCategories({
kb,
params,
request,
}),
};
return data;
});
if (!result) throw new KnowledgeBaseServiceError("not-found");
return result;
};
export const action = async ({ request, params }: ActionFunctionArgs, { kbSlug }: { kbSlug?: string } = {}) => {
const { t } = await getTranslations(request);
const { userAnalyticsId } = await getAnalyticsInfo(request);
const form = await request.formData();
const action = form.get("action") as string;
const kb = await KnowledgeBaseService.get({ slug: kbSlug ?? params.slug!, enabled: true, request });
const item = await KnowledgeBaseService.getArticle({
kb,
slug: params.article ?? "",
params,
request,
});
if (!item) {
return Response.json({ error: t("knowledgeBase.public.errors.articleNotFound") }, { status: 404 });
}
if (action === "thumbsUp") {
await voteArticle({ userAnalyticsId, articleId: item.article.id, type: "up" });
return Response.json({ success: true });
} else if (action === "thumbsDown") {
await voteArticle({ userAnalyticsId, articleId: item.article.id, type: "down" });
return Response.json({ success: true });
}
const slug = kbSlug ?? params.slug ?? "";
const result = await withPublicKnowledgeBaseRlsContext(slug, async () => {
const { t } = await getTranslations(request);
const { userAnalyticsId } = await getAnalyticsInfo(request);
const form = await request.formData();
const action = form.get("action") as string;
const kb = await KnowledgeBaseService.get({ slug, enabled: true, request });
const item = await KnowledgeBaseService.getArticle({
kb,
slug: params.article ?? "",
params,
request,
});
if (!item) {
return Response.json({ error: t("knowledgeBase.public.errors.articleNotFound") }, { status: 404 });
}
if (action === "thumbsUp") {
await voteArticle({ userAnalyticsId, articleId: item.article.id, type: "up" });
return Response.json({ success: true });
}
if (action === "thumbsDown") {
await voteArticle({ userAnalyticsId, articleId: item.article.id, type: "down" });
return Response.json({ success: true });
}
return Response.json({ error: t("knowledgeBase.public.errors.invalidAction") }, { status: 400 });
return Response.json({ error: t("knowledgeBase.public.errors.invalidAction") }, { status: 400 });
});
if (!result) throw new KnowledgeBaseServiceError("not-found");
return result;
};
}
@@ -2,9 +2,10 @@ import { LoaderFunctionArgs, redirect } from "react-router";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import { KbCategoryDto } from "../../dtos/KbCategoryDto";
import { KnowledgeBaseDto } from "../../dtos/KnowledgeBaseDto";
import KnowledgeBaseService from "../../service/KnowledgeBaseService.server";
import KnowledgeBaseService, { KnowledgeBaseServiceError } from "../../service/KnowledgeBaseService.server";
import KnowledgeBaseUtils from "../../utils/KnowledgeBaseUtils";
import { KbSearchResultDto } from "../../dtos/KbSearchResultDto";
import { withPublicKnowledgeBaseRlsContext } from "../../services/publicKnowledgeBaseRls.server";
export namespace KbRoutesCategoryApi {
export type LoaderData = {
@@ -16,33 +17,38 @@ export namespace KbRoutesCategoryApi {
allCategories: KbCategoryDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs, { kbSlug }: { kbSlug?: string } = {}) => {
const kb = await KnowledgeBaseService.get({ slug: kbSlug ?? params.slug!, enabled: true, request });
const language = params.lang ?? kb.defaultLanguage;
const slug = kbSlug ?? params.slug ?? "";
const result = await withPublicKnowledgeBaseRlsContext(slug, async () => {
const kb = await KnowledgeBaseService.get({ slug, enabled: true, request });
const language = params.lang ?? kb.defaultLanguage;
const item = await KnowledgeBaseService.getCategory({
kb,
category: params.category ?? "",
language,
params,
request,
});
if (!item) {
throw redirect(KnowledgeBaseUtils.getKbUrl({ kb, params }));
}
const searchParams = new URL(request.url).searchParams;
const query = searchParams.get("q")?.toString();
const data: LoaderData = {
metatags: item?.metatags,
kb,
search: await KnowledgeBaseService.search({ query, kb, params, request }),
item,
allCategories: await KnowledgeBaseService.getCategories({
const item = await KnowledgeBaseService.getCategory({
kb,
category: params.category ?? "",
language,
params,
request,
}),
language,
};
return data;
});
if (!item) {
throw redirect(KnowledgeBaseUtils.getKbUrl({ kb, params }));
}
const searchParams = new URL(request.url).searchParams;
const query = searchParams.get("q")?.toString();
const data: LoaderData = {
metatags: item.metatags,
kb,
search: await KnowledgeBaseService.search({ query, kb, params, request }),
item,
allCategories: await KnowledgeBaseService.getCategories({
kb,
params,
request,
}),
language,
};
return data;
});
if (!result) throw new KnowledgeBaseServiceError("not-found");
return result;
};
}
@@ -4,12 +4,13 @@ import { createKnowledgeBaseView } from "../../db/kbAnalytics.db.server";
import { KbArticleDto } from "../../dtos/KbArticleDto";
import { KbCategoryDto } from "../../dtos/KbCategoryDto";
import { KnowledgeBaseDto } from "../../dtos/KnowledgeBaseDto";
import KnowledgeBaseService from "../../service/KnowledgeBaseService.server";
import KnowledgeBaseService, { KnowledgeBaseServiceError } from "../../service/KnowledgeBaseService.server";
import { KbSearchResultDto } from "../../dtos/KbSearchResultDto";
import KnowledgeBaseUtils from "../../utils/KnowledgeBaseUtils";
import { getAnalyticsInfo } from "~/utils/analyticsCookie.server";
import { getUserInfo } from "~/utils/session.server";
import { getUser } from "~/utils/db/users.db.server";
import { withPublicKnowledgeBaseRlsContext } from "../../services/publicKnowledgeBaseRls.server";
export namespace KbRoutesIndexApi {
export type LoaderData = {
@@ -21,35 +22,39 @@ export namespace KbRoutesIndexApi {
isAdmin: boolean;
};
export const loader = async ({ request, params }: LoaderFunctionArgs, { kbSlug }: { kbSlug?: string } = {}) => {
if (params.lang && !KnowledgeBaseUtils.supportedLanguages.find((f) => f.value === params.lang)) {
throw Response.json({}, { status: 404 });
}
const kb = await KnowledgeBaseService.get({ slug: kbSlug ?? params.slug!, enabled: true, request });
const slug = kbSlug ?? params.slug ?? "";
const result = await withPublicKnowledgeBaseRlsContext(slug, async () => {
if (params.lang && !KnowledgeBaseUtils.supportedLanguages.find((f) => f.value === params.lang)) {
throw Response.json({}, { status: 404 });
}
const kb = await KnowledgeBaseService.get({ slug, enabled: true, request });
const { userAnalyticsId } = await getAnalyticsInfo(request);
const userInfo = await getUserInfo(request);
const { userAnalyticsId } = await getAnalyticsInfo(request);
const userInfo = await getUserInfo(request);
await createKnowledgeBaseView({ userAnalyticsId, knowledgeBaseId: kb.id });
const searchParams = new URL(request.url).searchParams;
const query = searchParams.get("q")?.toString();
const currentUser = await getUser(userInfo.userId);
const data: LoaderData = {
metatags: kb.metatags,
kb,
search: await KnowledgeBaseService.search({ query, kb, params, request }),
categories: await KnowledgeBaseService.getCategories({
await createKnowledgeBaseView({ userAnalyticsId, knowledgeBaseId: kb.id });
const searchParams = new URL(request.url).searchParams;
const query = searchParams.get("q")?.toString();
const currentUser = await getUser(userInfo.userId);
const data: LoaderData = {
metatags: kb.metatags,
kb,
params,
request,
}),
featured: await KnowledgeBaseService.getFeaturedArticles({
kb,
params,
request,
}),
isAdmin: !!currentUser?.admin,
// searchResult,
};
return data;
search: await KnowledgeBaseService.search({ query, kb, params, request }),
categories: await KnowledgeBaseService.getCategories({
kb,
params,
request,
}),
featured: await KnowledgeBaseService.getFeaturedArticles({
kb,
params,
request,
}),
isAdmin: !!currentUser?.admin,
};
return data;
});
if (!result) throw new KnowledgeBaseServiceError("not-found");
return result;
};
}
@@ -1,4 +1,5 @@
import { beforeEach, describe, expect, test, vi } from "vitest";
import { runWithRlsContext } from "@hivegrid/db/rls-context.server";
const getAllKnowledgeBaseArticlesMock = vi.fn();
const createKnowledgeBaseArticleMock = vi.fn();
@@ -7,6 +8,7 @@ const getFixedTMock = vi.fn();
const knowledgeBaseArticleCountMock = vi.fn();
const knowledgeBaseCategoryCountMock = vi.fn();
const knowledgeBaseDeleteMock = vi.fn();
const getKnowledgeBaseByIdMock = vi.fn();
const cachifiedMock = vi.fn();
vi.mock("../db/kbArticles.db.server", () => ({
@@ -27,7 +29,7 @@ vi.mock("../db/kbCategories.db.server", () => ({
vi.mock("../db/knowledgeBase.db.server", () => ({
getAllKnowledgeBases: vi.fn(),
getKnowledgeBaseById: vi.fn(),
getKnowledgeBaseById: (...args: unknown[]) => getKnowledgeBaseByIdMock(...args),
getKnowledgeBaseBySlug: vi.fn(),
}));
@@ -69,6 +71,7 @@ describe("KnowledgeBaseServiceServer", () => {
knowledgeBaseArticleCountMock.mockResolvedValue(0);
knowledgeBaseCategoryCountMock.mockResolvedValue(0);
knowledgeBaseDeleteMock.mockResolvedValue({ id: "kb-1" });
getKnowledgeBaseByIdMock.mockResolvedValue(null);
cachifiedMock.mockImplementation(async ({ getFreshValue }: { getFreshValue: () => unknown }) => getFreshValue());
});
@@ -87,10 +90,94 @@ describe("KnowledgeBaseServiceServer", () => {
});
expect(getFixedTMock).toHaveBeenCalledWith("de", "translations");
expect(createKnowledgeBaseArticleMock).toHaveBeenCalledWith(expect.objectContaining({ title: "de:knowledgeBase.adminCategories.untitledNumbered:1", language: "de" }));
expect(createKnowledgeBaseArticleMock).toHaveBeenCalledWith(
expect.objectContaining({ title: "de:knowledgeBase.adminCategories.untitledNumbered:1", language: "de" })
);
expect(created).toMatchObject({ title: "de:knowledgeBase.adminCategories.untitledNumbered:1", language: "de" });
});
test("public article DTOs never expose draft content or author identity", async () => {
const publishedAt = new Date("2026-07-14T00:00:00.000Z");
getAllKnowledgeBaseArticlesMock.mockResolvedValueOnce([
{
id: "article-public",
createdAt: publishedAt,
updatedAt: publishedAt,
slug: "published",
title: "Published",
description: "Public description",
order: 0,
contentDraft: "private draft",
contentPublished: "public content",
contentPublishedAsText: "public content",
contentType: "markdown",
language: "de",
featuredOrder: null,
createdByUser: { firstName: "Private", lastName: "Author", avatar: null },
publishedAt,
sectionId: null,
relatedArticles: [],
seoImage: "",
},
]);
const KnowledgeBaseServiceServer = (await import("./KnowledgeBaseService.server")).default;
const kb = {
id: "kb-public",
slug: "docs",
title: "Docs",
defaultLanguage: "de",
} as never;
const articles = await runWithRlsContext({ publicKnowledgeBaseId: "kb-public" }, () =>
KnowledgeBaseServiceServer.getArticles({
kb,
categoryId: "category-public",
language: "de",
query: undefined,
params: {},
request: new Request("https://example.test/docs"),
})
);
expect(articles).toHaveLength(1);
expect(articles[0]).toMatchObject({
contentDraft: "",
contentPublished: "public content",
createdByUser: null,
});
});
test("public KB lookup re-reads the capability-bound id instead of using the shared slug cache", async () => {
getKnowledgeBaseByIdMock.mockResolvedValueOnce({
id: "kb-public",
createdAt: new Date("2026-07-14T00:00:00.000Z"),
updatedAt: new Date("2026-07-14T00:00:00.000Z"),
basePath: "/docs",
slug: "docs",
title: "Docs",
description: "Public docs",
defaultLanguage: "de",
layout: "docs",
color: 0,
enabled: true,
languages: '["de"]',
links: "[]",
logo: "",
seoImage: "",
_count: { categories: 1, articles: 1, views: 0 },
});
const KnowledgeBaseServiceServer = (await import("./KnowledgeBaseService.server")).default;
await expect(
runWithRlsContext({ publicKnowledgeBaseId: "kb-public" }, () =>
KnowledgeBaseServiceServer.get({ slug: "docs", enabled: true, request: new Request("https://example.test/docs") })
)
).resolves.toMatchObject({ id: "kb-public", slug: "docs", enabled: true });
expect(getKnowledgeBaseByIdMock).toHaveBeenCalledWith("kb-public");
expect(cachifiedMock).not.toHaveBeenCalled();
});
test("del exposes coded delete guard errors for localized route handling", async () => {
const { default: KnowledgeBaseServiceServer, getKnowledgeBaseActionErrorKey } = await import("./KnowledgeBaseService.server");
knowledgeBaseArticleCountMock.mockResolvedValueOnce(1);
@@ -24,6 +24,8 @@ import { htmlToText } from "html-to-text";
import { remixI18Next } from "~/locale/i18next.server";
import { cachified } from "~/utils/cache.server";
import { getBaseURL } from "~/utils/url.server";
import { getRlsExecutionContext } from "@hivegrid/db/rls-context.server";
import { mapPublicKnowledgeBasesWithRlsContext } from "../services/publicKnowledgeBaseRls.server";
export type KnowledgeBaseServiceErrorCode =
| "cannot-delete-with-articles"
@@ -65,18 +67,27 @@ export function getKnowledgeBasePublicErrorKey(error: unknown): string {
return "knowledgeBase.public.errors.unavailable";
}
async function getAll({ enabled, request }: { enabled?: boolean; request: Request }): Promise<KnowledgeBaseDto[]> {
const items = await getAllKnowledgeBases({ enabled });
// cachified expects milliseconds. Keep this short until KB mutations publish
// cross-replica invalidations for the web L1 cache.
const PUBLIC_KNOWLEDGE_BASE_CACHE_TTL_MS = 60_000;
async function getAll({ enabled, request, publicOnly = false }: { enabled?: boolean; request: Request; publicOnly?: boolean }): Promise<KnowledgeBaseDto[]> {
const items = publicOnly
? await mapPublicKnowledgeBasesWithRlsContext((knowledgeBaseId) => getKnowledgeBaseById(knowledgeBaseId))
: await getAllKnowledgeBases({ enabled });
return items.map((item) => kbToDto(item, request));
}
async function get({ slug, enabled, request }: { slug: string; enabled?: boolean; request: Request }): Promise<KnowledgeBaseDto> {
const item = await cachified({
key: `kb:${slug}`,
ttl: 60 * 60 * 24,
getFreshValue: () => getKnowledgeBaseBySlug(slug),
});
if (!item) {
const publicKnowledgeBaseId = getRlsExecutionContext()?.publicKnowledgeBaseId;
const item = publicKnowledgeBaseId
? await getKnowledgeBaseById(publicKnowledgeBaseId)
: await cachified({
key: `kb:${slug}`,
ttl: PUBLIC_KNOWLEDGE_BASE_CACHE_TTL_MS,
getFreshValue: () => getKnowledgeBaseBySlug(slug),
});
if (!item || (publicKnowledgeBaseId && item.slug !== slug)) {
throw new KnowledgeBaseServiceError("not-found");
}
@@ -347,6 +358,7 @@ function articleToDto({
request: Request;
}) {
const baseUrl = getBaseURL(request, { https: true });
const isPublicKnowledgeBaseRequest = getRlsExecutionContext()?.publicKnowledgeBaseId === kb.id;
const item: KbArticleDto = {
id: article.id,
createdAt: article.createdAt,
@@ -355,13 +367,13 @@ function articleToDto({
title: article.title,
description: article.description,
order: article.order,
contentDraft: article.contentDraft,
contentDraft: isPublicKnowledgeBaseRequest ? "" : article.contentDraft,
contentPublished: article.contentPublished,
contentPublishedAsText: article.contentPublishedAsText,
contentType: article.contentType as "wysiwyg" | "markdown",
language: article.language,
featuredOrder: article.featuredOrder,
createdByUser: article.createdByUser,
createdByUser: isPublicKnowledgeBaseRequest ? null : article.createdByUser,
publishedAt: article.publishedAt,
href: KnowledgeBaseUtils.getArticleUrl({ kb, article, params }),
sectionId: article.sectionId,
@@ -0,0 +1,51 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
const { resolvePublicKnowledgeBaseRlsIdentity, listPublicKnowledgeBaseRlsIdentities, runWithIsolatedPublicKnowledgeBaseRlsContext } = vi.hoisted(() => ({
resolvePublicKnowledgeBaseRlsIdentity: vi.fn(),
listPublicKnowledgeBaseRlsIdentities: vi.fn(),
runWithIsolatedPublicKnowledgeBaseRlsContext: vi.fn(async (_resourceId: string, operation: () => Promise<unknown>) => operation()),
}));
vi.mock("@hivegrid/db/rls-resolvers.server", () => ({
resolvePublicKnowledgeBaseRlsIdentity,
listPublicKnowledgeBaseRlsIdentities,
}));
vi.mock("@hivegrid/db/rls-context.server", () => ({
runWithIsolatedPublicKnowledgeBaseRlsContext,
}));
import { mapPublicKnowledgeBasesWithRlsContext, withPublicKnowledgeBaseRlsContext } from "./publicKnowledgeBaseRls.server";
describe("public knowledge-base RLS context", () => {
beforeEach(() => {
vi.clearAllMocks();
});
it("fails closed when the slug resolver does not expose an enabled global knowledge base", async () => {
resolvePublicKnowledgeBaseRlsIdentity.mockResolvedValue(null);
const operation = vi.fn();
await expect(withPublicKnowledgeBaseRlsContext("disabled", operation)).resolves.toBeNull();
expect(operation).not.toHaveBeenCalled();
expect(runWithIsolatedPublicKnowledgeBaseRlsContext).not.toHaveBeenCalled();
});
it("binds the resolved id instead of trusting the public slug", async () => {
resolvePublicKnowledgeBaseRlsIdentity.mockResolvedValue({ resourceId: "kb-public" });
const operation = vi.fn().mockResolvedValue("visible");
await expect(withPublicKnowledgeBaseRlsContext("docs", operation)).resolves.toBe("visible");
expect(runWithIsolatedPublicKnowledgeBaseRlsContext).toHaveBeenCalledWith("kb-public", operation);
});
it("runs sitemap operations once per resolver-approved public knowledge base", async () => {
listPublicKnowledgeBaseRlsIdentities.mockResolvedValue([{ resourceId: "kb-a" }, { resourceId: "kb-b" }]);
const operation = vi.fn(async (knowledgeBaseId: string) => (knowledgeBaseId === "kb-a" ? { id: knowledgeBaseId } : null));
await expect(mapPublicKnowledgeBasesWithRlsContext(operation)).resolves.toEqual([{ id: "kb-a" }]);
expect(operation).toHaveBeenCalledTimes(2);
expect(runWithIsolatedPublicKnowledgeBaseRlsContext).toHaveBeenNthCalledWith(1, "kb-a", expect.any(Function));
expect(runWithIsolatedPublicKnowledgeBaseRlsContext).toHaveBeenNthCalledWith(2, "kb-b", expect.any(Function));
});
});
@@ -0,0 +1,16 @@
import { listPublicKnowledgeBaseRlsIdentities, resolvePublicKnowledgeBaseRlsIdentity } from "@hivegrid/db/rls-resolvers.server";
import { runWithIsolatedPublicKnowledgeBaseRlsContext } from "@hivegrid/db/rls-context.server";
export async function withPublicKnowledgeBaseRlsContext<T>(slug: string, operation: () => Promise<T>): Promise<T | null> {
const identity = await resolvePublicKnowledgeBaseRlsIdentity(slug);
if (!identity) {
return null;
}
return runWithIsolatedPublicKnowledgeBaseRlsContext(identity.resourceId, operation);
}
export async function mapPublicKnowledgeBasesWithRlsContext<T>(operation: (knowledgeBaseId: string) => Promise<T | null>): Promise<Awaited<T>[]> {
const identities = await listPublicKnowledgeBaseRlsIdentities();
const values = await Promise.all(identities.map(({ resourceId }) => runWithIsolatedPublicKnowledgeBaseRlsContext(resourceId, () => operation(resourceId))));
return values.flatMap((value) => (value === null ? [] : [value]));
}
@@ -80,7 +80,7 @@ function getCategoryUrl({ kb, category, params }: { kb: { slug: string; basePath
return `${kbUrl}/categories/${category.slug}`;
}
function getCategoryArticlesBySections({ kb, category }: { kb: KnowledgeBaseDto; category: KbCategoryDto }) {
function getCategoryArticlesBySections({ kb: _kb, category }: { kb: KnowledgeBaseDto; category: KbCategoryDto }) {
let sections: {
section: KbCategorySectionDto | null;
articles: {
@@ -81,6 +81,14 @@ describe("DefaultKbsTemplate content", () => {
expect(JSON.stringify(DefaultKbsTemplate.SAMPLE_DE)).not.toContain("Back to site");
});
it("keeps content templates independent from the expanded UI locale catalog", () => {
expect(Object.keys(DefaultKbsTemplate).sort()).toEqual(["SAMPLE", "SAMPLE_DE", "SAMPLE_EN"]);
expect(DefaultKbsTemplate).not.toHaveProperty("SAMPLE_PL");
expect(DefaultKbsTemplate).not.toHaveProperty("SAMPLE_RU");
expect(DefaultKbsTemplate).not.toHaveProperty("SAMPLE_UK");
expect(DefaultKbsTemplate).not.toHaveProperty("SAMPLE_HU");
});
it("keeps German knowledge-base copy generic while preserving the Hilfe-Center product title", () => {
const deSample = DefaultKbsTemplate.SAMPLE_DE;
const deCopy = JSON.stringify(deSample);