volleyballsimtypes 0.0.478 → 0.0.479

package/dist/esm/src/service/notification/notification.test.js

@@ -0,0 +1,126 @@
+import { describe, it, expect } from '@jest/globals';
+import { NOTIFICATION_TYPES, NOTIFICATION_LOCALES } from './notification-type';
+import { NOTIFICATION_REGISTRY } from './registry';
+import { NOTIFICATION_CATALOG } from './catalog';
+import { renderPush, notificationPath, interpolate, translateNotification } from './render';
+function readNested(node, dotKey) {
+    let current = node;
+    for (const part of dotKey.split('.')) {
+        if (typeof current !== 'object' || current == null)
+            return undefined;
+        current = current[part];
+    }
+    return typeof current === 'string' ? current : undefined;
+}
+function placeholders(value) {
+    return (value.match(/\{\{(\w+)\}\}/g) ?? []).sort((a, b) => a.localeCompare(b));
+}
+function flattenStrings(node, prefix = '') {
+    const out = [];
+    if (typeof node !== 'object' || node == null)
+        return out;
+    for (const [key, value] of Object.entries(node)) {
+        if (typeof value === 'string')
+            out.push([prefix + key, value]);
+        else if (typeof value === 'object' && value != null)
+            out.push(...flattenStrings(value, `${prefix}${key}.`));
+    }
+    return out;
+}
+describe('notification registry + catalog completeness', () => {
+    it('has exactly one descriptor per declared type', () => {
+        expect(Object.keys(NOTIFICATION_REGISTRY).sort((a, b) => a.localeCompare(b)))
+            .toEqual([...NOTIFICATION_TYPES].sort((a, b) => a.localeCompare(b)));
+    });
+    it('resolves every descriptor catalog key to a non-empty string in all 7 locales', () => {
+        for (const type of NOTIFICATION_TYPES) {
+            for (const key of NOTIFICATION_REGISTRY[type].catalogKeys) {
+                for (const locale of NOTIFICATION_LOCALES) {
+                    const value = readNested(NOTIFICATION_CATALOG[locale], key);
+                    expect([locale, key, (value ?? '').length > 0]).toEqual([locale, key, true]);
+                }
+            }
+        }
+    });
+    it('ships an identical key set across all 7 locales (no drift)', () => {
+        const enKeys = flattenStrings(NOTIFICATION_CATALOG.en).map(([key]) => key).sort((a, b) => a.localeCompare(b));
+        for (const locale of NOTIFICATION_LOCALES) {
+            const keys = flattenStrings(NOTIFICATION_CATALOG[locale]).map(([key]) => key).sort((a, b) => a.localeCompare(b));
+            expect([locale, keys]).toEqual([locale, enKeys]);
+        }
+    });
+    it('keeps placeholders identical across locales', () => {
+        for (const [key, enValue] of flattenStrings(NOTIFICATION_CATALOG.en)) {
+            const expected = placeholders(enValue);
+            for (const locale of NOTIFICATION_LOCALES) {
+                const value = readNested(NOTIFICATION_CATALOG[locale], key);
+                if (value == null)
+                    continue;
+                expect([locale, key, placeholders(value)]).toEqual([locale, key, expected]);
+            }
+        }
+    });
+    it('contains no em or en dashes', () => {
+        for (const locale of NOTIFICATION_LOCALES) {
+            for (const [key, value] of flattenStrings(NOTIFICATION_CATALOG[locale])) {
+                expect([locale, key, value.includes('—') || value.includes('–')]).toEqual([locale, key, false]);
+            }
+        }
+    });
+});
+describe('renderPush', () => {
+    it('renders a localized MATCH_RESULT win with a named opponent', () => {
+        const payload = { matchId: 'm1', result: 'WIN', side: 'HOME', awayTeam: { name: 'Rivals' } };
+        const en = renderPush('MATCH_RESULT', payload, 'en');
+        expect(en?.title).toBe('Match result');
+        expect(en?.body).toBe('You won against Rivals');
+        expect(en?.data.path).toBe('/match/m1');
+        expect(renderPush('MATCH_RESULT', payload, 'es')?.body).toBe('Ganaste contra Rivals');
+    });
+    it('uses the unnamed variant and root path when the opponent is unknown', () => {
+        const en = renderPush('MATCH_RESULT', { result: 'LOSS' }, 'en');
+        expect(en?.body).toBe('You lost your match');
+        expect(en?.data.path).toBe('/');
+    });
+    it('interpolates the injured player name and links to the infirmary', () => {
+        const en = renderPush('INJURY', { playerNickname: 'Ace', teamId: 't1' }, 'en');
+        expect(en?.title).toBe('Player injured');
+        expect(en?.body).toContain('Ace');
+        expect(en?.data.path).toBe('/infirmary');
+    });
+    it('uses a generic subject when the injury payload has no player name', () => {
+        const en = renderPush('INJURY', { teamId: 't1' }, 'en');
+        expect(en?.body.startsWith('A player')).toBe(true);
+    });
+    it('returns undefined for in-app-only types (COMPENSATION)', () => {
+        expect(renderPush('COMPENSATION', { currency: 100 }, 'en')).toBeUndefined();
+    });
+    it('falls back to generic copy and root path for an unknown type', () => {
+        const en = renderPush('SOMETHING_NEW', {}, 'en');
+        expect(en?.title).toBe('World Aces');
+        expect(en?.body).toBe('You have a new notification.');
+        expect(en?.data.path).toBe('/');
+    });
+    it('serializes the payload into the FCM data block', () => {
+        const en = renderPush('GRANT_RECEIVED', { pullType: 'MYTHIC' }, 'en');
+        expect(en?.data.type).toBe('GRANT_RECEIVED');
+        expect(JSON.parse(en?.data.payload ?? '{}')).toEqual({ pullType: 'MYTHIC' });
+    });
+});
+describe('translateNotification + interpolate + notificationPath', () => {
+    it('falls back to English then to the raw key', () => {
+        expect(translateNotification('fr', 'promotion.title')).toBe('Promotion');
+        expect(translateNotification('en', 'does.not.exist')).toBe('does.not.exist');
+    });
+    it('replaces placeholders and drops unknown ones', () => {
+        expect(interpolate('Hi {{name}}!', { name: 'X' })).toBe('Hi X!');
+        expect(interpolate('Hi {{name}}!', {})).toBe('Hi !');
+    });
+    it('derives the deep-link path per type', () => {
+        expect(notificationPath('SEASON_END', { leagueId: 'l1' })).toBe('/league/l1');
+        expect(notificationPath('SEASON_END', {})).toBe('/league');
+        expect(notificationPath('PROMOTION', { teamId: 't1' })).toBe('/team/t1');
+        expect(notificationPath('GRANT_RECEIVED', {})).toBe('/recruit');
+        expect(notificationPath('COMPENSATION', {})).toBe('/');
+    });
+});

