Reorganize repo structure and standards references

This commit is contained in:
david committed 2026-06-29 05:03:42 +02:00
1 parent 3cb93a81be
commit be2054274d
5885 files changed
+2588 -195

No files matched your search

@@ -0,0 +1,110 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { LoaderFunctionArgs } from "react-router";
import { loader } from "./events.$id";
import { getEvent } from "~/modules/events/db/events.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
vi.mock("react-i18next", () => ({
useTranslation: () => ({ t: (key: string) => key }),
}));
vi.mock("react-router", async () => {
const actual = await vi.importActual<typeof import("react-router")>("react-router");
return {
...actual,
Link: () => null,
useLoaderData: () => ({}),
useParams: () => ({ tenant: "acme", id: "event-1" }),
};
});
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/modules/events/components/EventDetails", () => ({ default: () => null }));
vi.mock("~/modules/events/db/events.db.server", () => ({
getEvent: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
const params = { tenant: "acme", id: "event-1" };
const event = {
id: "event-1",
tenantId: "tenant-1",
userId: "user-1",
name: "account.created",
data: "{}",
description: null,
createdAt: new Date("2026-05-08T10:00:00.000Z"),
tenant: { id: "tenant-1", name: "Acme", slug: "acme" },
user: { id: "user-1", email: "ada@example.test" },
};
function callLoader(routeParams = params) {
const request = new Request("https://app.example.test/acme/settings/logs/events/event-1");
return loader({ request, params: routeParams, context: {}, unstable_pattern: "app.$tenant/settings/logs/events.$id" } as LoaderFunctionArgs);
}
describe("tenant settings event detail route", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getEvent).mockResolvedValue(event as never);
});
it("checks tenant-scoped audit-trail permission before reading the requested event", async () => {
const data = await callLoader();
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getEvent).mock.invocationCallOrder[0]);
expect(getEvent).toHaveBeenCalledWith("event-1", "tenant-1");
expect(data).toEqual({ item: event });
});
it("rejects event detail reads without permission before downstream helper calls", async () => {
const rejection = new Response("Forbidden", { status: 403 });
vi.mocked(verifyUserHasPermission).mockRejectedValue(rejection as never);
await expect(callLoader()).rejects.toBe(rejection);
expect(getEvent).not.toHaveBeenCalled();
});
it("redirects missing events to the tenant events path after permission", async () => {
vi.mocked(getEvent).mockResolvedValue(null as never);
await expect(callLoader()).rejects.toMatchObject({
status: 302,
headers: expect.objectContaining({}),
});
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getEvent).mock.invocationCallOrder[0]);
expect(getEvent).toHaveBeenCalledWith("event-1", "tenant-1");
try {
await callLoader();
} catch (error) {
expect(error).toBeInstanceOf(Response);
expect((error as Response).headers.get("Location")).toBe("/acme/settings/logs/events");
}
});
it("uses an empty id after permission when the route id param is absent", async () => {
const data = await callLoader({ tenant: "acme", id: undefined as unknown as string });
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(getEvent).toHaveBeenCalledWith("", "tenant-1");
expect(data).toEqual({ item: event });
});
});
@@ -0,0 +1,50 @@
import { LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { useTranslation } from "react-i18next";
import EventDetails from "~/modules/events/components/EventDetails";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import UrlUtils from "~/utils/app/UrlUtils";
import { EventWithDetails, getEvent } from "~/modules/events/db/events.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import EventUtils from "~/modules/events/utils/EventUtils";
type LoaderData = {
item: EventWithDetails;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.auditTrails.view", tenantId);
const item = await getEvent(params.id ?? "", tenantId);
if (!item) {
throw redirect(UrlUtils.getModulePath(params, "logs/events"));
}
const data: LoaderData = {
item,
};
return data;
};
export default function AppEventDetailsRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout
title={t("models.event.object")}
withHome={false}
menu={[
{
title: t("models.event.plural"),
routePath: UrlUtils.getModulePath(params, "logs/events"),
},
{
title: EventUtils.parseName(data.item.name, t),
},
]}
>
<EventDetails item={data.item} />
</EditPageLayout>
);
}
@@ -0,0 +1,141 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { LoaderFunctionArgs } from "react-router";
import { loader } from "./events";
import { getTranslations } from "~/locale/i18next.server";
import { getEvents } from "~/modules/events/db/events.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getUsersByTenant } from "~/utils/db/users.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
vi.mock("react-i18next", () => ({
useTranslation: () => ({ t: (key: string) => key }),
}));
vi.mock("react-router", async () => {
const actual = await vi.importActual<typeof import("react-router")>("react-router");
return {
...actual,
Link: () => null,
useLoaderData: () => ({}),
useParams: () => ({ tenant: "acme" }),
};
});
vi.mock("~/components/ui/input/InputFilters", () => ({ default: () => null }));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/components/ui/tabs/Tabs", () => ({ default: () => null }));
vi.mock("~/modules/events/components/EventsTable", () => ({ default: () => null }));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/modules/events/db/events.db.server", () => ({
getEvents: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/db/users.db.server", () => ({
getUsersByTenant: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
const params = { tenant: "acme" };
const users = [
{ id: "user-1", email: "ada@example.test" },
{ id: "user-2", email: "grace@example.test" },
];
const events = [
{
id: "event-1",
tenantId: "tenant-1",
userId: "user-1",
name: "account.created",
data: "{}",
description: null,
createdAt: new Date("2026-05-08T10:00:00.000Z"),
tenant: { id: "tenant-1", name: "Acme", slug: "acme" },
user: { id: "user-1", email: "ada@example.test" },
},
];
function callLoader(url: string) {
const request = new Request(url);
return loader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/logs/events" } as LoaderFunctionArgs);
}
describe("tenant settings event list route", () => {
beforeEach(() => {
vi.clearAllMocks();
process.env.APP_NAME = "ToolCTRL";
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getTranslations).mockResolvedValue({
t: (key: string, values?: Record<string, string>) =>
key === "settings.logs.events.filters.eventOption" && values
? `formatted:${values.eventValue} -> ${values.eventLabel}`
: `translated:${key}`,
} as never);
vi.mocked(getUsersByTenant).mockResolvedValue(users as never);
vi.mocked(getEvents).mockResolvedValue({
items: events,
pagination: { page: 2, pageSize: 25, totalItems: 1, totalPages: 1 },
} as never);
});
it("checks tenant-scoped audit-trail permission before user and event helpers", async () => {
const data = await callLoader(
"https://app.example.test/acme/settings/logs/events?q=account&name=account.created&data=secret&userId=user-1&page=2&pageSize=25",
);
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getUsersByTenant).mock.invocationCallOrder[0]);
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getEvents).mock.invocationCallOrder[0]);
expect(getUsersByTenant).toHaveBeenCalledWith("tenant-1");
expect(getEvents).toHaveBeenCalledWith(
{
current: expect.objectContaining({ page: 2, pageSize: 25 }),
filters: expect.objectContaining({
query: "account",
properties: expect.arrayContaining([
expect.objectContaining({ name: "name", value: "account.created" }),
expect.objectContaining({ name: "data", value: "secret" }),
expect.objectContaining({ name: "userId", value: "user-1" }),
]),
}),
},
"tenant-1",
);
expect(data).toMatchObject({
title: "translated:models.event.plural | ToolCTRL",
items: events,
pagination: { page: 2, pageSize: 25, totalItems: 1, totalPages: 1 },
});
expect(data.filterableProperties).toEqual(
expect.arrayContaining([
expect.objectContaining({
name: "name",
options: expect.arrayContaining([expect.objectContaining({ value: "account.created", name: "formatted:account.created -> translated:events.names.account_created" })]),
}),
]),
);
});
it("rejects event list reads without permission before downstream helper calls", async () => {
const rejection = new Response("Forbidden", { status: 403 });
vi.mocked(verifyUserHasPermission).mockRejectedValue(rejection as never);
await expect(callLoader("https://app.example.test/acme/settings/logs/events?name=account.created")).rejects.toBe(rejection);
expect(getUsersByTenant).not.toHaveBeenCalled();
expect(getEvents).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,104 @@
import { LoaderFunctionArgs, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { useTranslation } from "react-i18next";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import { PaginationDto } from "~/application/dtos/data/PaginationDto";
import { ApplicationEvents, getApplicationEventNameKey } from "~/modules/events/types/ApplicationEvent";
import EventsTable from "~/modules/events/components/EventsTable";
import InputFilters from "~/components/ui/input/InputFilters";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { EventWithAttempts, getEvents } from "~/modules/events/db/events.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getFiltersFromCurrentUrl, getPaginationFromCurrentUrl } from "~/utils/helpers/RowPaginationHelper";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUsersByTenant } from "~/utils/db/users.db.server";
import Tabs from "~/components/ui/tabs/Tabs";
type LoaderData = {
title: string;
items: EventWithAttempts[];
pagination: PaginationDto;
filterableProperties: FilterablePropertyDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.auditTrails.view", tenantId);
const { t } = await getTranslations(request);
const urlSearchParams = new URL(request.url).searchParams;
const current = getPaginationFromCurrentUrl(urlSearchParams);
const filterableProperties: FilterablePropertyDto[] = [
{
name: "name",
title: "settings.logs.events.filters.event",
options: ApplicationEvents.filter((f) => !f.adminOnly || !params.tenant).map((item) => {
return {
value: item.value,
name: t("settings.logs.events.filters.eventOption", { eventValue: item.value, eventLabel: t(getApplicationEventNameKey(item.value)) }),
};
}),
},
{
name: "data",
title: "settings.logs.events.filters.data",
},
{
name: "userId",
title: "models.user.object",
options: (await getUsersByTenant(tenantId)).map((item) => {
return {
value: item.id,
name: item.email,
};
}),
},
];
const filters = getFiltersFromCurrentUrl(request, filterableProperties);
const { items, pagination } = await getEvents({ current, filters }, tenantId);
const data: LoaderData = {
title: `${t("models.event.plural")} | ${process.env.APP_NAME}`,
items,
pagination,
filterableProperties,
};
return data;
};
export default function AppEventsRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout>
<div data-ui-id="ui.settings.logs.events.page" className="space-y-2">
<div className="flex justify-between gap-2">
<div data-ui-id="ui.settings.logs.tabs" className="grow">
<Tabs
tabs={[
{
name: t("models.log.plural"),
routePath: UrlUtils.getModulePath(params, "logs"),
},
{
name: t("models.event.plural"),
routePath: UrlUtils.getModulePath(params, "logs/events"),
},
]}
/>
</div>
<div data-ui-id="ui.settings.logs.filters">
<InputFilters size="sm" filters={data.filterableProperties} />
</div>
</div>
<div data-ui-id="ui.settings.logs.events.table">
<EventsTable items={data.items} pagination={data.pagination} />
</div>
</div>
</EditPageLayout>
);
}
@@ -0,0 +1,175 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { LoaderFunctionArgs } from "react-router";
import { loader } from "./index";
import { getTenantAuditLogList, serializeAdminAuditLogsCsv } from "@toolctrl/db/logs.server";
import { getTranslations } from "~/locale/i18next.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { readRepoFile } from "~/utils/testing/repoPaths";
vi.mock("react-i18next", () => ({
useTranslation: () => ({ t: (key: string) => key }),
}));
vi.mock("react-router", async () => {
const actual = await vi.importActual<typeof import("react-router")>("react-router");
return {
...actual,
Link: () => null,
useLoaderData: () => ({}),
useParams: () => ({ tenant: "acme" }),
};
});
vi.mock("~/components/activity/TenantActivityLogToolbar", () => ({ default: () => null }));
vi.mock("~/components/app/events/LogsTable", () => ({ default: () => null }));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/components/ui/tabs/Tabs", () => ({ default: () => null }));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("@toolctrl/db/logs.server", () => ({
getTenantAuditLogList: vi.fn(),
serializeAdminAuditLogsCsv: vi.fn(),
}));
const params = { tenant: "acme" };
const auditRows = [
{
id: "log-1",
createdAt: new Date("2026-05-08T10:00:00.000Z"),
tenantId: "tenant-1",
userId: "user-1",
apiKeyId: null,
action: "create",
url: "/acme/contacts",
details: "redacted details",
rowId: null,
commentId: null,
tenant: { id: "tenant-1", name: "Acme", slug: "acme" },
user: { id: "user-1", email: "admin@example.test", firstName: "Ada", lastName: "Admin" },
apiKey: null,
comment: null,
},
];
function callLoader(url: string) {
const request = new Request(url);
return loader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/logs" } as LoaderFunctionArgs);
}
function readTenantLogsRoute() {
return readRepoFile("apps/web/app/routes/app.$tenant/settings/logs/index.tsx");
}
describe("tenant settings logs route", () => {
beforeEach(() => {
vi.clearAllMocks();
process.env.APP_NAME = "ToolCTRL";
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getTranslations).mockResolvedValue({ t: (key: string) => `translated:${key}` } as never);
vi.mocked(getTenantAuditLogList).mockResolvedValue({ rows: auditRows, total: 1, take: 25, skip: 25 } as never);
vi.mocked(serializeAdminAuditLogsCsv).mockReturnValue("csv-body\n");
});
it("checks permission before reading the tenant-scoped filtered table data", async () => {
const data = await callLoader(
"https://app.example.test/acme/settings/logs?q=contact&action=create&url=%2Fcontacts&tenantId=other-tenant&userId=user-1&createdAtFrom=2026-05-01&createdAtTo=2026-05-08&page=2&pageSize=25",
);
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getTenantAuditLogList).mock.invocationCallOrder[0]);
expect(getTenantAuditLogList).toHaveBeenCalledWith("tenant-1", {
q: "contact",
action: "create",
url: "/contacts",
userId: "user-1",
createdAtFrom: "2026-05-01",
createdAtTo: "2026-05-08",
take: 25,
skip: 25,
});
expect(JSON.stringify(vi.mocked(getTenantAuditLogList).mock.calls[0]?.[1])).not.toContain("other-tenant");
expect(data).toMatchObject({
title: "translated:models.log.plural | ToolCTRL",
items: auditRows,
pagination: { page: 2, pageSize: 25, totalItems: 1, totalPages: 1 },
});
});
it("exports CSV with the same tenant filters and a capped export window", async () => {
const response = (await callLoader(
"https://app.example.test/acme/settings/logs?export=csv&q=login&action=auth&url=%2Flogin&tenantId=other-tenant&userId=user-2&createdAtFrom=bad-date&createdAtTo=2026-05-08&page=9&pageSize=5",
)) as Response;
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getTenantAuditLogList).mock.invocationCallOrder[0]);
expect(getTenantAuditLogList).toHaveBeenCalledWith("tenant-1", {
q: "login",
action: "auth",
url: "/login",
userId: "user-2",
createdAtFrom: "bad-date",
createdAtTo: "2026-05-08",
take: 500,
skip: 0,
});
expect(JSON.stringify(vi.mocked(getTenantAuditLogList).mock.calls[0]?.[1])).not.toContain("other-tenant");
expect(serializeAdminAuditLogsCsv).toHaveBeenCalledWith(auditRows);
expect(response.headers.get("Content-Type")).toBe("text/csv; charset=utf-8");
expect(response.headers.get("Content-Disposition")).toBe('attachment; filename="tenant-audit-logs.csv"');
expect(await response.text()).toBe("csv-body\n");
});
it("rejects table and CSV reads without permission before helper calls", async () => {
const rejection = new Response("Forbidden", { status: 403 });
vi.mocked(verifyUserHasPermission).mockRejectedValue(rejection as never);
await expect(callLoader("https://app.example.test/acme/settings/logs?export=csv")).rejects.toBe(rejection);
expect(getTenantAuditLogList).not.toHaveBeenCalled();
expect(serializeAdminAuditLogsCsv).not.toHaveBeenCalled();
});
it("does not crash on malformed numeric and date filters", async () => {
vi.mocked(getTenantAuditLogList).mockResolvedValue({ rows: [], total: 0, take: 10, skip: 0 } as never);
const data = await callLoader("https://app.example.test/acme/settings/logs?page=abc&pageSize=-5&createdAtFrom=not-a-date&createdAtTo=also-bad");
expect(getTenantAuditLogList).toHaveBeenCalledWith("tenant-1", {
q: null,
action: null,
url: null,
userId: null,
createdAtFrom: "not-a-date",
createdAtTo: "also-bad",
take: 10,
skip: 0,
});
expect(data).toMatchObject({ pagination: { page: 1, pageSize: 10, totalItems: 0, totalPages: 0 } });
});
it("uses the package audit-log boundary instead of the legacy app DB helper", () => {
const source = readTenantLogsRoute();
expect(source).toContain('from "@toolctrl/db/logs.server"');
expect(source).toContain("getTenantAuditLogList");
expect(source).toContain("serializeAdminAuditLogsCsv");
expect(source).toContain("TenantActivityLogToolbar");
expect(source).not.toContain("getLogs");
expect(source).not.toContain('from "~/utils/db/logs.db.server"');
});
});
@@ -0,0 +1,150 @@
import type { AdminAuditLogFilters, AdminAuditLogRow } from "@toolctrl/db/logs.server";
import { getTenantAuditLogList, serializeAdminAuditLogsCsv } from "@toolctrl/db/logs.server";
import { LoaderFunctionArgs, MetaFunction, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { useTranslation } from "react-i18next";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import { PaginationDto } from "~/application/dtos/data/PaginationDto";
import TenantActivityLogToolbar from "~/components/activity/TenantActivityLogToolbar";
import LogsTable from "~/components/app/events/LogsTable";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import UrlUtils from "~/utils/app/UrlUtils";
import { getTranslations } from "~/locale/i18next.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getFiltersFromCurrentUrl, getPaginationFromCurrentUrl } from "~/utils/helpers/RowPaginationHelper";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import Tabs from "~/components/ui/tabs/Tabs";
const CSV_EXPORT_TAKE = 500;
type LoaderData = {
title: string;
items: AdminAuditLogRow[];
pagination: PaginationDto;
filterableProperties: FilterablePropertyDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.auditTrails.view", tenantId);
const { t } = await getTranslations(request);
const filterableProperties = getAuditLogFilterableProperties();
const filters = getFiltersFromCurrentUrl(request, filterableProperties);
const urlSearchParams = new URL(request.url).searchParams;
const auditLogFilters = getAuditLogFiltersFromUrl(urlSearchParams);
if (urlSearchParams.get("export") === "csv") {
const { rows } = await getTenantAuditLogList(tenantId, { ...auditLogFilters, take: CSV_EXPORT_TAKE, skip: 0 });
return new Response(serializeAdminAuditLogsCsv(rows), {
headers: {
"Content-Type": "text/csv; charset=utf-8",
"Content-Disposition": 'attachment; filename="tenant-audit-logs.csv"',
},
});
}
const currentPagination = getPaginationFromCurrentUrl(urlSearchParams);
const pageSize = normalizePositiveInteger(currentPagination.pageSize, 10);
const page = normalizePositiveInteger(currentPagination.page, 1);
const { rows, total, take } = await getTenantAuditLogList(tenantId, {
...auditLogFilters,
take: pageSize,
skip: pageSize * (page - 1),
});
const data: LoaderData = {
title: `${t("models.log.plural")} | ${process.env.APP_NAME}`,
items: rows,
pagination: {
page,
pageSize: take,
totalItems: total,
totalPages: Math.ceil(total / take),
sortedBy: currentPagination.sortedBy,
query: currentPagination.query,
},
filterableProperties: filters.properties,
};
return data;
};
function getAuditLogFilterableProperties(): FilterablePropertyDto[] {
return [
{
name: "action",
title: "models.log.action",
},
{
name: "url",
title: "models.log.url",
},
{
name: "userId",
title: "shared.createdBy",
},
{
name: "createdAtFrom",
title: "shared.createdAt",
},
{
name: "createdAtTo",
title: "shared.createdAt",
},
];
}
function getAuditLogFiltersFromUrl(urlSearchParams: URLSearchParams): AdminAuditLogFilters {
return {
q: urlSearchParams.get("q"),
action: urlSearchParams.get("action"),
url: urlSearchParams.get("url"),
userId: urlSearchParams.get("userId"),
createdAtFrom: urlSearchParams.get("createdAtFrom"),
createdAtTo: urlSearchParams.get("createdAtTo"),
};
}
function normalizePositiveInteger(value: number | null | undefined, fallback: number): number {
if (!Number.isFinite(value) || !value || value < 1) return fallback;
return Math.trunc(value);
}
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function Events() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout
// title={t("models.log.plural")}
>
<div data-ui-id="ui.settings.logs.page" className="space-y-2">
<div className="flex justify-between gap-2">
<div data-ui-id="ui.settings.logs.tabs" className="grow">
<Tabs
tabs={[
{
name: t("models.log.plural"),
routePath: UrlUtils.getModulePath(params, "logs"),
},
{
name: t("models.event.plural"),
routePath: UrlUtils.getModulePath(params, "logs/events"),
},
]}
/>
</div>
<div data-ui-id="ui.settings.logs.filters">
<TenantActivityLogToolbar filters={data.filterableProperties} />
</div>
</div>
<div data-ui-id="ui.settings.logs.table">
<LogsTable withTenant={false} items={data.items} pagination={data.pagination} />
</div>
</div>
</EditPageLayout>
);
}