Wiki/bridge/tests/webhooks/baserow-handler.test.ts

/**
 * Tests handler webhooks Baserow — generique R1 (plus de cascade rollup metier).
 * R3.1.b : tests de la publication SSE via streamRedis.
 */

import type { Redis } from 'ioredis';
import pino from 'pino';
import { describe, expect, it, vi } from 'vitest';
import type { RedisCache } from '../../src/adapters/redis-cache.js';
import { handleBaserowEvent } from '../../src/webhooks/baserow-handler.js';
import type { BaserowWebhookPayload } from '../../src/webhooks/types.js';

class FakeRedis {
  public calls: string[] = [];
  invalidatePattern(pattern: string): Promise<number> {
    this.calls.push(pattern);
    return Promise.resolve(1);
  }
}

const silentLogger = () => pino({ level: 'silent' });

function makePayload(over: Partial<BaserowWebhookPayload> = {}): BaserowWebhookPayload {
  return {
    event_id: 'evt-1',
    event_type: 'rows.created',
    table_id: 42,
    items: [{ id: 100 }],
    ...over,
  } as BaserowWebhookPayload;
}

describe('handleBaserowEvent (R1 generique)', () => {
  it('rows.created sur tableId -> invalide list + views (pas row precis)', async () => {
    const redis = new FakeRedis();
    const res = await handleBaserowEvent(makePayload(), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
    });
    expect(res.status).toBe('processed');
    expect(res.tableId).toBe(42);
    expect(redis.calls).toContain('bridge:tables:42:list:*');
    expect(redis.calls).toContain('bridge:tables:42:views:*');
    expect(redis.calls).not.toContain('bridge:tables:42:row:100');
  });

  it('rows.updated -> invalide list + views + row precis', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'rows.updated', items: [{ id: 100 }, { id: 101 }] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    expect(redis.calls).toContain('bridge:tables:42:row:100');
    expect(redis.calls).toContain('bridge:tables:42:row:101');
    expect(redis.calls).toContain('bridge:tables:42:list:*');
    expect(redis.calls).toContain('bridge:tables:42:views:*');
  });

  it('rows.deleted -> invalide list + views + row precis', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'rows.deleted', table_id: 5, items: [{ id: 200 }] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    expect(redis.calls).toContain('bridge:tables:5:row:200');
  });

  it('aucune cascade cross-table : invalidation limitee a tableId + views:data wildcard', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'rows.updated', table_id: 7, items: [{ id: 1 }] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    // R3.1.a : views:data:* est un pattern global car on ne connait pas les viewIds
    // appartenant a la table 7 depuis le payload rows.*.
    const tablePatterns = redis.calls.filter((p) => p.startsWith('bridge:tables:7:'));
    expect(tablePatterns).toContain('bridge:tables:7:list:*');
    expect(tablePatterns).toContain('bridge:tables:7:views:*');
    expect(redis.calls).toContain('views:data:*');
  });

  it('table_id <= 0 -> ignored, aucune invalidation', async () => {
    const redis = new FakeRedis();
    const res = await handleBaserowEvent(makePayload({ table_id: 0 }), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
    });
    expect(res.status).toBe('ignored');
    expect(res.tableId).toBeNull();
    expect(redis.calls).toHaveLength(0);
  });

  it('rows.created sans items -> invalide list + views, pas de row precis', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(makePayload({ event_type: 'rows.created', items: [] }), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
    });
    expect(redis.calls).toContain('bridge:tables:42:list:*');
    expect(redis.calls).toContain('bridge:tables:42:views:*');
    expect(redis.calls.some((p) => p.includes(':row:'))).toBe(false);
  });

  // R3.1.a : events view.*
  it('view.created -> invalide views:table:<tableId> + views:data wildcard', async () => {
    const redis = new FakeRedis();
    const res = await handleBaserowEvent(
      makePayload({ event_type: 'view.created', table_id: 42, view_id: 100, items: [] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    expect(res.status).toBe('processed');
    expect(redis.calls).toContain('views:table:42');
    expect(redis.calls).toContain('views:data:100:*');
  });

  it('view.updated -> invalide views:table + views:data de la vue precise', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'view.updated', table_id: 5, view_id: 200, items: [] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    expect(redis.calls).toContain('views:table:5');
    expect(redis.calls).toContain('views:data:200:*');
    // Les rows ne sont PAS invalides — c'est une mutation de metadonnees vue.
    expect(redis.calls.some((p) => p.includes('bridge:tables:'))).toBe(false);
  });

  it('view.deleted -> invalide views:table (sans view_id precise)', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(makePayload({ event_type: 'view.deleted', table_id: 5, items: [] }), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
    });
    expect(redis.calls).toContain('views:table:5');
    // Sans view_id : pas de pattern views:data:*:* precise.
    expect(redis.calls.some((p) => /^views:data:\d+/.test(p))).toBe(false);
  });

  it('view.* invalide que le metadata views, pas les rows', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'view.updated', table_id: 42, view_id: 100, items: [] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    expect(redis.calls.every((p) => !p.startsWith('bridge:tables:'))).toBe(true);
  });

  it('renvoie le total des keys invalidees', async () => {
    const redis = new FakeRedis();
    const res = await handleBaserowEvent(
      makePayload({ event_type: 'rows.updated', items: [{ id: 1 }, { id: 2 }] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    // R3.1.a : 5 patterns — list:*, views:* (tables keyspace), views:data:* (R3.1.a), row:1, row:2.
    expect(res.invalidatedKeys).toBe(5);
  });

  it('sans streamRedis, publishedEventId est null', async () => {
    const redis = new FakeRedis();
    const res = await handleBaserowEvent(makePayload(), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
      // Pas de streamRedis — mode dégradé sans clients SSE.
    });
    expect(res.publishedEventId).toBeNull();
  });
});

