strapi-plugin-notifier 1.0.3 → 1.2.0

package/tests/helpers.ts

@@ -0,0 +1,145 @@
+import { vi } from 'vitest';
+import type { NotificationType } from '../server/src/config';
+import type { UserPreference } from '../server/src/services/preference';
+
+// ---------------------------------------------------------------------------
+// DB query mock
+// ---------------------------------------------------------------------------
+
+export const makeDbQuery = (overrides: Record<string, unknown> = {}) => ({
+  findOne: vi.fn().mockResolvedValue(null),
+  findMany: vi.fn().mockResolvedValue([]),
+  create: vi.fn().mockImplementation(({ data }: { data: Record<string, unknown> }) =>
+    Promise.resolve({ id: 1, ...data })
+  ),
+  update: vi.fn().mockImplementation(({ data }: { data: Record<string, unknown> }) =>
+    Promise.resolve({ id: 1, ...data })
+  ),
+  updateMany: vi.fn().mockResolvedValue({ count: 0 }),
+  delete: vi.fn().mockResolvedValue({ id: 1 }),
+  deleteMany: vi.fn().mockResolvedValue({ count: 0 }),
+  count: vi.fn().mockResolvedValue(0),
+  ...overrides,
+});
+
+// ---------------------------------------------------------------------------
+// Preference helpers
+// ---------------------------------------------------------------------------
+
+export const makeDefaultPref = (overrides: Partial<UserPreference> = {}): UserPreference => ({
+  userId: 1,
+  globalOptOut: false,
+  mutedTypes: [],
+  ...overrides,
+});
+
+export const makePrefService = (prefOverrides: Partial<UserPreference> = {}) => {
+  const pref = makeDefaultPref(prefOverrides);
+  return {
+    get: vi.fn().mockResolvedValue(pref),
+    isOptedOut: (p: UserPreference, type: NotificationType) =>
+      p.globalOptOut || p.mutedTypes.includes(type),
+    upsert: vi.fn().mockResolvedValue(pref),
+  };
+};
+
+// ---------------------------------------------------------------------------
+// Notification service mock (for notifier tests)
+// ---------------------------------------------------------------------------
+
+export const makeNotificationService = (overrides: Record<string, unknown> = {}) => ({
+  create: vi.fn().mockResolvedValue({ id: 1, mergeCount: 1 }),
+  createMany: vi.fn().mockResolvedValue([{ id: 1 }]),
+  findMergeCandidate: vi.fn().mockResolvedValue(null),
+  mergeInto: vi.fn().mockResolvedValue({ id: 1, mergeCount: 2 }),
+  findByRecipient: vi.fn().mockResolvedValue([]),
+  countByRecipient: vi.fn().mockResolvedValue(0),
+  countUnread: vi.fn().mockResolvedValue(0),
+  markAsRead: vi.fn().mockResolvedValue({ id: 1, read: true }),
+  markAllAsRead: vi.fn().mockResolvedValue({}),
+  delete: vi.fn().mockResolvedValue({ id: 1 }),
+  clearAll: vi.fn().mockResolvedValue({}),
+  ...overrides,
+});
+
+// ---------------------------------------------------------------------------
+// Settings mock
+// ---------------------------------------------------------------------------
+
+export const makeSettingsService = (overrides: Record<string, unknown> = {}) => ({
+  getEffective: vi.fn().mockResolvedValue({
+    retention: { maxDays: 90, maxPerUser: 500 },
+    delivery: { defaultRecipient: 'broadcast', allowedRoles: [] },
+    merge: {
+      enabled: false,
+      windowMinutes: 60,
+      keyFields: ['title', 'type'],
+      countBadge: true,
+      rewriteMessage: false,
+    },
+    ui: {
+      pollInterval: 30000,
+      pageSize: 20,
+      defaultFilter: 'all',
+      badge: { enabled: true, color: '#ee5e52' },
+      theme: {
+        bellSize: '1.5em',
+        accent: { info: '#4945ff', success: '#328048', warning: '#d97706', error: '#d02b20' },
+      },
+    },
+    ...overrides,
+  }),
+  get: vi.fn(),
+  update: vi.fn(),
+  reset: vi.fn(),
+});
+
+// ---------------------------------------------------------------------------
+// Strapi instance mocks
+// ---------------------------------------------------------------------------
+
+/** Minimal strapi mock for notification service tests. */
+export const makeNotificationStrapi = (
+  dbOverrides: Record<string, unknown> = {},
+  prefOverrides: Partial<UserPreference> = {}
+) => {
+  const db = makeDbQuery(dbOverrides);
+  const prefSvc = makePrefService(prefOverrides);
+  const strapi = {
+    db: { query: vi.fn().mockReturnValue(db) },
+    plugin: vi.fn().mockReturnValue({ service: vi.fn().mockReturnValue(prefSvc) }),
+  };
+  return { strapi, _db: db, _prefSvc: prefSvc };
+};
+
+/** Minimal strapi mock for preference service tests. */
+export const makePreferenceStrapi = (dbOverrides: Record<string, unknown> = {}) => {
+  const db = makeDbQuery(dbOverrides);
+  const strapi = { db: { query: vi.fn().mockReturnValue(db) } };
+  return { strapi, _db: db };
+};
+
+/** Minimal strapi mock for notifier service tests. */
+export const makeNotifierStrapi = (
+  notifOverrides: Record<string, unknown> = {},
+  prefOverrides: Partial<UserPreference> = {},
+  settingsOverrides: Record<string, unknown> = {}
+) => {
+  const notifSvc = makeNotificationService(notifOverrides);
+  const prefSvc = makePrefService(prefOverrides);
+  const settSvc = makeSettingsService(settingsOverrides);
+
+  const serviceMap: Record<string, unknown> = {
+    notification: notifSvc,
+    preference: prefSvc,
+    settings: settSvc,
+  };
+
+  const strapi = {
+    plugin: vi.fn().mockReturnValue({
+      service: vi.fn().mockImplementation((name: string) => serviceMap[name]),
+    }),
+  };
+
+  return { strapi, _notifSvc: notifSvc, _prefSvc: prefSvc, _settSvc: settSvc };
+};

