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,301 @@
import { getDbClient } from "./client.server.js";
import type { EntityWebhook, EntityWebhookLog, Log, Prisma } from "./prisma-browser.js";
export type LegacyEntityWebhook = Pick<EntityWebhook, "id" | "method" | "endpoint">;
export type LegacyRowLogCreateData = {
tenantId: string | null;
userId?: string | null;
apiKeyId?: string | null;
url: string;
rowId?: string | null;
action: string;
details?: string | null;
commentId?: string | null;
};
export type LegacyLogWriterClient = {
log: {
create(args: {
data: {
tenantId: string | null;
userId: string | null;
apiKeyId: string | null;
url: string;
rowId: string | null;
action: string;
details: string | null;
commentId: string | null;
};
}): Promise<Log>;
};
};
export type LegacyEntityWebhookClient = {
entityWebhook: {
findMany(args: { where: { entityId: string; action: string } }): Promise<LegacyEntityWebhook[]>;
};
entityWebhookLog: {
create(args: { data: { webhookId: string; logId: string; status: number } }): Promise<EntityWebhookLog>;
};
};
export type AdminAuditLogFilters = {
q?: string | null;
action?: string | null;
url?: string | null;
tenantId?: string | null;
userId?: string | null;
createdAtFrom?: string | Date | null;
createdAtTo?: string | Date | null;
};
export type AdminAuditLogListArgs = AdminAuditLogFilters & {
take?: number | null;
skip?: number | null;
};
export type TenantAuditLogFilters = Omit<AdminAuditLogFilters, "tenantId"> & {
tenantId?: string | null;
};
export type TenantAuditLogListArgs = TenantAuditLogFilters & {
take?: number | null;
skip?: number | null;
};
export type AdminAuditLogRow = Log & {
tenant?: { id: string; name: string; slug?: string | null } | null;
user?: { id: string; email: string; firstName?: string | null; lastName?: string | null } | null;
apiKey?: { id: string; alias: string } | null;
comment?: { id: string; value: string } | null;
};
export type AdminAuditLogListResult = {
rows: AdminAuditLogRow[];
total: number;
take: number;
skip: number;
};
export type AdminAuditLogClient = {
log: {
findMany(args: {
where: Prisma.LogWhereInput;
include: typeof adminAuditLogInclude;
orderBy: Prisma.LogOrderByWithRelationInput;
take: number;
skip: number;
}): Promise<AdminAuditLogRow[]>;
count(args: { where: Prisma.LogWhereInput }): Promise<number>;
};
};
export const adminAuditLogInclude = {
user: { select: { id: true, email: true, firstName: true, lastName: true } },
tenant: { select: { id: true, name: true, slug: true } },
apiKey: { select: { id: true, alias: true } },
comment: { select: { id: true, value: true } },
} satisfies Prisma.LogInclude;
const DEFAULT_AUDIT_LOG_TAKE = 50;
const MAX_AUDIT_LOG_TAKE = 500;
const CSV_HEADERS = ["Created At", "Tenant", "Actor", "Actor Type", "Action", "URL", "Details"] as const;
const FORMULA_PREFIX_PATTERN = /^[=+\-@\t\r]/;
const SENSITIVE_LOG_KEY_PATTERN = /authorization|cookie|password|secret|token|api[-_]?key|payload|body|header/i;
export function buildAuditLogWhereFromFilters(filters: AdminAuditLogFilters): Prisma.LogWhereInput {
const where: Prisma.LogWhereInput = {};
const and: Prisma.LogWhereInput[] = [];
const q = normalizeFilter(filters.q);
if (q) {
and.push({
OR: [
{ action: { contains: q, mode: "insensitive" } },
{ url: { contains: q, mode: "insensitive" } },
{ details: { contains: q, mode: "insensitive" } },
{ tenantId: { contains: q, mode: "insensitive" } },
{ userId: { contains: q, mode: "insensitive" } },
],
});
}
const action = normalizeFilter(filters.action);
if (action) where.action = action;
const url = normalizeFilter(filters.url);
if (url) where.url = { contains: url, mode: "insensitive" };
const tenantId = normalizeFilter(filters.tenantId);
if (tenantId) where.tenantId = tenantId;
const userId = normalizeFilter(filters.userId);
if (userId) where.userId = userId;
const createdAt: Prisma.DateTimeFilter<"Log"> = {};
const createdAtFrom = parseValidDate(filters.createdAtFrom);
const createdAtTo = parseValidDate(filters.createdAtTo);
if (createdAtFrom) createdAt.gte = createdAtFrom;
if (createdAtTo) createdAt.lte = createdAtTo;
if (Object.keys(createdAt).length > 0) where.createdAt = createdAt;
if (and.length > 0) where.AND = and;
return where;
}
export async function getAdminAuditLogList(
args: AdminAuditLogListArgs,
client: AdminAuditLogClient = getDbClient() as unknown as AdminAuditLogClient,
): Promise<AdminAuditLogListResult> {
const where = buildAuditLogWhereFromFilters(args);
return getAuditLogListWithWhere(where, args, client);
}
export async function getTenantAuditLogList(
tenantId: string,
args: TenantAuditLogListArgs,
client: AdminAuditLogClient = getDbClient() as unknown as AdminAuditLogClient,
): Promise<AdminAuditLogListResult> {
const where = buildAuditLogWhereFromFilters(args);
where.tenantId = tenantId;
return getAuditLogListWithWhere(where, args, client);
}
export function serializeAdminAuditLogsCsv(rows: readonly AdminAuditLogRow[]): string {
const lines = [CSV_HEADERS.map(escapeCsvCell).join(",")];
for (const row of rows) {
lines.push(
[row.createdAt.toISOString(), formatTenant(row), formatActor(row), getActorType(row), row.action, row.url, redactLogDetails(row.details)]
.map(escapeCsvCell)
.join(","),
);
}
return `${lines.join("\n")}\n`;
}
export async function createLegacyRowLog(data: LegacyRowLogCreateData, client: LegacyLogWriterClient = getDbClient() as unknown as LegacyLogWriterClient): Promise<Log> {
return client.log.create({
data: {
tenantId: data.tenantId,
userId: data.userId ?? null,
apiKeyId: data.apiKeyId ?? null,
url: data.url,
rowId: data.rowId ?? null,
action: data.action,
details: redactLogDetails(data.details),
commentId: data.commentId ?? null,
},
});
}
export async function getLegacyEntityWebhooksByAction(entityId: string, action: string, client: LegacyEntityWebhookClient = getDbClient() as unknown as LegacyEntityWebhookClient): Promise<LegacyEntityWebhook[]> {
return client.entityWebhook.findMany({ where: { entityId, action } });
}
export async function createLegacyEntityWebhookLog(data: { webhookId: string; logId: string; status: number }, client: LegacyEntityWebhookClient = getDbClient() as unknown as LegacyEntityWebhookClient): Promise<EntityWebhookLog> {
return client.entityWebhookLog.create({ data });
}
async function getAuditLogListWithWhere(
where: Prisma.LogWhereInput,
args: { take?: number | null; skip?: number | null },
client: AdminAuditLogClient,
): Promise<AdminAuditLogListResult> {
const take = normalizeTake(args.take);
const skip = normalizeSkip(args.skip);
const queryArgs = {
where,
include: adminAuditLogInclude,
orderBy: { createdAt: "desc" } satisfies Prisma.LogOrderByWithRelationInput,
take,
skip,
};
const [rows, total] = await Promise.all([client.log.findMany(queryArgs), client.log.count({ where })]);
return { rows, total, take, skip };
}
function normalizeFilter(value: string | null | undefined): string | undefined {
const normalized = value?.trim();
return normalized ? normalized : undefined;
}
function parseValidDate(value: string | Date | null | undefined): Date | undefined {
if (!value) return undefined;
const date = value instanceof Date ? value : new Date(value);
return Number.isNaN(date.getTime()) ? undefined : date;
}
function normalizeTake(value: number | null | undefined): number {
if (!Number.isFinite(value) || !value || value < 1) return DEFAULT_AUDIT_LOG_TAKE;
return Math.min(Math.trunc(value), MAX_AUDIT_LOG_TAKE);
}
function normalizeSkip(value: number | null | undefined): number {
if (!Number.isFinite(value) || !value || value < 0) return 0;
return Math.trunc(value);
}
function formatTenant(row: AdminAuditLogRow): string {
if (row.tenant) return row.tenant.name || row.tenant.slug || row.tenant.id;
return row.tenantId ?? "";
}
function formatActor(row: AdminAuditLogRow): string {
if (row.user) {
const name = [row.user.firstName, row.user.lastName].filter(Boolean).join(" ").trim();
return name ? `${name} <${row.user.email}>` : row.user.email;
}
if (row.apiKey) return row.apiKey.alias;
return row.userId ?? row.apiKeyId ?? "System";
}
function getActorType(row: AdminAuditLogRow): string {
if (row.userId || row.user) return "User";
if (row.apiKeyId || row.apiKey) return "API Key";
return "System";
}
function escapeCsvCell(value: unknown): string {
const stringValue = String(value ?? "");
const safeValue = FORMULA_PREFIX_PATTERN.test(stringValue) ? `'${stringValue}` : stringValue;
return `"${safeValue.replaceAll('"', '""')}"`;
}
export function redactLogDetails(details?: string | null): string | null {
if (!details) {
return details ?? null;
}
try {
return JSON.stringify(redactLogValue(JSON.parse(details)));
} catch {
return redactSensitiveText(details);
}
}
function redactLogValue(value: unknown): unknown {
if (Array.isArray(value)) {
return value.map(redactLogValue);
}
if (value && typeof value === "object") {
return Object.fromEntries(
Object.entries(value as Record<string, unknown>).map(([key, entry]) => [key, SENSITIVE_LOG_KEY_PATTERN.test(key) ? "[REDACTED]" : redactLogValue(entry)]),
);
}
if (typeof value === "string") {
return redactSensitiveText(value);
}
return value;
}
function redactSensitiveText(value: string): string {
return value
.replace(/(authorization)\s*=\s*Bearer\s+\S+/gi, "$1=Bearer [REDACTED]")
.replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]")
.replace(/(password|secret|token|api[-_]?key)=\S+/gi, "$1=[REDACTED]");
}