@paroicms/server/dist/admin-backend/event-log/event-log.service.js

The ParoiCMS server

import { type } from "arktype";
export function recordEvent(siteContext, entry) {
    recordEventInternal(siteContext, entry).catch((error) => {
        siteContext.logger.error("Failed to record event (uncaught)", error);
    });
}
async function recordEventInternal(siteContext, entry) {
    try {
        await siteContext.cn("PaEventLog").insert({
            eventType: entry.eventType,
            actorId: entry.actorId,
            targetType: entry.targetType,
            targetId: entry.targetId,
            eventData: entry.eventData ? JSON.stringify(entry.eventData) : undefined,
        });
    }
    catch (error) {
        siteContext.logger.error("Failed to record event", error);
    }
}
const DocumentCreatedEventDataAT = type({
    nodeId: "string",
    typeName: "string",
    title: "string",
    language: "string",
    "+": "reject",
});
const DocumentUpdatedEventDataAT = type({
    nodeId: "string",
    typeName: "string",
    "title?": "string|undefined",
    language: "string",
    changedFields: "string[]",
    "+": "reject",
});
const DocumentDeletedEventDataAT = type({
    nodeId: "string",
    typeName: "string",
    title: "string",
    language: "string",
    "+": "reject",
});
const PartMovedEventDataAT = type({
    partNodeId: "string",
    documentNodeId: "string",
    typeName: "string",
    newParentNodeId: "string",
    newListName: "string",
    "+": "reject",
});
const AccountCreatedEventDataAT = type({
    accountId: "string",
    email: "string",
    "name?": "string|undefined",
    "+": "reject",
});
const AccountUpdatedEventDataAT = type({
    accountId: "string",
    email: "string",
    changedFields: "string[]",
    "+": "reject",
});
const AccountDeletedEventDataAT = type({
    accountId: "string",
    email: "string",
    "name?": "string|undefined",
    "+": "reject",
});
const AccountLoginEventDataAT = type({
    accountId: "string",
    email: "string",
    loginMethod: '"local"|"localDev"|"platform"|"platformAdmin"',
    "+": "reject",
});
const AccountLoginMethodChangedEventDataAT = type({
    accountId: "string",
    email: "string",
    oldLoginMethod: '"local"|"localDev"|"platform"|"platformAdmin"',
    newLoginMethod: '"local"|"localDev"|"platform"|"platformAdmin"',
    "+": "reject",
});
const AccountDeactivatedEventDataAT = type({
    accountId: "string",
    email: "string",
    reason: "string",
    "+": "reject",
});
const MediaCreatedEventDataAT = type({
    mediaId: "string",
    filename: "string",
    mimeType: "string",
    sizeBytes: "number",
    "+": "reject",
});
const MediaUpdatedEventDataAT = type({
    mediaId: "string",
    changedFields: "string[]",
    "+": "reject",
});
const MediaDeletedEventDataAT = type({
    mediaId: "string",
    filename: "string",
    "+": "reject",
});
const EventLogRowAT = type({
    id: "number",
    eventType: "string",
    actorId: "number|null",
    targetType: "string",
    targetId: "string",
    eventData: "string|null",
    createdAt: "Date|string|number",
    "+": "reject",
}).pipe((r) => ({
    eventType: r.eventType,
    actorId: r.actorId !== null ? String(r.actorId) : undefined,
    targetType: r.targetType,
    targetId: r.targetId,
    eventData: r.eventData ? JSON.parse(r.eventData) : undefined,
}));
export async function getEventLog(siteContext, filters = {}) {
    let query = siteContext
        .cn("PaEventLog")
        .select("id", "eventType", "actorId", "targetType", "targetId", "eventData", "createdAt")
        .orderBy("createdAt", "desc");
    if (filters.eventType) {
        query = query.where("eventType", filters.eventType);
    }
    if (filters.actorId) {
        query = query.where("actorId", filters.actorId);
    }
    if (filters.targetType) {
        query = query.where("targetType", filters.targetType);
    }
    if (filters.targetId) {
        query = query.where("targetId", filters.targetId);
    }
    if (filters.limit) {
        query = query.limit(filters.limit);
    }
    const rows = await query;
    return rows.map((row) => {
        const validated = EventLogRowAT.assert(row);
        switch (validated.eventType) {
            case "document.create":
                if (validated.targetType !== "document") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: DocumentCreatedEventDataAT.assert(validated.eventData),
                };
            case "document.update":
                if (validated.targetType !== "document") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: DocumentUpdatedEventDataAT.assert(validated.eventData),
                };
            case "document.delete":
                if (validated.targetType !== "document") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: DocumentDeletedEventDataAT.assert(validated.eventData),
                };
            case "part.move":
                if (validated.targetType !== "documentNode") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: PartMovedEventDataAT.assert(validated.eventData),
                };
            case "account.create":
                if (validated.targetType !== "account") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: AccountCreatedEventDataAT.assert(validated.eventData),
                };
            case "account.update":
                if (validated.targetType !== "account") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: AccountUpdatedEventDataAT.assert(validated.eventData),
                };
            case "account.delete":
                if (validated.targetType !== "account") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: AccountDeletedEventDataAT.assert(validated.eventData),
                };
            case "account.login":
                if (validated.targetType !== "account") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: AccountLoginEventDataAT.assert(validated.eventData),
                };
            case "account.loginMethodChanged":
                if (validated.targetType !== "account") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: AccountLoginMethodChangedEventDataAT.assert(validated.eventData),
                };
            case "account.deactivated":
                if (validated.targetType !== "account") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: AccountDeactivatedEventDataAT.assert(validated.eventData),
                };
            case "media.create":
                if (validated.targetType !== "media") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: MediaCreatedEventDataAT.assert(validated.eventData),
                };
            case "media.update":
                if (validated.targetType !== "media") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: MediaUpdatedEventDataAT.assert(validated.eventData),
                };
            case "media.delete":
                if (validated.targetType !== "media") {
                    throw new Error(`invalid target type "${validated.targetType}"`);
                }
                return {
                    eventType: validated.eventType,
                    actorId: validated.actorId,
                    targetType: validated.targetType,
                    targetId: validated.targetId,
                    eventData: MediaDeletedEventDataAT.assert(validated.eventData),
                };
            default:
                throw new Error(`Unknown event type: ${validated.eventType}`);
        }
    });
}
//# sourceMappingURL=event-log.service.js.map