package/tests/unit/config.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import { DEFAULT_SETTINGS, mergeWithDefaults } from '../../server/src/config';
+
+describe('mergeWithDefaults', () => {
+  it('returns all default fields when called with no overrides', () => {
+    const result = mergeWithDefaults();
+    expect(result).toEqual(DEFAULT_SETTINGS);
+  });
+
+  it('includes default merge config', () => {
+    const result = mergeWithDefaults();
+    expect(result.merge).toEqual({
+      enabled: false,
+      windowMinutes: 60,
+      keyFields: ['title', 'type'],
+      countBadge: true,
+      rewriteMessage: false,
+    });
+  });
+
+  it('enables merge when overridden', () => {
+    const result = mergeWithDefaults({ merge: { enabled: true } });
+    expect(result.merge.enabled).toBe(true);
+    expect(result.merge.windowMinutes).toBe(60);
+    expect(result.merge.keyFields).toEqual(['title', 'type']);
+  });
+
+  it('overrides windowMinutes while preserving other merge defaults', () => {
+    const result = mergeWithDefaults({ merge: { windowMinutes: 30 } });
+    expect(result.merge.windowMinutes).toBe(30);
+    expect(result.merge.enabled).toBe(false);
+    expect(result.merge.countBadge).toBe(true);
+  });
+
+  it('replaces keyFields entirely when overridden', () => {
+    const result = mergeWithDefaults({ merge: { keyFields: ['url'] } });
+    expect(result.merge.keyFields).toEqual(['url']);
+  });
+
+  it('applies rewriteMessage override', () => {
+    const result = mergeWithDefaults({ merge: { rewriteMessage: true } });
+    expect(result.merge.rewriteMessage).toBe(true);
+    expect(result.merge.countBadge).toBe(true);
+  });
+
+  it('does not bleed merge config into other sections', () => {
+    const result = mergeWithDefaults({ merge: { enabled: true } });
+    expect(result.retention).toEqual(DEFAULT_SETTINGS.retention);
+    expect(result.delivery).toEqual(DEFAULT_SETTINGS.delivery);
+  });
+
+  it('overrides retention fields independently', () => {
+    const result = mergeWithDefaults({ retention: { maxDays: 30 } });
+    expect(result.retention.maxDays).toBe(30);
+    expect(result.retention.maxPerUser).toBe(DEFAULT_SETTINGS.retention.maxPerUser);
+    expect(result.merge).toEqual(DEFAULT_SETTINGS.merge);
+  });
+
+  it('deeply merges ui accent colours', () => {
+    const result = mergeWithDefaults({ ui: { theme: { accent: { info: '#000' } } } });
+    expect(result.ui.theme.accent.info).toBe('#000');
+    expect(result.ui.theme.accent.error).toBe(DEFAULT_SETTINGS.ui.theme.accent.error);
+  });
+});

