Track HiveGrid Cloud planning reference

This commit is contained in:
david committed 2026-06-26 20:48:01 +02:00
1 parent b3d5ea6764
commit e341c5938a
5784 files changed
+1104929 -3

No files matched your search

@@ -0,0 +1,398 @@
// @vitest-environment node
import { describe, expect, it } from "vitest";
import EventUtils from "./EventUtils";
import type { TFunction } from "i18next";
function createTranslationSpy() {
const calls: Array<{ key: string; values: Record<string, unknown> }> = [];
const t = ((key: string, values: Record<string, unknown>) => {
calls.push({ key, values });
return `translated:${key}`;
}) as TFunction;
return { calls, t };
}
function stripDefaultValues(calls: Array<{ key: string; values: Record<string, unknown> }>) {
return calls.map(({ key, values }) => {
const { defaultValue: _defaultValue, ...rest } = values;
return { key, values: rest };
});
}
describe("EventUtils user preference descriptions", () => {
it("describes locale preference updates", () => {
expect(
EventUtils.getDescription("user.preferences.updated", {
old: { locale: "en" },
new: { locale: "de" },
user: { id: "user-1", email: "user@example.com" },
})
).toBe("user@example.com updated their language: en -> de");
});
it("translates locale preference updates when a translator is provided", () => {
const { calls, t } = createTranslationSpy();
expect(
EventUtils.getDescription(
"user.preferences.updated",
{
old: { locale: "en" },
new: { locale: "de" },
user: { id: "user-1", email: "user@example.com" },
},
t
)
).toBe("translated:events.descriptions.userPreferences.localeUpdated");
expect(stripDefaultValues(calls)).toEqual([
{
key: "shared.locales.en",
values: {},
},
{
key: "shared.locales.de",
values: {},
},
{
key: "events.descriptions.userPreferences.localeUpdated",
values: {
email: "user@example.com",
newLocale: "translated:shared.locales.de",
oldLocale: "translated:shared.locales.en",
},
},
]);
});
it("describes light/dark mode preference updates", () => {
expect(
EventUtils.getDescription("user.preferences.updated", {
old: { lightOrDarkMode: "light" },
new: { lightOrDarkMode: "dark" },
user: { id: "user-1", email: "user@example.com" },
})
).toBe("user@example.com updated their theme mode: light -> dark");
});
it("translates theme preference updates with light as the default mode", () => {
const { calls, t } = createTranslationSpy();
expect(
EventUtils.getDescription(
"user.preferences.updated",
{
old: {},
new: { lightOrDarkMode: "dark" },
user: { id: "user-1", email: "user@example.com" },
},
t
)
).toBe("translated:events.descriptions.userPreferences.themeUpdated");
expect(stripDefaultValues(calls)).toEqual([
{
key: "shared.light",
values: {},
},
{
key: "shared.dark",
values: {},
},
{
key: "events.descriptions.userPreferences.themeUpdated",
values: {
email: "user@example.com",
newTheme: "translated:shared.dark",
oldTheme: "translated:shared.light",
},
},
]);
});
it("translates generic preference updates", () => {
const { calls, t } = createTranslationSpy();
expect(
EventUtils.getDescription(
"user.preferences.updated",
{
old: {},
new: {},
user: { id: "user-1", email: "user@example.com" },
},
t
)
).toBe("translated:events.descriptions.userPreferences.updated");
expect(stripDefaultValues(calls)).toEqual([
{
key: "events.descriptions.userPreferences.updated",
values: {
email: "user@example.com",
},
},
]);
});
});
describe("EventUtils translated event descriptions", () => {
it("passes readable default values to translated event descriptions", () => {
const { calls, t } = createTranslationSpy();
EventUtils.getDescription(
"account.created",
{
tenant: { id: "tenant-1", name: "Acme" },
},
t
);
expect(calls).toEqual([
{
key: "events.descriptions.account.created",
values: {
defaultValue: "Account created: Acme",
tenant: "Acme",
},
},
]);
});
it("translates unmapped event names with the raw name as fallback", () => {
const { calls, t } = createTranslationSpy();
expect(EventUtils.parseName("provider.webhook.delivered", t)).toBe("translated:events.names.unmapped");
expect(EventUtils.parseName("provider.webhook.delivered")).toBe("provider.webhook.delivered");
expect(calls).toEqual([
{
key: "events.names.unmapped",
values: {
defaultValue: "provider.webhook.delivered",
name: "provider.webhook.delivered",
},
},
]);
});
it("recomputes persisted descriptions with the active translator", () => {
const { calls, t } = createTranslationSpy();
expect(
EventUtils.parseDescription(
{
id: "event-1",
tenantId: "tenant-1",
userId: "user-1",
name: "account.created",
data: JSON.stringify({ tenant: { id: "tenant-1", name: "Acme" } }),
description: "Account created: Acme",
createdAt: new Date("2026-05-08T10:00:00.000Z"),
},
t
)
).toBe("translated:events.descriptions.account.created");
expect(stripDefaultValues(calls)).toEqual([
{
key: "events.descriptions.account.created",
values: {
tenant: "Acme",
},
},
]);
});
it("falls back to persisted descriptions when event payloads cannot be parsed", () => {
const { t } = createTranslationSpy();
expect(
EventUtils.parseDescription(
{
id: "event-1",
tenantId: "tenant-1",
userId: "user-1",
name: "account.created",
data: "{",
description: "Persisted fallback",
createdAt: new Date("2026-05-08T10:00:00.000Z"),
},
t
)
).toBe("Persisted fallback");
});
it("uses the unknown event translation key when an unmapped payload has no persisted description", () => {
const { calls, t } = createTranslationSpy();
expect(
EventUtils.parseDescription(
{
id: "event-1",
tenantId: "tenant-1",
userId: "user-1",
name: "provider.webhook.delivered",
data: "{",
description: null,
createdAt: new Date("2026-05-08T10:00:00.000Z"),
},
t
)
).toBe("translated:events.descriptions.unknownWithName");
expect(calls).toEqual([
{
key: "events.descriptions.unknownWithName",
values: {
defaultValue: "Unknown event: provider.webhook.delivered",
name: "provider.webhook.delivered",
},
},
]);
expect(
EventUtils.parseDescription({
id: "event-1",
tenantId: "tenant-1",
userId: "user-1",
name: "provider.webhook.delivered",
data: "{",
description: null,
createdAt: new Date("2026-05-08T10:00:00.000Z"),
})
).toBe("Unknown event: provider.webhook.delivered");
});
it("translates account descriptions", () => {
const { calls, t } = createTranslationSpy();
expect(
EventUtils.getDescription(
"account.created",
{
tenant: { id: "tenant-1", name: "Acme" },
},
t
)
).toBe("translated:events.descriptions.account.created");
expect(stripDefaultValues(calls)).toEqual([
{
key: "events.descriptions.account.created",
values: {
tenant: "Acme",
},
},
]);
});
it("translates new-user invitation prefixes before composing accepted invitation descriptions", () => {
const calls: Array<{ key: string; values: Record<string, unknown> }> = [];
const t = ((key: string, values: Record<string, unknown>) => {
calls.push({ key, values });
if (key === "events.descriptions.memberInvitation.newUserPrefix") return "translated-prefix ";
return `translated:${key}`;
}) as TFunction;
expect(
EventUtils.getDescription(
"member.invitation.accepted",
{
newUser: true,
user: { id: "user-1", email: "ada@example.com" },
tenant: { id: "tenant-1", name: "Acme" },
},
t
)
).toBe("translated:events.descriptions.memberInvitation.accepted");
expect(stripDefaultValues(calls)).toEqual([
{
key: "events.descriptions.memberInvitation.newUserPrefix",
values: {},
},
{
key: "events.descriptions.memberInvitation.accepted",
values: {
email: "ada@example.com",
prefix: "translated-prefix ",
tenant: "Acme",
},
},
]);
});
it("translates row descriptions with actor values", () => {
const { calls, t } = createTranslationSpy();
expect(
EventUtils.getDescription(
"row.created",
{
entity: { id: "entity-1", name: "Contact" },
title: "Ada Lovelace",
user: { id: "user-1", email: "ada@example.com" },
},
t
)
).toBe("translated:events.descriptions.row.created");
expect(stripDefaultValues(calls)).toEqual([
{
key: "events.descriptions.row.created",
values: {
actor: "ada@example.com",
entity: "Contact",
title: "Ada Lovelace",
},
},
]);
});
it("translates row task actors and status fragments", () => {
const calls: Array<{ key: string; values: Record<string, unknown> }> = [];
const t = ((key: string, values: Record<string, unknown>) => {
calls.push({ key, values });
if (key === "events.actors.apiKey") return `api-key:${values.alias}`;
if (key === "events.descriptions.rowTasks.changes.completedAt") return `completed:${values.date}`;
return `translated:${key}`;
}) as TFunction;
expect(
EventUtils.getDescription(
"row.tasks.updated",
{
rowId: "row-1",
new: { name: "Follow up", completedAt: "2026-05-27T01:00:00.000Z" },
apiKey: { id: "key-1", alias: "Zapier" },
},
t,
{ dateTime: () => "May 27, 2026, 3:00 AM" }
)
).toBe("translated:events.descriptions.rowTasks.updated");
expect(stripDefaultValues(calls)).toEqual([
{
key: "events.descriptions.rowTasks.changes.completedAt",
values: {
date: "May 27, 2026, 3:00 AM",
},
},
{
key: "events.actors.apiKey",
values: {
alias: "Zapier",
},
},
{
key: "events.descriptions.rowTasks.updated",
values: {
actor: "api-key:Zapier",
change: "completed:May 27, 2026, 3:00 AM",
rowId: "row-1",
task: "Follow up",
},
},
]);
});
});
@@ -0,0 +1,455 @@
import { AccountCreatedDto } from "../dtos/AccountCreatedDto";
import { AccountDeletedDto } from "../dtos/AccountDeletedDto";
import { AccountUpdatedDto } from "../dtos/AccountUpdatedDto";
import { ApiKeyCreatedDto } from "../dtos/ApiKeyCreatedDto";
import { ApiKeyDeletedDto } from "../dtos/ApiKeyDeletedDto";
import { ApiKeyUpdatedDto } from "../dtos/ApiKeyUpdatedDto";
import { EmailReceivedDto } from "../dtos/EmailReceivedDto";
import { MemberDeletedDto } from "../dtos/MemberDeletedDto";
import { MemberInvitationAcceptedDto } from "../dtos/MemberInvitationAcceptedDto";
import { MemberInvitationCreatedDto } from "../dtos/MemberInvitationCreatedDto";
import { RoleAssignedDto } from "../dtos/RoleAssignedDto";
import { RoleUnassignedDto } from "../dtos/RoleUnassignedDto";
import { RowCreatedDto } from "../dtos/RowCreatedDto";
import { RowDeletedDto } from "../dtos/RowDeletedDto";
import { RowSharedDto } from "../dtos/RowSharedDto";
import { RowUpdatedDto } from "../dtos/RowUpdatedDto";
import { SubscriptionCancelledDto } from "../dtos/SubscriptionCancelledDto";
import { SubscriptionEndedDto } from "../dtos/SubscriptionEndedDto";
import { SubscriptionSubscribedDto } from "../dtos/SubscriptionSubscribedDto";
import { SubscriptionUpgradedDto } from "../dtos/SubscriptionUpgradedDto";
import { UserPasswordUpdatedDto } from "../dtos/UserPasswordUpdatedDto";
import { UserPreferencesUpdatedDto } from "../dtos/UserPreferencesUpdatedDto";
import { UserProfileDeletedDto } from "../dtos/UserProfileDeletedDto";
import { UserProfileUpdatedDto } from "../dtos/UserProfileUpdatedDto";
import { ApplicationEvent, getApplicationEventNameKey, isApplicationEvent } from "../types/ApplicationEvent";
import { Event } from "@toolctrl/db/prisma-browser";
import { RowTasksCreatedDto } from "../dtos/RowTasksCreatedDto";
import { RowTasksUpdatedDto } from "../dtos/RowTasksUpdatedDto";
import { RowTasksDeletedDto } from "../dtos/RowTasksDeletedDto";
import { RowCommentsCreatedDto } from "../dtos/RowCommentsCreatedDto";
import { RowCommentsDeletedDto } from "../dtos/RowCommentsDeletedDto";
import { RowCommentsReactedDto } from "../dtos/RowCommentsReactedDto";
import { OnboardingStartedDto } from "../dtos/OnboardingStartedDto";
import { OnboardingDismissedDto } from "../dtos/OnboardingDismissedDto";
import { OnboardingCompletedDto } from "../dtos/OnboardingCompletedDto";
import { SubscriptionDowngradedDto } from "../dtos/SubscriptionDowngradedDto";
import type { TFunction } from "i18next";
type EventDescriptionFormatters = {
dateTime?: (value: Date | number | string, options?: Intl.DateTimeFormatOptions) => string;
};
function parseDescription(event: Event, t?: TFunction, formatters?: EventDescriptionFormatters) {
if (event.description && !t) {
return event.description;
}
try {
const data = JSON.parse(event.data);
return getDescription(event.name as ApplicationEvent, data, t, formatters);
} catch {
if (event.description) {
return event.description;
}
return translateEventDescription(t, "events.descriptions.unknownWithName", `Unknown event: ${event.name}`, { name: event.name });
}
}
function parseName(eventName: string, t?: TFunction) {
if (!isApplicationEvent(eventName)) {
return translateEventDescription(t, "events.names.unmapped", eventName, { name: eventName });
}
return t ? t(getApplicationEventNameKey(eventName)) : eventName;
}
function translateEventDescription(
t: TFunction | undefined,
key: string,
defaultValue: string,
values: Record<string, string | number | boolean | null | undefined> = {}
) {
return t ? t(key, { defaultValue, ...values }) : defaultValue;
}
function translateEventValue(t: TFunction | undefined, key: string, defaultValue: string) {
return t ? t(key, { defaultValue }) : defaultValue;
}
function getDescription(event: ApplicationEvent, data: any, t?: TFunction, formatters?: EventDescriptionFormatters) {
if (!isApplicationEvent(event)) {
return translateEventDescription(t, "events.descriptions.unknown", "Unknown event");
}
try {
switch (event) {
case "user.profile.updated": {
const payload = data as UserProfileUpdatedDto;
return translateEventDescription(t, "events.descriptions.userProfile.updated", `${payload.email} updated their profile`, { email: payload.email });
}
case "user.profile.deleted": {
const payload = data as UserProfileDeletedDto;
return translateEventDescription(t, "events.descriptions.userProfile.deleted", `${payload.email} deleted their profile`, { email: payload.email });
}
case "user.password.updated": {
const payload = data as UserPasswordUpdatedDto;
if (payload.fromUser) {
return translateEventDescription(
t,
"events.descriptions.userPassword.updatedByUser",
`${payload.fromUser.email} updated ${payload.user.email}'s password`,
{ fromEmail: payload.fromUser.email, email: payload.user.email }
);
}
return translateEventDescription(t, "events.descriptions.userPassword.updated", `${payload.user.email} updated their password`, { email: payload.user.email });
}
case "user.mfa.totp.enrollment.started": {
return translateEventDescription(t, "events.descriptions.userMfa.enrollmentStarted", `${data.user.email} started authenticator enrollment`, { email: data.user.email });
}
case "user.mfa.totp.enabled": {
return translateEventDescription(t, "events.descriptions.userMfa.enabled", `${data.user.email} enabled authenticator MFA`, { email: data.user.email });
}
case "user.mfa.totp.disabled": {
return translateEventDescription(t, "events.descriptions.userMfa.disabled", `${data.user.email} disabled authenticator MFA`, { email: data.user.email });
}
case "user.preferences.updated": {
const payload = data as UserPreferencesUpdatedDto;
if (payload.old.locale !== undefined || payload.new.locale !== undefined) {
const oldLocale = payload.old.locale ?? "";
const newLocale = payload.new.locale ?? "";
const oldLocaleLabel = oldLocale ? translateEventValue(t, `shared.locales.${oldLocale}`, oldLocale) : "";
const newLocaleLabel = newLocale ? translateEventValue(t, `shared.locales.${newLocale}`, newLocale) : "";
return translateEventDescription(
t,
"events.descriptions.userPreferences.localeUpdated",
`${payload.user.email} updated their language: ${oldLocale} -> ${newLocale}`,
{
email: payload.user.email,
oldLocale: oldLocaleLabel,
newLocale: newLocaleLabel,
}
);
}
if (payload.old.lightOrDarkMode !== undefined || payload.new.lightOrDarkMode !== undefined) {
const oldTheme = payload.old.lightOrDarkMode ?? "light";
const newTheme = payload.new.lightOrDarkMode ?? "light";
const oldThemeLabel = translateEventValue(t, `shared.${oldTheme}`, oldTheme);
const newThemeLabel = translateEventValue(t, `shared.${newTheme}`, newTheme);
return translateEventDescription(
t,
"events.descriptions.userPreferences.themeUpdated",
`${payload.user.email} updated their theme mode: ${oldTheme} -> ${newTheme}`,
{
email: payload.user.email,
oldTheme: oldThemeLabel,
newTheme: newThemeLabel,
}
);
}
return translateEventDescription(t, "events.descriptions.userPreferences.updated", `${payload.user.email} updated their preferences`, {
email: payload.user.email,
});
}
case "account.created": {
const payload = data as AccountCreatedDto;
return translateEventDescription(t, "events.descriptions.account.created", `Account created: ${payload.tenant.name}`, { tenant: payload.tenant.name });
}
case "account.updated": {
const payload = data as AccountUpdatedDto;
return translateEventDescription(
t,
"events.descriptions.account.updated",
`${payload.user.email} updated account: ${payload.old.name} (/${payload.old.slug}) -> ${payload.new.name} (/${payload.new.slug})`,
{ email: payload.user.email, oldName: payload.old.name, oldSlug: payload.old.slug, newName: payload.new.name, newSlug: payload.new.slug }
);
}
case "account.deleted": {
const payload = data as AccountDeletedDto;
let subscription = "";
if (payload.subscription) {
subscription = `, ${payload.subscription.product.title} - $${payload.subscription.price.amount}`;
}
return translateEventDescription(t, "events.descriptions.account.deleted", `${payload.user.email} deleted the account '${payload.tenant.name}'${subscription}.`, {
email: payload.user.email,
tenant: payload.tenant.name,
subscription,
});
}
case "member.invitation.created": {
const payload = data as MemberInvitationCreatedDto;
return translateEventDescription(t, "events.descriptions.memberInvitation.created", `${payload.fromUser.email} invited ${payload.user.email} to ${payload.tenant.name}`, {
fromEmail: payload.fromUser.email,
email: payload.user.email,
tenant: payload.tenant.name,
});
}
case "member.invitation.accepted": {
const payload = data as MemberInvitationAcceptedDto;
const defaultPrefix = payload.newUser ? "(New user) " : "";
const prefix = payload.newUser ? translateEventDescription(t, "events.descriptions.memberInvitation.newUserPrefix", defaultPrefix) : "";
if (payload.fromUser) {
return translateEventDescription(
t,
"events.descriptions.memberInvitation.acceptedFromUser",
`${defaultPrefix}${payload.user.email} accepted the invitation to ${payload.tenant.name} from user ${payload.fromUser.email}`,
{ prefix, email: payload.user.email, tenant: payload.tenant.name, fromEmail: payload.fromUser.email }
);
}
return translateEventDescription(t, "events.descriptions.memberInvitation.accepted", `${defaultPrefix}${payload.user.email} accepted the invitation to ${payload.tenant.name}`, {
prefix,
email: payload.user.email,
tenant: payload.tenant.name,
});
}
case "member.deleted": {
const payload = data as MemberDeletedDto;
return translateEventDescription(t, "events.descriptions.member.deleted", `${payload.fromUser.email} deleted ${payload.user.email} from ${payload.tenant.name}`, {
fromEmail: payload.fromUser.email,
email: payload.user.email,
tenant: payload.tenant.name,
});
}
case "role.assigned": {
const payload = data as RoleAssignedDto;
return translateEventDescription(t, "events.descriptions.role.assigned", `${payload.fromUser.email} assigned the role "${payload.role.name}" to ${payload.toUser.email}`, {
fromEmail: payload.fromUser.email,
role: payload.role.name,
email: payload.toUser.email,
});
}
case "role.unassigned": {
const payload = data as RoleUnassignedDto;
return translateEventDescription(t, "events.descriptions.role.unassigned", `${payload.fromUser.email} unassigned the role "${payload.role.name}" from ${payload.toUser.email}`, {
fromEmail: payload.fromUser.email,
role: payload.role.name,
email: payload.toUser.email,
});
}
case "subscription.subscribed": {
const payload = data as SubscriptionSubscribedDto;
if (payload.user) {
return translateEventDescription(t, "events.descriptions.subscription.subscribedByUser", `${payload.user.email} subscribed ${payload.tenant.name} to ${payload.subscription.product.title}`, {
email: payload.user.email,
tenant: payload.tenant.name,
product: payload.subscription.product.title,
});
}
return translateEventDescription(t, "events.descriptions.subscription.subscribed", `${payload.tenant.name} subscribed to ${payload.subscription.product.title}`, {
tenant: payload.tenant.name,
product: payload.subscription.product.title,
});
}
case "subscription.upgraded": {
const payload = data as SubscriptionUpgradedDto;
const product = payload.subscription?.product.title ?? "";
if (payload.user) {
return translateEventDescription(t, "events.descriptions.subscription.upgradedByUser", `Subscription upgraded: ${payload.tenant.name} (${product}), by ${payload.user.email}`, {
tenant: payload.tenant.name,
product,
email: payload.user.email,
});
}
return translateEventDescription(t, "events.descriptions.subscription.upgraded", `Subscription upgraded: ${payload.tenant.name} (${product})`, { tenant: payload.tenant.name, product });
}
case "subscription.downgraded": {
const payload = data as SubscriptionDowngradedDto;
const product = payload.subscription?.product.title ?? "";
if (payload.user) {
return translateEventDescription(t, "events.descriptions.subscription.downgradedByUser", `Subscription downgraded: ${payload.tenant.name} (${product}), by ${payload.user.email}`, {
tenant: payload.tenant.name,
product,
email: payload.user.email,
});
}
return translateEventDescription(t, "events.descriptions.subscription.downgraded", `Subscription downgraded: ${payload.tenant.name} (${product})`, { tenant: payload.tenant.name, product });
}
case "subscription.cancelled": {
const payload = data as SubscriptionCancelledDto;
const product = payload.subscription?.product.title ?? "";
if (payload.user) {
return translateEventDescription(t, "events.descriptions.subscription.cancelledByUser", `Subscription cancelled: ${payload.tenant.name} (${product}), by ${payload.user.email}`, {
tenant: payload.tenant.name,
product,
email: payload.user.email,
});
}
return translateEventDescription(t, "events.descriptions.subscription.cancelled", `Subscription cancelled: ${payload.tenant.name} (${product})`, { tenant: payload.tenant.name, product });
}
case "subscription.ended": {
const payload = data as SubscriptionEndedDto;
const product = payload.subscription?.product.title ?? "";
return translateEventDescription(t, "events.descriptions.subscription.ended", `Subscription ended: ${payload.tenant.name} (${product})`, { tenant: payload.tenant.name, product });
}
case "api_key.created": {
const payload = data as ApiKeyCreatedDto;
return translateEventDescription(t, "events.descriptions.apiKey.created", `${payload.user.email} created API key: ${payload.alias}`, { email: payload.user.email, alias: payload.alias });
}
case "api_key.updated": {
const payload = data as ApiKeyUpdatedDto;
return translateEventDescription(t, "events.descriptions.apiKey.updated", `${payload.user.email} updated API key: ${payload.old.alias} -> ${payload.new.alias}`, {
email: payload.user.email,
oldAlias: payload.old.alias,
newAlias: payload.new.alias,
});
}
case "api_key.deleted": {
const payload = data as ApiKeyDeletedDto;
return translateEventDescription(t, "events.descriptions.apiKey.deleted", `${payload.user.email} deleted API key: ${payload.alias}`, { email: payload.user.email, alias: payload.alias });
}
case "email.received": {
const payload = data as EmailReceivedDto;
return translateEventDescription(t, "events.descriptions.email.received", `New email from ${payload.fromEmail}: ${payload.subject}`, {
fromEmail: payload.fromEmail,
subject: payload.subject,
});
}
case "row.created": {
const payload = data as RowCreatedDto;
const actor = getUserOrApiKey(payload, t);
return translateEventDescription(t, "events.descriptions.row.created", `New ${payload.entity.name}: ${payload.title}, by ${actor}`, {
entity: payload.entity.name,
title: payload.title,
actor,
});
}
case "row.updated": {
const payload = data as RowUpdatedDto;
const actor = getUserOrApiKey(payload, t);
return translateEventDescription(t, "events.descriptions.row.updated", `Updated ${payload.entity.name}: ${payload.title}, by ${actor}`, {
entity: payload.entity.name,
title: payload.title,
actor,
});
}
case "row.deleted": {
const payload = data as RowDeletedDto;
const actor = getUserOrApiKey(payload, t);
return translateEventDescription(t, "events.descriptions.row.deleted", `Deleted ${payload.entity.name}: ${payload.title}, by ${actor}`, {
entity: payload.entity.name,
title: payload.title,
actor,
});
}
case "row.shared": {
const payload = data as RowSharedDto;
const actor = getUserOrApiKey(payload, t);
return translateEventDescription(
t,
"events.descriptions.row.shared",
`${payload.entity.name}: ${payload.title} shared with ${payload.type} "${payload.to}" (${payload.access}) by ${actor}`,
{ entity: payload.entity.name, title: payload.title, type: payload.type, to: payload.to, access: payload.access, actor }
);
}
case "row.tasks.created": {
const payload = data as RowTasksCreatedDto;
const actor = getUserOrApiKey(payload, t);
return translateEventDescription(t, "events.descriptions.rowTasks.created", `Row ${payload.rowId} task created '${payload.task.name}' by ${actor}`, {
rowId: payload.rowId,
task: payload.task.name,
actor,
});
}
case "row.tasks.updated": {
const payload = data as RowTasksUpdatedDto;
let change = "";
if (payload.new.completedAt) {
const completedAt = formatters?.dateTime ? formatters.dateTime(payload.new.completedAt) : String(payload.new.completedAt);
change = translateEventDescription(
t,
"events.descriptions.rowTasks.changes.completedAt",
`completed at ${completedAt}`,
{ date: completedAt }
);
} else {
change = translateEventDescription(t, "events.descriptions.rowTasks.changes.incomplete", "set as incomplete");
}
const actor = getUserOrApiKey(payload, t);
return translateEventDescription(t, "events.descriptions.rowTasks.updated", `Row ${payload.rowId} task updated '${payload.new.name}', ${change}, by ${actor}`, {
rowId: payload.rowId,
task: payload.new.name,
change,
actor,
});
}
case "row.tasks.deleted": {
const payload = data as RowTasksDeletedDto;
const actor = getUserOrApiKey(payload, t);
return translateEventDescription(t, "events.descriptions.rowTasks.deleted", `Row ${payload.rowId} task deleted '${payload.task.name}' by ${actor}`, {
rowId: payload.rowId,
task: payload.task.name,
actor,
});
}
case "row.comments.created": {
const payload = data as RowCommentsCreatedDto;
const actor = payload.user ? payload.user.email : "";
return translateEventDescription(t, "events.descriptions.rowComments.created", `Row ${payload.rowId} commented '${payload.comment.text}' by ${actor}`, {
rowId: payload.rowId,
comment: payload.comment.text,
actor,
});
}
case "row.comments.deleted": {
const payload = data as RowCommentsDeletedDto;
const actor = payload.user ? payload.user.email : "";
return translateEventDescription(t, "events.descriptions.rowComments.deleted", `Row ${payload.rowId} comment deleted '${payload.comment.text}' by ${actor}`, {
rowId: payload.rowId,
comment: payload.comment.text,
actor,
});
}
case "row.comments.reacted": {
const payload = data as RowCommentsReactedDto;
const actor = payload.user ? payload.user.email : "";
return translateEventDescription(t, "events.descriptions.rowComments.reacted", `Row ${payload.rowId} comment reaction (${payload.reaction}) '${payload.comment.text}' by ${actor}`, {
rowId: payload.rowId,
reaction: payload.reaction,
comment: payload.comment.text,
actor,
});
}
case "onboarding.started": {
const payload = data as OnboardingStartedDto;
return translateEventDescription(t, "events.descriptions.onboarding.started", `Onboarding started by ${payload.user.email}: ${payload.onboarding.title}`, {
email: payload.user.email,
title: payload.onboarding.title,
});
}
case "onboarding.dismissed": {
const payload = data as OnboardingDismissedDto;
return translateEventDescription(t, "events.descriptions.onboarding.dismissed", `Onboarding dismissed by ${payload.user.email}: ${payload.onboarding.title}`, {
email: payload.user.email,
title: payload.onboarding.title,
});
}
case "onboarding.completed": {
const payload = data as OnboardingCompletedDto;
return translateEventDescription(t, "events.descriptions.onboarding.completed", `Onboarding completed by ${payload.user.email}: ${payload.onboarding.title}`, {
email: payload.user.email,
title: payload.onboarding.title,
});
}
default:
return assertNever(event);
}
} catch {
return parseName(event, t);
}
}
function assertNever(x: never): never {
throw new Error("Unexpected event: " + x);
}
function getUserOrApiKey(item: { user?: { id: string; email: string } | null; apiKey?: { id: string; alias: string } | null }, t?: TFunction) {
if (item.user) {
return item.user.email;
} else if (item.apiKey) {
return translateEventDescription(t, "events.actors.apiKey", "API Key {{alias}}", { alias: item.apiKey.alias });
}
return "";
}
export default {
parseName,
parseDescription,
getDescription,
};