strapi-plugin-notifier 1.0.3 → 1.2.0

package/tests/unit/rules.test.ts

@@ -0,0 +1,470 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import makeRulesService, { interpolate, getByPath } from '../../server/src/services/rules';
+import type { NotifierRule } from '../../server/src/config';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const makeSend = () => vi.fn().mockResolvedValue({ id: 1 });
+
+/** Builds a minimal strapi mock and returns it alongside a reference to `send`. */
+const makeStrapi = (send = makeSend()) => {
+  let lifecycleCallback: ((event: any) => Promise<void>) | undefined;
+  let eventCallback: ((data: any) => Promise<void>) | undefined;
+  let cronTask: ((ctx: { strapi: any }) => Promise<void>) | undefined;
+
+  const strapi = {
+    db: {
+      lifecycles: {
+        subscribe: vi.fn((opts: any) => {
+          // Capture whichever action key is present (afterCreate, afterUpdate, …)
+          const actionKey = Object.keys(opts).find((k) => k !== 'models');
+          if (actionKey) lifecycleCallback = opts[actionKey];
+        }),
+      },
+    },
+    eventHub: {
+      on: vi.fn((_event: string, cb: any) => { eventCallback = cb; }),
+    },
+    cron: {
+      add: vi.fn((tasks: any) => {
+        const key = Object.keys(tasks)[0];
+        cronTask = tasks[key].task;
+      }),
+    },
+    plugin: vi.fn().mockReturnValue({
+      service: vi.fn().mockReturnValue({ send }),
+    }),
+    log: { error: vi.fn() },
+  };
+
+  return { strapi, send, getLifecycleCallback: () => lifecycleCallback, getEventCallback: () => eventCallback, getCronTask: () => cronTask };
+};
+
+// ---------------------------------------------------------------------------
+// Unit: interpolate / getByPath
+// ---------------------------------------------------------------------------
+
+describe('getByPath', () => {
+  it('resolves shallow key', () => expect(getByPath({ a: 1 }, 'a')).toBe(1));
+  it('resolves nested key', () => expect(getByPath({ a: { b: 2 } }, 'a.b')).toBe(2));
+  it('returns undefined for missing path', () => expect(getByPath({ a: 1 }, 'a.b.c')).toBeUndefined());
+  it('returns undefined for null intermediate', () => expect(getByPath({ a: null }, 'a.b')).toBeUndefined());
+});
+
+describe('interpolate', () => {
+  it('replaces a simple token', () => {
+    expect(interpolate('Hello {{name}}', { name: 'World' })).toBe('Hello World');
+  });
+
+  it('replaces a nested token', () => {
+    expect(interpolate('Title: {{entry.title}}', { entry: { title: 'My Post' } })).toBe('Title: My Post');
+  });
+
+  it('replaces multiple tokens', () => {
+    expect(interpolate('{{a}} and {{b}}', { a: 'foo', b: 'bar' })).toBe('foo and bar');
+  });
+
+  it('replaces missing token with empty string', () => {
+    expect(interpolate('{{missing}}', {})).toBe('');
+  });
+
+  it('leaves non-token text unchanged', () => {
+    expect(interpolate('plain text', {})).toBe('plain text');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Lifecycle rules
+// ---------------------------------------------------------------------------
+
+describe('lifecycle rule', () => {
+  it('subscribes to the correct model and action', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: { title: 'Created', type: 'info' },
+    }]);
+
+    expect(strapi.db.lifecycles.subscribe).toHaveBeenCalledOnce();
+    const opts = strapi.db.lifecycles.subscribe.mock.calls[0][0];
+    expect(opts.models).toEqual(['api::article.article']);
+    expect(typeof opts.afterCreate).toBe('function');
+  });
+
+  it('fires send with interpolated title', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: { title: 'New: {{entry.title}}', type: 'success' },
+    }]);
+
+    await getLifecycleCallback()!({ result: { title: 'Hello World' } });
+
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'New: Hello World', type: 'success' }));
+  });
+
+  it('fires send with function title', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: { title: (ctx) => `Entry #${ctx.entry.id}`, type: 'info' },
+    }]);
+
+    await getLifecycleCallback()!({ result: { id: 42 } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'Entry #42' }));
+  });
+
+  it('skips send when when() returns false', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      when: (ctx) => ctx.entry.published === true,
+      notification: { title: 'Published', type: 'info' },
+    }]);
+
+    await getLifecycleCallback()!({ result: { published: false } });
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it('fires send when when() returns true', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      when: (ctx) => ctx.entry.status === 'published',
+      notification: { title: 'Published', type: 'success' },
+    }]);
+
+    await getLifecycleCallback()!({ result: { status: 'published' } });
+    expect(send).toHaveBeenCalledOnce();
+  });
+
+  it('resolves userIdFrom target from entry', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: {
+        title: 'Your article was created',
+        to: { userIdFrom: 'entry.createdBy.id' },
+      },
+    }]);
+
+    await getLifecycleCallback()!({ result: { createdBy: { id: 7 } } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ to: { userId: 7 } }));
+  });
+
+  it('uses params.data as entry fallback for before-hooks', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'beforeCreate',
+      notification: { title: '{{entry.title}}' },
+    }]);
+
+    // beforeCreate has no result, only params.data
+    await getLifecycleCallback()!({ params: { data: { title: 'Draft' } } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'Draft' }));
+  });
+
+  it('catches errors and logs them without throwing', async () => {
+    const send = vi.fn().mockRejectedValue(new Error('boom'));
+    const { strapi, getLifecycleCallback } = makeStrapi(send);
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle',
+      model: 'api::article.article',
+      action: 'afterCreate',
+      notification: { title: 'Test' },
+    }]);
+
+    await expect(getLifecycleCallback()!({ result: {} })).resolves.toBeUndefined();
+    expect(strapi.log.error).toHaveBeenCalledOnce();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Event rules
+// ---------------------------------------------------------------------------
+
+describe('event rule', () => {
+  it('subscribes to the event hub with the given event name', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'media.upload',
+      notification: { title: 'Upload' },
+    }]);
+
+    expect(strapi.eventHub.on).toHaveBeenCalledWith('media.upload', expect.any(Function));
+  });
+
+  it('fires send with interpolated title from event payload', async () => {
+    const { strapi, send, getEventCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'entry.create',
+      notification: { title: 'New entry: {{entry.title}}', type: 'info' },
+    }]);
+
+    await getEventCallback()!({ entry: { title: 'My Post' } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'New entry: My Post' }));
+  });
+
+  it('applies filter — skips when payload does not match', async () => {
+    const { strapi, send, getEventCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'entry.create',
+      filter: { uid: 'api::article.article' },
+      notification: { title: 'Article created' },
+    }]);
+
+    await getEventCallback()!({ uid: 'api::comment.comment' });
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it('applies filter — fires when payload matches', async () => {
+    const { strapi, send, getEventCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'entry.create',
+      filter: { uid: 'api::article.article' },
+      notification: { title: 'Article created' },
+    }]);
+
+    await getEventCallback()!({ uid: 'api::article.article', entry: { title: 'Hello' } });
+    expect(send).toHaveBeenCalledOnce();
+  });
+
+  it('respects when() guard', async () => {
+    const { strapi, send, getEventCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'event',
+      event: 'entry.update',
+      when: (ctx) => (ctx.entry as any)?.status === 'published',
+      notification: { title: 'Published' },
+    }]);
+
+    await getEventCallback()!({ entry: { status: 'draft' } });
+    expect(send).not.toHaveBeenCalled();
+
+    await getEventCallback()!({ entry: { status: 'published' } });
+    expect(send).toHaveBeenCalledOnce();
+  });
+
+  it('catches errors and logs them without throwing', async () => {
+    const send = vi.fn().mockRejectedValue(new Error('net'));
+    const { strapi, getEventCallback } = makeStrapi(send);
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{ on: 'event', event: 'media.upload', notification: { title: 'Upload' } }]);
+
+    await expect(getEventCallback()!({})).resolves.toBeUndefined();
+    expect(strapi.log.error).toHaveBeenCalledOnce();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Cron rules
+// ---------------------------------------------------------------------------
+
+describe('cron rule', () => {
+  it('registers a cron task with the given schedule', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{ on: 'cron', schedule: '0 9 * * 1', notification: { title: 'Weekly' } }]);
+
+    expect(strapi.cron.add).toHaveBeenCalledOnce();
+    const tasks = strapi.cron.add.mock.calls[0][0];
+    const key = Object.keys(tasks)[0];
+    expect(tasks[key].options.rule).toBe('0 9 * * 1');
+  });
+
+  it('fires send when the task runs', async () => {
+    const { strapi, send, getCronTask } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'cron',
+      schedule: '0 9 * * 1',
+      notification: { title: 'Weekly reminder', type: 'warning', to: 'broadcast' },
+    }]);
+
+    await getCronTask()!({ strapi: strapi as any });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ title: 'Weekly reminder', type: 'warning' }));
+  });
+
+  it('uses distinct keys for multiple cron rules', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    const rules: NotifierRule[] = [
+      { on: 'cron', schedule: '0 9 * * 1', notification: { title: 'A' } },
+      { on: 'cron', schedule: '0 17 * * 5', notification: { title: 'B' } },
+    ];
+    svc.setup(rules);
+
+    const keys = strapi.cron.add.mock.calls.map((c: any) => Object.keys(c[0])[0]);
+    expect(new Set(keys).size).toBe(2);
+  });
+
+  it('catches errors and logs them without throwing', async () => {
+    const send = vi.fn().mockRejectedValue(new Error('oops'));
+    const { strapi, getCronTask } = makeStrapi(send);
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{ on: 'cron', schedule: '* * * * *', notification: { title: 'Fail' } }]);
+
+    await expect(getCronTask()!({ strapi: strapi as any })).resolves.toBeUndefined();
+    expect(strapi.log.error).toHaveBeenCalledOnce();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Targeting
+// ---------------------------------------------------------------------------
+
+describe('rule targeting', () => {
+  it('broadcast: sends with no `to` key', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: { title: 'T', to: 'broadcast' },
+    }]);
+
+    await getLifecycleCallback()!({ result: {} });
+    const args = send.mock.calls[0][0];
+    expect(args.to).toBeUndefined();
+  });
+
+  it('role: sends with to.role', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: { title: 'T', to: { role: 'strapi-editor' } },
+    }]);
+
+    await getLifecycleCallback()!({ result: {} });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ to: { role: 'strapi-editor' } }));
+  });
+
+  it('userId: sends with to.userId', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: { title: 'T', to: { userId: 3 } },
+    }]);
+
+    await getLifecycleCallback()!({ result: {} });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ to: { userId: 3 } }));
+  });
+
+  it('userIdFrom missing path: sends with no to key (falls back to broadcast)', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: { title: 'T', to: { userIdFrom: 'entry.author.id' } },
+    }]);
+
+    await getLifecycleCallback()!({ result: {} });
+    const args = send.mock.calls[0][0];
+    expect(args.to).toBeUndefined();
+  });
+
+  it('function to: resolves dynamically', async () => {
+    const { strapi, send, getLifecycleCallback } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([{
+      on: 'lifecycle', model: 'api::x.x', action: 'afterCreate',
+      notification: {
+        title: 'T',
+        to: (ctx) => (ctx as any).entry.vip ? { role: 'strapi-super-admin' } : 'broadcast',
+      },
+    }]);
+
+    await getLifecycleCallback()!({ result: { vip: true } });
+    expect(send).toHaveBeenCalledWith(expect.objectContaining({ to: { role: 'strapi-super-admin' } }));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Mixed rule sets
+// ---------------------------------------------------------------------------
+
+describe('setup with mixed rule types', () => {
+  it('wires all three trigger types independently', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    const rules: NotifierRule[] = [
+      { on: 'lifecycle', model: 'api::a.a', action: 'afterCreate', notification: { title: 'L' } },
+      { on: 'event', event: 'media.upload', notification: { title: 'E' } },
+      { on: 'cron', schedule: '0 3 * * *', notification: { title: 'C' } },
+    ];
+    svc.setup(rules);
+
+    expect(strapi.db.lifecycles.subscribe).toHaveBeenCalledOnce();
+    expect(strapi.eventHub.on).toHaveBeenCalledOnce();
+    expect(strapi.cron.add).toHaveBeenCalledOnce();
+  });
+
+  it('returns immediately without registering anything for empty rules array', () => {
+    const { strapi } = makeStrapi();
+    const svc = makeRulesService({ strapi: strapi as any });
+
+    svc.setup([]);
+
+    expect(strapi.db.lifecycles.subscribe).not.toHaveBeenCalled();
+    expect(strapi.eventHub.on).not.toHaveBeenCalled();
+    expect(strapi.cron.add).not.toHaveBeenCalled();
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+  },
+});