package/tests/unit/notification.test.ts

@@ -0,0 +1,263 @@
+import { describe, it, expect, vi } from 'vitest';
+import makeNotificationService from '../../server/src/services/notification';
+import { makeNotificationStrapi, makeDbQuery } from '../helpers';
+import type { MergeConfig } from '../../server/src/config';
+
+const DISABLED_MERGE: MergeConfig = {
+  enabled: false,
+  windowMinutes: 60,
+  keyFields: ['title', 'type'],
+  countBadge: true,
+  rewriteMessage: false,
+};
+
+// ---------------------------------------------------------------------------
+// findByRecipient — opt-out filtering
+// ---------------------------------------------------------------------------
+
+describe('notification.findByRecipient', () => {
+  it('returns empty array without querying DB when globalOptOut is true', async () => {
+    const { strapi, _db } = makeNotificationStrapi({}, { globalOptOut: true });
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    const result = await svc.findByRecipient(1, []);
+
+    expect(result).toEqual([]);
+    expect(_db.findMany).not.toHaveBeenCalled();
+  });
+
+  it('queries DB normally when user has no restrictions', async () => {
+    const rows = [{ id: 1, title: 'Hello', type: 'info' }];
+    const { strapi, _db } = makeNotificationStrapi(
+      { findMany: vi.fn().mockResolvedValue(rows) },
+      { globalOptOut: false, mutedTypes: [] }
+    );
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    const result = await svc.findByRecipient(1, []);
+
+    expect(result).toBe(rows);
+    expect(_db.findMany).toHaveBeenCalledOnce();
+    const call = _db.findMany.mock.calls[0][0];
+    expect(call.where).not.toHaveProperty('type');
+  });
+
+  it('adds $notIn filter for mutedTypes', async () => {
+    const { strapi, _db } = makeNotificationStrapi(
+      {},
+      { globalOptOut: false, mutedTypes: ['info', 'warning'] as any }
+    );
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.findByRecipient(1, []);
+
+    const where = _db.findMany.mock.calls[0][0].where;
+    expect(where.type).toEqual({ $notIn: ['info', 'warning'] });
+  });
+
+  it('respects page and pageSize', async () => {
+    const { strapi, _db } = makeNotificationStrapi();
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.findByRecipient(1, [], { page: 3, pageSize: 10 });
+
+    const call = _db.findMany.mock.calls[0][0];
+    expect(call.limit).toBe(10);
+    expect(call.offset).toBe(20);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// countByRecipient / countUnread — opt-out
+// ---------------------------------------------------------------------------
+
+describe('notification.countByRecipient', () => {
+  it('returns 0 without querying DB when globalOptOut is true', async () => {
+    const { strapi, _db } = makeNotificationStrapi({}, { globalOptOut: true });
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    const count = await svc.countByRecipient(1, []);
+
+    expect(count).toBe(0);
+    expect(_db.count).not.toHaveBeenCalled();
+  });
+
+  it('queries DB normally when not opted out', async () => {
+    const { strapi, _db } = makeNotificationStrapi({ count: vi.fn().mockResolvedValue(5) });
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    const count = await svc.countByRecipient(1, []);
+
+    expect(count).toBe(5);
+    expect(_db.count).toHaveBeenCalledOnce();
+  });
+});
+
+describe('notification.countUnread', () => {
+  it('returns 0 without querying DB when globalOptOut is true', async () => {
+    const { strapi, _db } = makeNotificationStrapi({}, { globalOptOut: true });
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    const count = await svc.countUnread(1, []);
+
+    expect(count).toBe(0);
+    expect(_db.count).not.toHaveBeenCalled();
+  });
+
+  it('passes read: false filter when not opted out', async () => {
+    const { strapi, _db } = makeNotificationStrapi({ count: vi.fn().mockResolvedValue(3) });
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.countUnread(1, []);
+
+    const where = _db.count.mock.calls[0][0].where;
+    expect(where.read).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// create
+// ---------------------------------------------------------------------------
+
+describe('notification.create', () => {
+  it('stores mergeKey and mergeCount: 1', async () => {
+    const { strapi, _db } = makeNotificationStrapi();
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.create({ title: 'Test', type: 'info', mergeKey: 'Test\x00info' });
+
+    const data = _db.create.mock.calls[0][0].data;
+    expect(data.mergeKey).toBe('Test\x00info');
+    expect(data.mergeCount).toBe(1);
+    expect(data.read).toBe(false);
+  });
+
+  it('defaults type to info', async () => {
+    const { strapi, _db } = makeNotificationStrapi();
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.create({ title: 'Hi' });
+
+    expect(_db.create.mock.calls[0][0].data.type).toBe('info');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// findMergeCandidate
+// ---------------------------------------------------------------------------
+
+describe('notification.findMergeCandidate', () => {
+  it('queries DB with mergeKey, recipientId, and cutoff', async () => {
+    const candidate = { id: 5, mergeCount: 1 };
+    const { strapi, _db } = makeNotificationStrapi({
+      findOne: vi.fn().mockResolvedValue(candidate),
+    });
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    const before = Date.now();
+    const result = await svc.findMergeCandidate('Test\x00info', 1, null, 60 * 60 * 1000);
+    const after = Date.now();
+
+    expect(result).toBe(candidate);
+    const where = _db.findOne.mock.calls[0][0].where;
+    expect(where.mergeKey).toBe('Test\x00info');
+    expect(where.recipientId).toBe(1);
+    expect(where.recipientRole).toBeNull();
+    const cutoffMs = new Date(where.createdAt.$gt).getTime();
+    expect(cutoffMs).toBeGreaterThanOrEqual(before - 60 * 60 * 1000);
+    expect(cutoffMs).toBeLessThanOrEqual(after);
+  });
+
+  it('returns null when no candidate found', async () => {
+    const { strapi } = makeNotificationStrapi({ findOne: vi.fn().mockResolvedValue(null) });
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    const result = await svc.findMergeCandidate('key', null, null, 3600000);
+    expect(result).toBeNull();
+  });
+
+  it('uses recipientRole when provided', async () => {
+    const { strapi, _db } = makeNotificationStrapi();
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.findMergeCandidate('key', null, 'strapi-editor', 3600000);
+
+    const where = _db.findOne.mock.calls[0][0].where;
+    expect(where.recipientRole).toBe('strapi-editor');
+    expect(where.recipientId).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// mergeInto
+// ---------------------------------------------------------------------------
+
+describe('notification.mergeInto', () => {
+  it('updates mergeCount without rewriting message when rewriteMessage=false', async () => {
+    const { strapi, _db } = makeNotificationStrapi();
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.mergeInto(5, 3, { ...DISABLED_MERGE, rewriteMessage: false }, 'Test');
+
+    const data = _db.update.mock.calls[0][0].data;
+    expect(data.mergeCount).toBe(3);
+    expect(data.message).toBeUndefined();
+  });
+
+  it('rewrites message when rewriteMessage=true', async () => {
+    const { strapi, _db } = makeNotificationStrapi();
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.mergeInto(5, 4, { ...DISABLED_MERGE, rewriteMessage: true }, 'Test');
+
+    const data = _db.update.mock.calls[0][0].data;
+    expect(data.mergeCount).toBe(4);
+    expect(data.message).toBe('4× Test');
+  });
+
+  it('targets the correct notification id', async () => {
+    const { strapi, _db } = makeNotificationStrapi();
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.mergeInto(99, 2, DISABLED_MERGE, 'X');
+
+    expect(_db.update.mock.calls[0][0].where).toEqual({ id: 99 });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createMany
+// ---------------------------------------------------------------------------
+
+describe('notification.createMany', () => {
+  it('calls create for each item', async () => {
+    const { strapi, _db } = makeNotificationStrapi();
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    await svc.createMany([
+      { title: 'A', type: 'info' },
+      { title: 'B', type: 'error' },
+    ]);
+
+    expect(_db.create).toHaveBeenCalledTimes(2);
+    const titles = _db.create.mock.calls.map((c: any) => c[0].data.title);
+    expect(titles).toContain('A');
+    expect(titles).toContain('B');
+  });
+
+  it('returns an array of created items', async () => {
+    const { strapi } = makeNotificationStrapi({
+      create: vi
+        .fn()
+        .mockResolvedValueOnce({ id: 1, title: 'A' })
+        .mockResolvedValueOnce({ id: 2, title: 'B' }),
+    });
+    const svc = makeNotificationService({ strapi: strapi as any });
+
+    const results = await svc.createMany([{ title: 'A' }, { title: 'B' }]);
+
+    expect(results).toHaveLength(2);
+    expect(results[0]).toMatchObject({ id: 1 });
+    expect(results[1]).toMatchObject({ id: 2 });
+  });
+});