describe('handleBaserowEvent R3.1.b — publication SSE', () => {
  /**
   * Fake Redis Streams : simule xadd et retourne un ID déterministe.
   */
  class FakeStreamRedis {
    public xaddCalls: Array<{ key: string; fields: string[] }> = [];
    private seq = 0;

    async xadd(key: string, ...args: unknown[]): Promise<string> {
      // args = ['MAXLEN', '~', maxLen, '*', ...fields]
      const fieldsStart = args.indexOf('*') + 1;
      const fields = args.slice(fieldsStart) as string[];
      this.xaddCalls.push({ key, fields });
      return `${Date.now()}-${++this.seq}`;
    }
  }

  it('rows.created -> publie un event row.created sur le stream', async () => {
    const redis = new FakeRedis();
    const streamRedis = new FakeStreamRedis();
    const res = await handleBaserowEvent(
      makePayload({ event_type: 'rows.created', table_id: 42, items: [{ id: 100 }] }),
      {
        redis: redis as unknown as RedisCache,
        logger: silentLogger(),
        streamRedis: streamRedis as unknown as Redis,
      },
    );

    expect(res.publishedEventId).not.toBeNull();
    expect(streamRedis.xaddCalls).toHaveLength(1);
    const { fields } = streamRedis.xaddCalls[0];
    const map: Record<string, string> = {};
    for (let i = 0; i < fields.length; i += 2) map[fields[i]] = fields[i + 1];
    expect(map.type).toBe('row.created');
    expect(map.tableId).toBe('42');
    expect(map.rowId).toBe('100');
  });

  it('rows.updated avec 2 items -> publie 2 events row.updated', async () => {
    const redis = new FakeRedis();
    const streamRedis = new FakeStreamRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'rows.updated', items: [{ id: 1 }, { id: 2 }] }),
      {
        redis: redis as unknown as RedisCache,
        logger: silentLogger(),
        streamRedis: streamRedis as unknown as Redis,
      },
    );
    expect(streamRedis.xaddCalls).toHaveLength(2);
    for (const call of streamRedis.xaddCalls) {
      const map: Record<string, string> = {};
      for (let i = 0; i < call.fields.length; i += 2) map[call.fields[i]] = call.fields[i + 1];
      expect(map.type).toBe('row.updated');
    }
  });

  it('rows.deleted -> publie un event row.deleted sans row payload', async () => {
    const redis = new FakeRedis();
    const streamRedis = new FakeStreamRedis();
    await handleBaserowEvent(makePayload({ event_type: 'rows.deleted', items: [{ id: 5 }] }), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
      streamRedis: streamRedis as unknown as Redis,
    });
    const { fields } = streamRedis.xaddCalls[0];
    const map: Record<string, string> = {};
    for (let i = 0; i < fields.length; i += 2) map[fields[i]] = fields[i + 1];
    expect(map.type).toBe('row.deleted');
    // row.deleted ne doit pas inclure de payload row.
    expect(map.row).toBeUndefined();
  });

  it('view.created -> publie un event view.created avec viewId', async () => {
    const redis = new FakeRedis();
    const streamRedis = new FakeStreamRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'view.created', table_id: 5, view_id: 200, items: [] }),
      {
        redis: redis as unknown as RedisCache,
        logger: silentLogger(),
        streamRedis: streamRedis as unknown as Redis,
      },
    );
    expect(streamRedis.xaddCalls).toHaveLength(1);
    const { fields } = streamRedis.xaddCalls[0];
    const map: Record<string, string> = {};
    for (let i = 0; i < fields.length; i += 2) map[fields[i]] = fields[i + 1];
    expect(map.type).toBe('view.created');
    expect(map.viewId).toBe('200');
  });

  it('rows.created sans items -> publie un event table.updated', async () => {
    const redis = new FakeRedis();
    const streamRedis = new FakeStreamRedis();
    await handleBaserowEvent(makePayload({ event_type: 'rows.created', items: [] }), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
      streamRedis: streamRedis as unknown as Redis,
    });
    expect(streamRedis.xaddCalls).toHaveLength(1);
    const { fields } = streamRedis.xaddCalls[0];
    const map: Record<string, string> = {};
    for (let i = 0; i < fields.length; i += 2) map[fields[i]] = fields[i + 1];
    expect(map.type).toBe('table.updated');
  });

  it('table_id invalide -> ignoré, pas de publication SSE', async () => {
    const redis = new FakeRedis();
    const streamRedis = new FakeStreamRedis();
    await handleBaserowEvent(makePayload({ table_id: 0 }), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
      streamRedis: streamRedis as unknown as Redis,
    });
    expect(streamRedis.xaddCalls).toHaveLength(0);
  });

  it('erreur xadd est loggée mais ne lève pas d exception (non-critique)', async () => {
    const redis = new FakeRedis();
    const failingStreamRedis = {
      xadd: vi.fn().mockRejectedValue(new Error('Redis connection lost')),
    } as unknown as Redis;

    // Doit résoudre sans throw même si xadd échoue.
    const res = await handleBaserowEvent(makePayload(), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
      streamRedis: failingStreamRedis,
    });
    // La cache invalidation a quand même eu lieu.
    expect(res.invalidatedKeys).toBeGreaterThan(0);
    // publishedEventId est null car xadd a échoué.
    expect(res.publishedEventId).toBeNull();
  });
});