package/dist/esm/src/service/notification/payloads.d.ts

@@ -0,0 +1,34 @@
+export interface MatchResultTeam {
+    id?: string;
+    name?: string;
+}
+export interface MatchResultPayload {
+    matchId?: string;
+    homeTeam?: MatchResultTeam;
+    awayTeam?: MatchResultTeam;
+    result?: 'WIN' | 'LOSS';
+    side?: 'HOME' | 'AWAY';
+}
+export interface InjuryPayload {
+    playerId?: string;
+    playerName?: string;
+    playerNickname?: string;
+    teamId?: string;
+    matchId?: string;
+}
+export interface InjuryRecoveredPayload {
+    playerId?: string;
+    playerName?: string;
+    playerNickname?: string;
+    teamId?: string;
+}
+export interface SeasonEndPayload {
+    competitionId?: string;
+    leagueId?: string;
+    position?: number;
+}
+export interface PromotionPayload {
+    teamId?: string;
+    amount?: number;
+}
+export type NotificationPayload = MatchResultPayload | InjuryPayload | InjuryRecoveredPayload | SeasonEndPayload | PromotionPayload | Record<string, unknown>;

package/dist/esm/src/service/notification/payloads.js

@@ -0,0 +1,4 @@
+// Typed payload shapes per notification type, for call-site safety in the Sim/API. The DB `Notification.payload`
+// column is jsonb (free-form), so the registry reads payloads defensively (Record<string, unknown>); these
+// interfaces document the intended shape and can be used by emitters when constructing the payload.
+export {};

package/dist/esm/src/service/notification/registry.d.ts

@@ -0,0 +1,13 @@
+import { type NotificationType } from './notification-type';
+export type CatalogKeyResolver = string | ((payload: Record<string, unknown>) => string);
+export interface NotificationDescriptor {
+    emitsPush: boolean;
+    deepLink?: (payload: Record<string, unknown>) => string;
+    pushTitleKey?: CatalogKeyResolver;
+    pushBodyKey?: CatalogKeyResolver;
+    inAppMessageKey?: CatalogKeyResolver;
+    richRender?: NotificationType;
+    params?: (payload: Record<string, unknown>) => Record<string, string>;
+    catalogKeys: string[];
+}
+export declare const NOTIFICATION_REGISTRY: Record<NotificationType, NotificationDescriptor>;

