strapi-plugin-notifier 1.0.3 → 1.2.0

package/tests/unit/notifier.test.ts

@@ -0,0 +1,348 @@
+import { describe, it, expect, vi } from 'vitest';
+import makeNotifierService from '../../server/src/services/notifier';
+import { makeNotifierStrapi } from '../helpers';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const MERGE_ENABLED = {
+  enabled: true,
+  windowMinutes: 60,
+  keyFields: ['title', 'type'],
+  countBadge: true,
+  rewriteMessage: false,
+};
+
+const MERGE_DISABLED = { ...MERGE_ENABLED, enabled: false };
+
+const withMerge = (enabled: boolean, extra = {}) => ({
+  merge: enabled ? MERGE_ENABLED : MERGE_DISABLED,
+  ...extra,
+});
+
+// ---------------------------------------------------------------------------
+// send — merge disabled
+// ---------------------------------------------------------------------------
+
+describe('notifier.send — merge disabled', () => {
+  it('creates a notification directly', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'Hello', type: 'info' });
+
+    expect(_notifSvc.create).toHaveBeenCalledOnce();
+    expect(_notifSvc.findMergeCandidate).not.toHaveBeenCalled();
+  });
+
+  it('passes title, message, type, url to create', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'T', message: 'M', type: 'error', url: '/path' });
+
+    const args = _notifSvc.create.mock.calls[0][0];
+    expect(args).toMatchObject({ title: 'T', message: 'M', type: 'error', url: '/path' });
+  });
+
+  it('sets recipientId when targeting a user', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'Hi', to: { userId: 42 } });
+
+    expect(_notifSvc.create.mock.calls[0][0].recipientId).toBe(42);
+  });
+
+  it('sets recipientRole when targeting a role', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'Hi', to: { role: 'strapi-editor' } });
+
+    expect(_notifSvc.create.mock.calls[0][0].recipientRole).toBe('strapi-editor');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// send — opt-out
+// ---------------------------------------------------------------------------
+
+describe('notifier.send — opt-out', () => {
+  it('does not create when target user is opted out (globalOptOut)', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi(
+      {},
+      { globalOptOut: true }
+    );
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    const result = await svc.toUser(1, { title: 'Hi' });
+
+    expect(result).toBeNull();
+    expect(_notifSvc.create).not.toHaveBeenCalled();
+  });
+
+  it('does not create when type is muted', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi(
+      {},
+      { globalOptOut: false, mutedTypes: ['info'] as any }
+    );
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    const result = await svc.toUser(1, { title: 'Hi', type: 'info' });
+
+    expect(result).toBeNull();
+    expect(_notifSvc.create).not.toHaveBeenCalled();
+  });
+
+  it('creates when type is NOT in mutedTypes', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi(
+      {},
+      { globalOptOut: false, mutedTypes: ['warning'] as any }
+    );
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.toUser(1, { title: 'Hi', type: 'info' });
+
+    expect(_notifSvc.create).toHaveBeenCalledOnce();
+  });
+
+  it('does NOT check opt-out for broadcast (no recipientId)', async () => {
+    const { strapi, _notifSvc, _prefSvc, _settSvc } = makeNotifierStrapi(
+      {},
+      { globalOptOut: true }
+    );
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.broadcast({ title: 'All' });
+
+    expect(_prefSvc.get).not.toHaveBeenCalled();
+    expect(_notifSvc.create).toHaveBeenCalledOnce();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// send — merge enabled
+// ---------------------------------------------------------------------------
+
+describe('notifier.send — merge enabled', () => {
+  it('calls findMergeCandidate with computed merge key', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(true));
+    _notifSvc.findMergeCandidate.mockResolvedValue(null);
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'Deploy', type: 'info' });
+
+    expect(_notifSvc.findMergeCandidate).toHaveBeenCalledOnce();
+    const [mergeKey] = _notifSvc.findMergeCandidate.mock.calls[0];
+    expect(mergeKey).toBe('Deploy\x00info');
+  });
+
+  it('calls mergeInto (not create) when a candidate is found', async () => {
+    const candidate = { id: 7, mergeCount: 2 };
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(true));
+    _notifSvc.findMergeCandidate.mockResolvedValue(candidate);
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'Deploy', type: 'info' });
+
+    expect(_notifSvc.mergeInto).toHaveBeenCalledWith(7, 3, MERGE_ENABLED, 'Deploy');
+    expect(_notifSvc.create).not.toHaveBeenCalled();
+  });
+
+  it('creates a new notification when no candidate found', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(true));
+    _notifSvc.findMergeCandidate.mockResolvedValue(null);
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'New', type: 'success' });
+
+    expect(_notifSvc.create).toHaveBeenCalledOnce();
+    expect(_notifSvc.mergeInto).not.toHaveBeenCalled();
+  });
+
+  it('includes mergeKey in the created notification', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(true));
+    _notifSvc.findMergeCandidate.mockResolvedValue(null);
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'Test', type: 'warning' });
+
+    const args = _notifSvc.create.mock.calls[0][0];
+    expect(args.mergeKey).toBe('Test\x00warning');
+  });
+
+  it('uses configured keyFields to build merge key', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue({
+      merge: { ...MERGE_ENABLED, keyFields: ['title', 'url'] },
+    });
+    _notifSvc.findMergeCandidate.mockResolvedValue(null);
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'Deploy', url: '/admin', type: 'info' });
+
+    const [mergeKey] = _notifSvc.findMergeCandidate.mock.calls[0];
+    expect(mergeKey).toBe('Deploy\x00/admin');
+  });
+
+  it('passes window in ms to findMergeCandidate', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue({
+      merge: { ...MERGE_ENABLED, windowMinutes: 30 },
+    });
+    _notifSvc.findMergeCandidate.mockResolvedValue(null);
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.send({ title: 'T', type: 'info' });
+
+    const windowMs = _notifSvc.findMergeCandidate.mock.calls[0][3];
+    expect(windowMs).toBe(30 * 60 * 1000);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// sendBatch
+// ---------------------------------------------------------------------------
+
+describe('notifier.sendBatch', () => {
+  it('fetches settings exactly once regardless of batch size', async () => {
+    const { strapi, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.sendBatch([
+      { title: 'A', type: 'info' },
+      { title: 'B', type: 'warning' },
+      { title: 'C', type: 'success' },
+    ]);
+
+    expect(_settSvc.getEffective).toHaveBeenCalledOnce();
+  });
+
+  it('sends all items and returns an array of results', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+    _notifSvc.create
+      .mockResolvedValueOnce({ id: 1 })
+      .mockResolvedValueOnce({ id: 2 });
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    const results = await svc.sendBatch([
+      { title: 'A', type: 'info' },
+      { title: 'B', type: 'error' },
+    ]);
+
+    expect(_notifSvc.create).toHaveBeenCalledTimes(2);
+    expect(results).toHaveLength(2);
+  });
+
+  it('skips opted-out recipients but still sends others', async () => {
+    const { strapi, _notifSvc, _prefSvc, _settSvc } = makeNotifierStrapi(
+      {},
+      { globalOptOut: true }
+    );
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    const results = await svc.sendBatch([
+      { title: 'A', to: { userId: 1 } },
+      { title: 'B' },
+    ]);
+
+    // userId:1 opted out → null; broadcast (no userId) → not checked
+    expect(results[0]).toBeNull();
+    expect(_notifSvc.create).toHaveBeenCalledOnce();
+    expect(results).toHaveLength(2);
+  });
+
+  it('returns empty array for empty input', async () => {
+    const { strapi, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    const results = await svc.sendBatch([]);
+
+    expect(results).toEqual([]);
+    expect(_settSvc.getEffective).toHaveBeenCalledOnce();
+  });
+
+  it('applies merge per item in the batch', async () => {
+    const candidate = { id: 10, mergeCount: 1 };
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(true));
+    _notifSvc.findMergeCandidate
+      .mockResolvedValueOnce(candidate)
+      .mockResolvedValueOnce(null);
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.sendBatch([
+      { title: 'Same', type: 'info' },
+      { title: 'New', type: 'info' },
+    ]);
+
+    expect(_notifSvc.mergeInto).toHaveBeenCalledOnce();
+    expect(_notifSvc.create).toHaveBeenCalledOnce();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// toUser / toRole / broadcast convenience wrappers
+// ---------------------------------------------------------------------------
+
+describe('notifier convenience wrappers', () => {
+  it('toUser passes recipientId and skips create when opted out', async () => {
+    const { strapi, _notifSvc, _settSvc } = makeNotifierStrapi(
+      {},
+      { globalOptOut: true }
+    );
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.toUser(1, { title: 'Hi' });
+
+    expect(_notifSvc.create).not.toHaveBeenCalled();
+  });
+
+  it('toRole passes recipientRole without opt-out check', async () => {
+    const { strapi, _notifSvc, _prefSvc, _settSvc } = makeNotifierStrapi(
+      {},
+      { globalOptOut: true }
+    );
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.toRole('strapi-editor', { title: 'Hi' });
+
+    expect(_prefSvc.get).not.toHaveBeenCalled();
+    expect(_notifSvc.create).toHaveBeenCalledOnce();
+    expect(_notifSvc.create.mock.calls[0][0].recipientRole).toBe('strapi-editor');
+  });
+
+  it('broadcast creates without opt-out check', async () => {
+    const { strapi, _notifSvc, _prefSvc, _settSvc } = makeNotifierStrapi();
+    _settSvc.getEffective.mockResolvedValue(withMerge(false));
+
+    const svc = makeNotifierService({ strapi: strapi as any });
+    await svc.broadcast({ title: 'All', type: 'warning' });
+
+    expect(_prefSvc.get).not.toHaveBeenCalled();
+    expect(_notifSvc.create).toHaveBeenCalledOnce();
+    const args = _notifSvc.create.mock.calls[0][0];
+    expect(args.recipientId).toBeUndefined();
+    expect(args.recipientRole).toBeUndefined();
+  });
+});

package/tests/unit/preference.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import makePreferenceService from '../../server/src/services/preference';
+import { makePreferenceStrapi } from '../helpers';
+
+describe('preference.isOptedOut (pure logic)', () => {
+  const { isOptedOut } = makePreferenceService({ strapi: {} as any });
+
+  it('returns true when globalOptOut is set', () => {
+    expect(isOptedOut({ userId: 1, globalOptOut: true, mutedTypes: [] }, 'info')).toBe(true);
+  });
+
+  it('returns true when type is in mutedTypes', () => {
+    expect(isOptedOut({ userId: 1, globalOptOut: false, mutedTypes: ['info'] }, 'info')).toBe(true);
+  });
+
+  it('returns false when type is not muted and globalOptOut is false', () => {
+    expect(isOptedOut({ userId: 1, globalOptOut: false, mutedTypes: ['warning'] }, 'info')).toBe(false);
+  });
+
+  it('returns false with empty mutedTypes and globalOptOut false', () => {
+    expect(isOptedOut({ userId: 1, globalOptOut: false, mutedTypes: [] }, 'error')).toBe(false);
+  });
+
+  it('globalOptOut overrides even when mutedTypes is empty', () => {
+    expect(isOptedOut({ userId: 1, globalOptOut: true, mutedTypes: [] }, 'success')).toBe(true);
+  });
+
+  it('mutes multiple types independently', () => {
+    const pref = { userId: 1, globalOptOut: false, mutedTypes: ['info', 'warning'] as any };
+    expect(isOptedOut(pref, 'info')).toBe(true);
+    expect(isOptedOut(pref, 'warning')).toBe(true);
+    expect(isOptedOut(pref, 'success')).toBe(false);
+    expect(isOptedOut(pref, 'error')).toBe(false);
+  });
+});
+
+describe('preference.get', () => {
+  it('returns default preference when no DB row exists', async () => {
+    const { strapi, _db } = makePreferenceStrapi({ findOne: vi.fn().mockResolvedValue(null) });
+    const svc = makePreferenceService({ strapi: strapi as any });
+
+    const pref = await svc.get(5);
+
+    expect(pref).toEqual({ userId: 5, globalOptOut: false, mutedTypes: [] });
+    expect(_db.findOne).toHaveBeenCalledWith({ where: { userId: 5 } });
+  });
+
+  it('returns stored preference when DB row exists', async () => {
+    const stored = { userId: 5, globalOptOut: true, mutedTypes: ['info', 'warning'] };
+    const { strapi } = makePreferenceStrapi({ findOne: vi.fn().mockResolvedValue(stored) });
+    const svc = makePreferenceService({ strapi: strapi as any });
+
+    const pref = await svc.get(5);
+
+    expect(pref.globalOptOut).toBe(true);
+    expect(pref.mutedTypes).toEqual(['info', 'warning']);
+  });
+
+  it('normalises null mutedTypes to empty array', async () => {
+    const stored = { userId: 5, globalOptOut: false, mutedTypes: null };
+    const { strapi } = makePreferenceStrapi({ findOne: vi.fn().mockResolvedValue(stored) });
+    const svc = makePreferenceService({ strapi: strapi as any });
+
+    const pref = await svc.get(5);
+    expect(pref.mutedTypes).toEqual([]);
+  });
+});
+
+describe('preference.upsert', () => {
+  it('creates a new row when none exists', async () => {
+    const { strapi, _db } = makePreferenceStrapi({
+      findOne: vi.fn().mockResolvedValue(null),
+      create: vi.fn().mockResolvedValue({
+        userId: 3,
+        globalOptOut: true,
+        mutedTypes: [],
+      }),
+    });
+    const svc = makePreferenceService({ strapi: strapi as any });
+
+    const pref = await svc.upsert(3, { globalOptOut: true });
+
+    expect(_db.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({ userId: 3, globalOptOut: true }),
+    });
+    expect(_db.update).not.toHaveBeenCalled();
+    expect(pref.globalOptOut).toBe(true);
+  });
+
+  it('updates existing row when one exists', async () => {
+    const existing = { id: 10, userId: 3, globalOptOut: false, mutedTypes: [] };
+    const { strapi, _db } = makePreferenceStrapi({
+      findOne: vi.fn().mockResolvedValue(existing),
+      update: vi.fn().mockResolvedValue({ ...existing, mutedTypes: ['info'] }),
+    });
+    const svc = makePreferenceService({ strapi: strapi as any });
+
+    const pref = await svc.upsert(3, { mutedTypes: ['info'] as any });
+
+    expect(_db.update).toHaveBeenCalledWith({
+      where: { id: 10 },
+      data: { mutedTypes: ['info'] },
+    });
+    expect(_db.create).not.toHaveBeenCalled();
+    expect(pref.mutedTypes).toEqual(['info']);
+  });
+
+  it('persists globalOptOut=false to re-enable notifications', async () => {
+    const existing = { id: 7, userId: 2, globalOptOut: true, mutedTypes: [] };
+    const { strapi, _db } = makePreferenceStrapi({
+      findOne: vi.fn().mockResolvedValue(existing),
+      update: vi.fn().mockResolvedValue({ ...existing, globalOptOut: false }),
+    });
+    const svc = makePreferenceService({ strapi: strapi as any });
+
+    await svc.upsert(2, { globalOptOut: false });
+
+    expect(_db.update).toHaveBeenCalledWith(
+      expect.objectContaining({ data: { globalOptOut: false } })
+    );
+  });
+});