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

/**
 * Tests handler webhooks Baserow — generique R1 (plus de cascade rollup metier).
 */

import pino from 'pino';
import { describe, expect, it } 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);
  });
});