package/dist/esm/src/service/notification/registry.js

@@ -0,0 +1,109 @@
+function readString(value) {
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+function teamPath(payload) {
+    const teamId = readString(payload.teamId);
+    return teamId != null ? `/team/${encodeURIComponent(teamId)}` : '/';
+}
+// MATCH_RESULT copy is recipient-relative: `result` is WIN/LOSS from the recipient's view and `side` marks
+// which team is theirs, so the OTHER team is the opponent. When side/names are missing, do not name a winner.
+function matchOpponent(payload) {
+    const homeTeam = typeof payload.homeTeam === 'object' && payload.homeTeam != null ? payload.homeTeam : {};
+    const awayTeam = typeof payload.awayTeam === 'object' && payload.awayTeam != null ? payload.awayTeam : {};
+    const homeName = readString(homeTeam.name);
+    const awayName = readString(awayTeam.name);
+    if (payload.side === 'HOME')
+        return awayName;
+    if (payload.side === 'AWAY')
+        return homeName;
+    return null;
+}
+function injuredName(payload) {
+    // Matches the old Sim injuredPlayerName fallback so a name-less payload never renders a subjectless sentence.
+    return readString(payload.playerNickname) ?? readString(payload.playerName) ?? 'A player';
+}
+export const NOTIFICATION_REGISTRY = {
+    MATCH_RESULT: {
+        emitsPush: true,
+        deepLink: (p) => {
+            const matchId = readString(p.matchId);
+            return matchId != null ? `/match/${encodeURIComponent(matchId)}` : '/';
+        },
+        pushTitleKey: 'matchResult.title',
+        pushBodyKey: (p) => {
+            const outcome = p.result === 'WIN' ? 'won' : 'lost';
+            const named = matchOpponent(p) != null ? 'Named' : 'Unnamed';
+            return `matchResult.${outcome}${named}`;
+        },
+        params: (p) => ({ opponent: matchOpponent(p) ?? '' }),
+        richRender: 'MATCH_RESULT',
+        catalogKeys: ['matchResult.title', 'matchResult.wonNamed', 'matchResult.wonUnnamed', 'matchResult.lostNamed', 'matchResult.lostUnnamed']
+    },
+    INJURY: {
+        emitsPush: true,
+        deepLink: () => '/infirmary',
+        pushTitleKey: 'injury.title',
+        pushBodyKey: 'injury.body',
+        inAppMessageKey: 'injury.body',
+        params: (p) => ({ name: injuredName(p) }),
+        catalogKeys: ['injury.title', 'injury.body']
+    },
+    INJURY_RECOVERED: {
+        emitsPush: true,
+        deepLink: teamPath,
+        pushTitleKey: 'injuryRecovered.title',
+        pushBodyKey: 'injuryRecovered.body',
+        inAppMessageKey: 'injuryRecovered.body',
+        params: (p) => ({ name: injuredName(p) }),
+        catalogKeys: ['injuryRecovered.title', 'injuryRecovered.body']
+    },
+    SEASON_END: {
+        emitsPush: true,
+        deepLink: (p) => {
+            const leagueId = readString(p.leagueId);
+            return leagueId != null ? `/league/${encodeURIComponent(leagueId)}` : '/league';
+        },
+        pushTitleKey: 'seasonEnd.title',
+        pushBodyKey: 'seasonEnd.body',
+        inAppMessageKey: 'seasonEnd.body',
+        catalogKeys: ['seasonEnd.title', 'seasonEnd.body']
+    },
+    GRANT_RECEIVED: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'grant.title',
+        pushBodyKey: 'grant.body',
+        inAppMessageKey: 'grant.body',
+        catalogKeys: ['grant.title', 'grant.body']
+    },
+    PROMOTION: {
+        emitsPush: true,
+        deepLink: teamPath,
+        pushTitleKey: 'promotion.title',
+        pushBodyKey: 'promotion.body',
+        inAppMessageKey: 'promotion.body',
+        catalogKeys: ['promotion.title', 'promotion.body']
+    },
+    DAILY_LOGIN: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'dailyLogin.title',
+        pushBodyKey: 'dailyLogin.body',
+        inAppMessageKey: 'dailyLogin.body',
+        catalogKeys: ['dailyLogin.title', 'dailyLogin.body']
+    },
+    WELCOME: {
+        emitsPush: true,
+        deepLink: () => '/recruit',
+        pushTitleKey: 'welcome.title',
+        pushBodyKey: 'welcome.body',
+        richRender: 'WELCOME',
+        catalogKeys: ['welcome.title', 'welcome.body']
+    },
+    // In-app only (no push); the UI keeps a bespoke renderer (amount formatting) and its own `compensation` label.
+    COMPENSATION: {
+        emitsPush: false,
+        richRender: 'COMPENSATION',
+        catalogKeys: []
+    }
+};

