Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

11.0 KB
Raw Blame
import { DataSource, Repository } from 'typeorm';
import { MessageProjector } from './message-projector.service';
import { SessionEngineControls, SessionEngineControlsHost, StopMarks } from './session-engine-controls';
import { EngineRegistry } from '../../engine/engine-registry.service';
import { IWhatsAppEngine, IncomingMessage } from '../../engine/interfaces/whatsapp-engine.interface';
import { Session } from './entities/session.entity';
import { Message } from '../message/entities/message.entity';
import { MessageBatch } from '../message/entities/message-batch.entity';
import { SendIdempotencyKey } from '../message/entities/send-idempotency-key.entity';
import { Webhook } from '../webhook/entities/webhook.entity';
import { WebhookOutboxEvent } from '../webhook/entities/webhook-outbox-event.entity';
import { WebhookDeliveryFailure } from '../webhook/entities/webhook-delivery-failure.entity';
import { IntegrationDeliveryFailure } from '../integration/entities/integration-delivery-failure.entity';
import { Template } from '../template/entities/template.entity';
import { BaileysStoredMessage } from '../../engine/adapters/baileys-stored-message.entity';
import { ChatState } from '../../engine/adapters/baileys-chat-state.entity';
import { StatusUpdate } from '../status-store/entities/status-update.entity';
import { EventsGateway } from '../events/events.gateway';
import { WebhookService } from '../webhook/webhook.service';
import { HookManager } from '../../core/hooks';
import { StatusStoreService } from '../status-store/status-store.service';
import { SessionLidResolver } from './session-lid-resolver.service';
import { captureSessionWrites } from '../../common/utils/session-write-scope';

const deferred = () => {
  let resolve!: () => void;
  const promise = new Promise<void>(done => (resolve = done));
  return { promise, resolve };
};
const settle = (): Promise<void> => new Promise(resolve => setImmediate(resolve));
type Entry = 'inbound' | 'own-send' | 'history';
const entries: Entry[] = ['inbound', 'own-send', 'history'];

// The repository delays dispatch to SQLite to model an asynchronous driver operation. Projection,
// write scopes, the database rows and every child/parent deletion use their actual implementations.
describe('Message projection during session deletion', () => {
  let source: DataSource;
  let messages: Repository<Message>;
  let projector: MessageProjector;
  let controls: SessionEngineControls;
  let engines: EngineRegistry;
  let engine: IWhatsAppEngine;
  let id: string;
  let otherId: string;
  let beforeWrite: jest.Mock<Promise<void>, []>;
  let hook: jest.Mock;
  let retired: ReturnType<typeof deferred>;

  beforeEach(async () => {
    source = new DataSource({
      type: 'better-sqlite3',
      database: ':memory:',
      synchronize: true,
      entities: [
        Session,
        Message,
        MessageBatch,
        SendIdempotencyKey,
        Webhook,
        WebhookOutboxEvent,
        WebhookDeliveryFailure,
        IntegrationDeliveryFailure,
        Template,
        BaileysStoredMessage,
        ChatState,
        StatusUpdate,
      ],
    });
    await source.initialize();
    const sessions = source.getRepository(Session);
    id = (await sessions.save({ name: 'projected', config: {} })).id;
    otherId = (await sessions.save({ name: 'other', config: {} })).id;
    messages = source.getRepository(Message);
    await messages.insert({
      sessionId: otherId,
      waMessageId: 'other',
      chatId: '[email protected]',
      from: '[email protected]',
      to: '[email protected]',
      body: 'other payload',
    });
    beforeWrite = jest.fn<Promise<void>, []>().mockResolvedValue(undefined);
    const guarded: Repository<Message> = Object.create(messages) as Repository<Message>;
    guarded.insert = async entity => {
      await beforeWrite();
      return messages.insert(entity);
    };
    guarded.createQueryBuilder = (...args) => {
      const query = messages.createQueryBuilder(...args);
      const insert = query.insert.bind(query);
      query.insert = () => {
        const writing = insert();
        const execute = writing.execute.bind(writing);
        writing.execute = async () => {
          await beforeWrite();
          return execute();
        };
        return writing;
      };
      return query;
    };
    engines = new EngineRegistry();
    engine = { forceDestroy: jest.fn().mockResolvedValue(undefined) } as unknown as IWhatsAppEngine;
    engines.set(id, engine);
    retired = deferred();
    engines.onRetire(() => retired.resolve());
    hook = jest.fn((_name: string, data: unknown) => Promise.resolve({ continue: true, data }));
    const hooks = { execute: hook } as unknown as HookManager;
    projector = new MessageProjector(
      guarded,
      sessions,
      engines,
      { emitMessage: jest.fn(), emitMessageSent: jest.fn() } as unknown as EventsGateway,
      { dispatch: jest.fn().mockResolvedValue(undefined) } as unknown as WebhookService,
      hooks,
      {} as StatusStoreService,
      {} as SessionLidResolver,
    );
    const store = { clear: jest.fn(), attachTo: (row: Session) => row };
    controls = new SessionEngineControls({
      sessionRepository: sessions,
      engineFactory: { purgeSessionData: jest.fn().mockResolvedValue(undefined) },
      engines,
      sessionErrors: store,
      sessionRestrictions: store,
      presence: store,
      hookManager: hooks,
      logger: { log() {}, warn() {}, error() {}, debug() {} },
      dataSource: () => source,
      fences: {
        awaitPendingTeardown: async () => {},
        awaitInitialStatus: async () => {},
        teardownEngineSafely: async (
          _id: string,
          current: IWhatsAppEngine,
          destroy: (current: IWhatsAppEngine) => Promise<void>,
        ) => {
          await destroy(current);
          return true;
        },
      },
      broadcaster: store,
      cancelReconnect() {},
      stoppingSessions: new StopMarks(),
      operatorTeardowns: new Map(),
      reconnectStates: new Map(),
      stuckAuthRecoveryUsed: new Set(),
      initializingSessions: new Set(),
    } as unknown as SessionEngineControlsHost);
  });

  afterEach(async () => {
    jest.restoreAllMocks();
    await source.destroy();
  });

  const write = async (entry: Entry): Promise<void> => {
    const message: IncomingMessage = {
      id: 'projected-message',
      chatId: '[email protected]',
      from: '[email protected]',
      to: '[email protected]',
      body: 'payload',
      type: 'text',
      timestamp: Math.floor(Date.now() / 1000),
      fromMe: entry === 'own-send',
    } as IncomingMessage;
    if (entry === 'history') {
      await projector.persistHistoryMessages(id, engine, [message]);
      return;
    }
    const ticket = projector.admitInbound(id, engine, {
      id: message.id,
      chatId: message.chatId,
      needsRoom: false,
      status: false,
      fromMe: message.fromMe,
    });
    if (entry === 'inbound') {
      await projector.handleInboundMessage(id, engine, message, ticket)?.settled;
      return;
    }
    projector.handleOwnSendEcho(id, engine, message, ticket);
    const queues = projector as unknown as { chatCommits: { size: number } };
    const end = Date.now() + 3000;
    while (queues.chatCommits.size) {
      if (Date.now() > end) throw new Error('Own-send commit did not settle');
      await settle();
    }
  };

  const expectDeleted = async () => {
    expect(await source.getRepository(Session).existsBy({ id })).toBe(false);
    expect(await messages.countBy({ sessionId: id })).toBe(0);
    expect(await source.getRepository(Session).existsBy({ id: otherId })).toBe(true);
    expect(await messages.countBy({ sessionId: otherId })).toBe(1);
  };

  describe.each(entries)('%s', entry => {
    it.each([false, true])('drains a pending insert before deletion, rejecting=%s', async reject => {
      const entered = deferred(),
        release = deferred();
      beforeWrite.mockImplementation(async () => {
        entered.resolve();
        await release.promise;
        if (reject) throw new Error('Insert unavailable');
      });
      const projection = write(entry).catch(error => error as Error);
      await entered.promise;
      const removing = jest.fn();
      const deletion = controls.delete(id, { onRemoving: removing });
      try {
        await retired.promise;
        await settle();
        expect(removing).not.toHaveBeenCalled();
      } finally {
        release.resolve();
        await Promise.all([projection, deletion]);
      }
      expect(removing).toHaveBeenCalledTimes(1);
      if (reject && entry === 'history') expect(await projection).toEqual(new Error('Insert unavailable'));
      await expectDeleted();
    });

    it('preserves completed persistence and lets an outer write scope drain', async () => {
      const outer = captureSessionWrites(source, id);
      try {
        await outer.write(() => write(entry));
        expect(await messages.countBy({ sessionId: id })).toBe(1);
        await controls.delete(id);
        await expectDeleted();
      } finally {
        outer.close();
      }
    });
  });

  describe.each(['inbound', 'own-send'] as const)('%s retries', entry => {
    it('drains the retry insert before deleting its row', async () => {
      const entered = deferred(),
        release = deferred();
      beforeWrite.mockRejectedValueOnce(Object.assign(new Error('database is locked'), { code: 'SQLITE_BUSY' }));
      beforeWrite.mockImplementation(async () => {
        entered.resolve();
        await release.promise;
      });
      const projection = write(entry);
      await entered.promise;
      const removing = jest.fn();
      const deletion = controls.delete(id, { onRemoving: removing });
      try {
        await retired.promise;
        await settle();
        expect(removing).not.toHaveBeenCalled();
      } finally {
        release.resolve();
        await Promise.all([projection, deletion]);
      }
      expect(beforeWrite).toHaveBeenCalledTimes(2);
      await expectDeleted();
    });

    it('does not hold deletion across retry backoff or retry a retired engine', async () => {
      const failed = deferred();
      beforeWrite.mockImplementation(() => {
        failed.resolve();
        return Promise.reject(Object.assign(new Error('database is locked'), { code: 'SQLITE_BUSY' }));
      });
      const projection = write(entry);
      await failed.promise;
      await controls.delete(id);
      await projection;
      expect(beforeWrite).toHaveBeenCalledTimes(1);
      await expectDeleted();
    });

    it('does not hold deletion across a pending hook', async () => {
      const entered = deferred(),
        release = deferred();
      hook.mockImplementation(async (name: string, data: unknown) => {
        if (name === (entry === 'inbound' ? 'message:received' : 'message:sent')) {
          entered.resolve();
          await release.promise;
        }
        return { continue: true, data };
      });
      const projection = write(entry);
      await entered.promise;
      try {
        await controls.delete(id);
      } finally {
        release.resolve();
        await projection;
      }
      expect(beforeWrite).not.toHaveBeenCalled();
      await expectDeleted();
    });
  });
});