package/dist/esm/src/service/notification/render.d.ts

@@ -0,0 +1,10 @@
+import { type NotificationLocale } from './notification-type';
+export interface RenderedPush {
+    title: string;
+    body: string;
+    data: Record<string, string>;
+}
+export declare function interpolate(template: string, params: Record<string, string>): string;
+export declare function translateNotification(locale: NotificationLocale, key: string, params?: Record<string, string>): string;
+export declare function renderPush(type: string, payload: Record<string, unknown>, locale: NotificationLocale): RenderedPush | undefined;
+export declare function notificationPath(type: string, payload: Record<string, unknown>): string;

package/dist/esm/src/service/notification/render.js

@@ -0,0 +1,58 @@
+import { DEFAULT_NOTIFICATION_LOCALE } from './notification-type';
+import { NOTIFICATION_REGISTRY } from './registry';
+import { NOTIFICATION_CATALOG } from './catalog';
+function readNested(node, dotKey) {
+    let current = node;
+    for (const part of dotKey.split('.')) {
+        if (typeof current !== 'object' || current == null)
+            return undefined;
+        current = current[part];
+    }
+    return typeof current === 'string' ? current : undefined;
+}
+function lookupCatalog(locale, dotKey) {
+    return readNested(NOTIFICATION_CATALOG[locale], dotKey) ??
+        readNested(NOTIFICATION_CATALOG[DEFAULT_NOTIFICATION_LOCALE], dotKey) ??
+        dotKey;
+}
+function resolveKey(resolver, payload) {
+    if (resolver == null)
+        return undefined;
+    return typeof resolver === 'function' ? resolver(payload) : resolver;
+}
+export function interpolate(template, params) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => params[key] ?? '');
+}
+// Resolve one catalog key to a localized, interpolated string. Missing key/locale falls back to English,
+// then to the raw key. Exposed so consumers can render notification copy off the shared catalog too.
+export function translateNotification(locale, key, params = {}) {
+    return interpolate(lookupCatalog(locale, key), params);
+}
+// Build the localized push payload for a notification. Returns undefined for in-app-only types (emitsPush
+// false, e.g. COMPENSATION). Unknown/future types fall back to the generic copy and the root path, matching
+// the previous hardcoded fallback. Callers pass the recipient's locale (normalizeNotificationLocale first).
+export function renderPush(type, payload, locale) {
+    const buildData = (path) => ({ type, payload: JSON.stringify(payload), path });
+    const descriptor = NOTIFICATION_REGISTRY[type];
+    if (descriptor == null) {
+        return {
+            title: translateNotification(locale, 'generic.title'),
+            body: translateNotification(locale, 'generic.body'),
+            data: buildData('/')
+        };
+    }
+    if (!descriptor.emitsPush)
+        return undefined;
+    const params = descriptor.params?.(payload) ?? {};
+    const titleKey = resolveKey(descriptor.pushTitleKey, payload) ?? 'generic.title';
+    const bodyKey = resolveKey(descriptor.pushBodyKey, payload) ?? 'generic.body';
+    return {
+        title: translateNotification(locale, titleKey, params),
+        body: translateNotification(locale, bodyKey, params),
+        data: buildData(descriptor.deepLink?.(payload) ?? '/')
+    };
+}
+// Deep-link path for a type/payload, used for both the push data.path and the in-app click target.
+export function notificationPath(type, payload) {
+    return NOTIFICATION_REGISTRY[type]?.deepLink?.(payload) ?? '/';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.478",
+  "version": "0.0.479",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
@@ -37,6 +37,11 @@
       "import": "./dist/esm/src/data/common/index.js",
       "require": "./dist/cjs/src/data/common/index.js"
     },
+    "./notification": {
+      "types": "./dist/esm/src/service/notification/index.d.ts",
+      "import": "./dist/esm/src/service/notification/index.js",
+      "require": "./dist/cjs/src/service/notification/index.js"
+    },
     "./stat-config": {
       "types": "./dist/esm/src/stat-config/index.d.ts",
       "import": "./dist/esm/src/stat-config/index.js",